renamings

IntelRealSense · Jan 5, 2021 · 52347ec · 52347ec
1 parent 2e8b399
commit 52347ec
Show file tree

Hide file tree

Showing 2 changed files with 28 additions and 28 deletions.
diff --git a/third-party/easyloggingpp/src/easylogging++.cc b/third-party/easyloggingpp/src/easylogging++.cc
@@ -2081,8 +2081,8 @@ Storage::Storage(const LogBuilderPtr& defaultLogBuilder) :
   m_flags(ELPP_DEFAULT_LOGGING_FLAGS),
   m_vRegistry(new base::VRegistry(0, &m_flags)),
 #if ELPP_ASYNC_LOGGING
-    m_asyncLogQueueWrite(new base::AsyncLogQueue()),
-    m_asyncLogQueueRead(new base::AsyncLogQueue()),
+    m_asyncLogWriteQueue(new base::AsyncLogQueue()),
+    m_asyncLogReadQueue(new base::AsyncLogQueue()),
   m_asyncDispatchWorker(asyncDispatchWorker),
 #endif  // ELPP_ASYNC_LOGGING
   m_preRollOutCallback(base::defaultPreRollOutCallback) {
@@ -2129,8 +2129,8 @@ Storage::~Storage(void) {
   ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker");
   base::utils::safeDelete(m_asyncDispatchWorker);
   ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueues");
-  base::utils::safeDelete(m_asyncLogQueueWrite);
-  base::utils::safeDelete(m_asyncLogQueueRead);
+  base::utils::safeDelete(m_asyncLogWriteQueue);
+  base::utils::safeDelete(m_asyncLogReadQueue);
 #endif  // ELPP_ASYNC_LOGGING
   ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters");
   base::utils::safeDelete(m_registeredHitCounters);
@@ -2319,7 +2319,7 @@ void AsyncLogDispatchCallback::handle(const LogDispatchData* data) {
   auto conf = data->logMessage()->logger()->typedConfigurations();
   if (conf->toStandardOutput(data->logMessage()->level()) ||
       conf->toFile(data->logMessage()->level())) {
-    ELPP->asyncLogQueueWrite()->push(AsyncLogItem(*(data->logMessage()), *data, logLine));
+    ELPP->asyncLogWriteQueue()->push(AsyncLogItem(*(data->logMessage()), *data, logLine));
   }
 }
 
@@ -2343,23 +2343,23 @@ bool AsyncDispatchWorker::clean(void) {
   std::unique_lock<std::mutex> lk(_mtx);
   try
   {
-      moveWriteQueueToReadQueue();
-      emptyQueueRead();
+      fetchLogQueue();
+      emptyLogQueue();
   }
   catch(...){}
   lk.unlock();
   cv.notify_one();
-  return (ELPP && ELPP->asyncLogQueueWrite() && ELPP->asyncLogQueueWrite()->empty() && ELPP->asyncLogQueueRead() && ELPP->asyncLogQueueRead()->empty());
+  return (ELPP && ELPP->asyncLogWriteQueue() && ELPP->asyncLogWriteQueue()->empty() && ELPP->asyncLogReadQueue() && ELPP->asyncLogReadQueue()->empty());
 }
 
-void AsyncDispatchWorker::emptyQueueRead(void) {
-  if (ELPP && ELPP->asyncLogQueueRead())
+void AsyncDispatchWorker::emptyLogQueue(void) {
+  if (ELPP && ELPP->asyncLogReadQueue())
   {
       try // TODO Thread-safety
       {
-        for (auto i=0UL; i < ELPP->asyncLogQueueRead()->size(); i++)
+        for (auto i=0UL; i < ELPP->asyncLogReadQueue()->size(); i++)
         {
-          AsyncLogItem data = ELPP->asyncLogQueueRead()->next();
+          AsyncLogItem data = ELPP->asyncLogReadQueue()->next();
           handle(&data);
         }
       }
@@ -2435,24 +2435,24 @@ void AsyncDispatchWorker::handle(AsyncLogItem* logItem) {
 #  endif  // defined(ELPP_SYSLOG)
 }
 
-void AsyncDispatchWorker::moveWriteQueueToReadQueue()
+void AsyncDispatchWorker::fetchLogQueue()
 {
-    if (ELPP && ELPP->asyncLogQueueWrite() && ELPP->asyncLogQueueWrite()->size() > 0) {
-        base::threading::ScopedLock scopedLockW(ELPP->asyncLogQueueWrite()->lock());
-        base::threading::ScopedLock scopedLockR(ELPP->asyncLogQueueRead()->lock());
-        ELPP->asyncLogQueueWrite()->appendTo(ELPP->asyncLogQueueRead());
-        ELPP->asyncLogQueueWrite()->clear();
+    if (ELPP && ELPP->asyncLogWriteQueue() && ELPP->asyncLogWriteQueue()->size() > 0) {
+        base::threading::ScopedLock scopedLockW(ELPP->asyncLogWriteQueue()->lock());
+        base::threading::ScopedLock scopedLockR(ELPP->asyncLogReadQueue()->lock());
+        ELPP->asyncLogWriteQueue()->appendTo(ELPP->asyncLogReadQueue());
+        ELPP->asyncLogWriteQueue()->clear();
     }
 }
 
 void AsyncDispatchWorker::run(void) {
     while (continueRunning()) {
         if (ELPP) {
             base::threading::ScopedLock scopedLock(ELPP->configLock());
-            emptyQueueRead();
+            emptyLogQueue();
         }
         std::this_thread::sleep_for(std::chrono::milliseconds(5));
-        moveWriteQueueToReadQueue();    
+        fetchLogQueue();    
     }
 }
 #endif  // ELPP_ASYNC_LOGGING

diff --git a/third-party/easyloggingpp/src/easylogging++.h b/third-party/easyloggingpp/src/easylogging++.h
@@ -2599,12 +2599,12 @@ class Storage : base::NoCopy, public base::threading::ThreadSafe {
   }
 
 #if ELPP_ASYNC_LOGGING
-  inline base::AsyncLogQueue* asyncLogQueueWrite(void) const {
-    return m_asyncLogQueueWrite;
+  inline base::AsyncLogQueue* asyncLogWriteQueue(void) const {
+    return m_asyncLogWriteQueue;
   }
 
-  inline base::AsyncLogQueue* asyncLogQueueRead(void) const {
-      return m_asyncLogQueueRead;
+  inline base::AsyncLogQueue* asyncLogReadQueue(void) const {
+      return m_asyncLogReadQueue;
   }
 
   inline base::AsyncDispatchWorker* asyncDispatchWorker(void) const {
@@ -2722,8 +2722,8 @@ class Storage : base::NoCopy, public base::threading::ThreadSafe {
   base::type::EnumType m_flags;
   base::VRegistry* m_vRegistry;
 #if ELPP_ASYNC_LOGGING
-  base::AsyncLogQueue* m_asyncLogQueueWrite; 
-  base::AsyncLogQueue* m_asyncLogQueueRead;
+  base::AsyncLogQueue* m_asyncLogWriteQueue; 
+  base::AsyncLogQueue* m_asyncLogReadQueue;
   base::IWorker* m_asyncDispatchWorker;
   base::threading::Mutex m_configLock;
 #endif  // ELPP_ASYNC_LOGGING
@@ -2771,11 +2771,11 @@ class AsyncDispatchWorker : public base::IWorker, public base::threading::Thread
   virtual ~AsyncDispatchWorker();
 
   bool clean(void);
-  void emptyQueueRead(void);
+  void emptyLogQueue(void);
   virtual void start(void);
   void handle(AsyncLogItem* logItem);
   void run(void);
-  void moveWriteQueueToReadQueue();
+  void fetchLogQueue();
 
   void setContinueRunning(bool value) {
     base::threading::ScopedLock scopedLock(m_continueRunningLock);