common: Update Finisher.h to work without using namespace

Signed-off-by: Adam C. Emerson <aemerson@redhat.com>

diff --git a/src/common/Finisher.h b/src/common/Finisher.h
index cca3f81c884352509835216ade20856df0011715..b70b600af6c2c3e57080f7f948aa79bf01e8ddcf 100644 (file)
--- a/src/common/Finisher.h
+++ b/src/common/Finisher.h
@@ -46,18 +46,18 @@ class Finisher {
   bool        finisher_empty_wait; ///< True mean someone wait finisher empty.
 
   /// Queue for contexts for which complete(0) will be called.
-  vector<pair<Context*,int>> finisher_queue;
+  std::vector<std::pair<Context*,int>> finisher_queue;
 
-  string thread_name;
+  std::string thread_name;
 
   /// Performance counter for the finisher's queue length.
   /// Only active for named finishers.
   PerfCounters *logger;
-  
+
   void *finisher_thread_entry();
 
   struct FinisherThread : public Thread {
-    Finisher *fin;    
+    Finisher *fin;
     explicit FinisherThread(Finisher *f) : fin(f) {}
     void* entry() override { return fin->finisher_thread_entry(); }
   } finisher_thread;
@@ -69,47 +69,47 @@ class Finisher {
     if (finisher_queue.empty()) {
       finisher_cond.notify_all();
     }
-    finisher_queue.push_back(make_pair(c, r));
+    finisher_queue.push_back(std::make_pair(c, r));
     if (logger)
       logger->inc(l_finisher_queue_len);
   }
 
-  void queue(list<Context*>& ls) {
+  void queue(std::list<Context*>& ls) {
     {
       std::unique_lock ul(finisher_lock);
       if (finisher_queue.empty()) {
        finisher_cond.notify_all();
       }
       for (auto i : ls) {
-       finisher_queue.push_back(make_pair(i, 0));
+       finisher_queue.push_back(std::make_pair(i, 0));
       }
       if (logger)
        logger->inc(l_finisher_queue_len, ls.size());
     }
     ls.clear();
   }
-  void queue(deque<Context*>& ls) {
+  void queue(std::deque<Context*>& ls) {
     {
       std::unique_lock ul(finisher_lock);
       if (finisher_queue.empty()) {
        finisher_cond.notify_all();
       }
       for (auto i : ls) {
-       finisher_queue.push_back(make_pair(i, 0));
+       finisher_queue.push_back(std::make_pair(i, 0));
       }
       if (logger)
        logger->inc(l_finisher_queue_len, ls.size());
     }
     ls.clear();
   }
-  void queue(vector<Context*>& ls) {
+  void queue(std::vector<Context*>& ls) {
     {
       std::unique_lock ul(finisher_lock);
       if (finisher_queue.empty()) {
        finisher_cond.notify_all();
       }
       for (auto i : ls) {
-       finisher_queue.push_back(make_pair(i, 0));
+       finisher_queue.push_back(std::make_pair(i, 0));
       }
       if (logger)
        logger->inc(l_finisher_queue_len, ls.size());
@@ -142,12 +142,12 @@ class Finisher {
     finisher_thread(this) {}
 
   /// Construct a named Finisher that logs its queue length.
-  Finisher(CephContext *cct_, string name, string tn) :
+  Finisher(CephContext *cct_, std::string name, std::string tn) :
     cct(cct_), finisher_lock(ceph::make_mutex("Finisher::" + name)),
     finisher_stop(false), finisher_running(false), finisher_empty_wait(false),
     thread_name(tn), logger(0),
     finisher_thread(this) {
-    PerfCountersBuilder b(cct, string("finisher-") + name,
+    PerfCountersBuilder b(cct, std::string("finisher-") + name,
                          l_finisher_first, l_finisher_last);
     b.add_u64(l_finisher_queue_len, "queue_len");
     b.add_time_avg(l_finisher_complete_lat, "complete_latency");
@@ -189,7 +189,7 @@ public:
 };
 
 class ContextQueue {
-  list<Context *> q;
+  std::list<Context *> q;
   std::mutex q_mutex;
   ceph::mutex& mutex;
   ceph::condition_variable& cond;
@@ -198,7 +198,7 @@ public:
               ceph::condition_variable& con)
     : mutex(mut), cond(con) {}
 
-  void queue(list<Context *>& ls) {
+  void queue(std::list<Context *>& ls) {
     bool empty = false;
     {
       std::scoped_lock l(q_mutex);
@@ -218,7 +218,7 @@ public:
     ls.clear();
   }
 
-  void swap(list<Context *>& ls) {
+  void swap(std::list<Context *>& ls) {
     ls.clear();
     std::scoped_lock l(q_mutex);
     if (!q.empty()) {