Changeset 378 for cpp

Timestamp:

04/27/15 04:44:23 (10 years ago)

Author:

Maciej Komosinski

Message:

Improved argument variable names; changed implementation to use STL classes (vector, string)

Location:

cpp/frams/loggers

Files:

• loggers.cpp (modified) (2 diffs)
• loggers.h (modified) (8 diffs)
• loggertostdout.cpp (modified) (1 diff)
• loggertostdout.h (modified) (1 diff)

cpp/frams/loggers/loggers.cpp

@@ -6 +6 @@
 #include <common/stl-util.h>
 
-void _logMessageSingleLine(const char *o, const char *m, int w, const char *txt)
+void _logMessageSingleLine(const char *obj, const char *method, int level, const char *msg)
 {
-        tlsGetRef(message_handler_manager_instance).send(o, m, w, txt);
+        tlsGetRef(message_handler_manager_instance).send(obj, method, level, msg);
 }
 
 THREAD_LOCAL_DEF(LoggerManager, message_handler_manager_instance);
 
-void LoggerManager::send(int level, const char *o, const char *m, int w, const char *bl)
+void LoggerManager::send(int position, const char *obj, const char *method, int level, const char *msg)
 {
-        if (level >= handlers.size()) level = handlers.size() - 1;
-        bool blocked = 0;
-        for (int i = level; i >= 0; i--)
+        if (position >= (int)loggers.size()) position = loggers.size() - 1;
+        bool blocked = false;
+        for (int i = position; i >= 0; i--)
         {
-                LoggerBase *r = handlers(i);
-                if ((!(r->options & LoggerBase::Paused)) &&
-                        ((!blocked) || (r->options & LoggerBase::CannotBeBlocked)))
+                LoggerBase *logger = loggers[i];
+                if ((!(logger->options & LoggerBase::Paused)) &&
+                        ((!blocked) || (logger->options & LoggerBase::CannotBeBlocked)))
                 {
-                        r->handle(o, m, w, bl);
-                        if (!(r->options & LoggerBase::DontBlock)) blocked = 1;
+                        logger->handle(obj, method, level, msg);
+                        if (!(logger->options & LoggerBase::DontBlock)) blocked = true;
                 }
         }
 }
 
-int LoggerManager::add(LoggerBase *h)
+int LoggerManager::add(LoggerBase *logger)
 {
-        h->manager = this;
-        handlers += h;
-        return handlers.size() - 1;
+        logger->manager = this;
+        loggers.push_back(logger);
+        return loggers.size() - 1;
 }
 
 void LoggerManager::remove(int i)
 {
-        LoggerBase *h = handlers(i);
+        LoggerBase *h = loggers[i];
         h->manager = NULL;
-        handlers.remove(i);
+        loggers.erase(loggers.begin() + i);
 }
 
-void LoggerManager::remove(LoggerBase *h)
+void LoggerManager::remove(LoggerBase *logger)
 {
-        int i;
-        if ((i = handlers.find(h)) < 0) return;
-        remove(i);
+        int index = find(logger);
+        if (index >= 0)
+                remove(index);
 }
 
 void LoggerManager::removeAll()
 {
-        while (handlers.size() > 0)
-                remove(handlers.size() - 1);
+        while (loggers.size() > 0)
+                remove(loggers.size() - 1);
 }
 
 //////////////////////////////////
 
-void LoggerBase::send(const char *o, const char *m, int w, const char *bl)
+void LoggerBase::send(const char *obj, const char *method, int level, const char *msg)
 {
         if (!isEnabled()) return;
-        int level = manager->find(this);
-        if (level >= 0) manager->send(level - 1, o, m, w, bl);
+        int position = manager->find(this);
+        if (position >= 0) manager->send(position - 1, obj, method, level, msg);
 }
 
-void LoggerBase::logPrintf(const char *o, const char *m, int w, const char *bl, ...)
+void LoggerBase::logPrintf(const char *obj, const char *method, int level, const char *msg, ...)
 {
         if (!isEnabled()) return;
         string buf;
         va_list argptr;
-        va_start(argptr, bl);
-        buf = ssprintf_va(bl, argptr);
+        va_start(argptr, msg);
+        buf = ssprintf_va(msg, argptr);
         va_end(argptr);
-        send(o, m, w, buf.c_str());
+        send(obj, method, level, buf.c_str());
 }
 
@@ -103 +103 @@
 /////////////////////////////////
 
-void LoggerToMemory::handle(const char *o, const char *m, int w, const char *bl)
+void LoggerToMemory::handle(const char *obj, const char *method, int level, const char *msg)
 {
-        if (w > maxlevel) maxlevel = w;
-        if (w >= LOG_INFO) infocount++;
-        if (w >= LOG_WARN) warncount++;
-        if (w >= LOG_ERROR) errcount++;
+        if (level > maxlevel) maxlevel = level;
+        if (level >= LOG_INFO) infocount++;
+        if (level >= LOG_WARN) warncount++;
+        if (level >= LOG_ERROR) errcount++;
 
-        if (w >= minleveltostore)
+        if (level >= minleveltostore)
         {
                 storedcount++;
                 if (options & (StoreFirstMessage | StoreAllMessages))
                 {
-                        if (!((options&StoreFirstMessage) && (msgs.len() > 0)))
+                        if (!((options&StoreFirstMessage) && (msgs.length() > 0)))
                         {
-                                if (msgs.len() > 0) msgs += '\n';
-                                msgs += SString::sprintf(LOG_FORMAT,LOG_LEVEL[w+1],o,m,bl);
+                                if (msgs.length() > 0) msgs += '\n';
+                                msgs += ssprintf(LOG_FORMAT, LOG_LEVEL[level + 1], obj, method, msg);
                         }
                 }

cpp/frams/loggers/loggers.h

@@ -3 +3 @@
 // See LICENSE.txt for details.
 
-#ifndef _FRAMS_LOGGERS_H_
-#define _FRAMS_LOGGERS_H_
+#ifndef _COMMON_LOGGERS_H_
+#define _COMMON_LOGGERS_H_
 
-#include <frams/util/list.h>
-#include <frams/util/sstring.h>
 #include <common/log.h>
 #include <common/threads.h>
+#include <common/nonstd_stl.h>
 
 class LoggerBase;
@@ -16 +15 @@
 {
         friend class LoggerBase;
-        SListTempl<LoggerBase*> handlers;
-        void send(int level, const char *o, const char *m, int w, const char *bl);
+        vector<LoggerBase*> loggers;
+        void send(int position, const char *obj, const char *method, int level, const char *msg);
 public:
-        int find(LoggerBase *r) { return handlers.find(r); }
-        int add(LoggerBase *r);
+        int find(LoggerBase *logger)
+        {
+                vector<LoggerBase*>::iterator it = std::find(loggers.begin(), loggers.end(), logger);
+                return it == loggers.end() ? -1 : std::distance(loggers.begin(), it);
+        }
+        int add(LoggerBase *logger);
         void remove(int i);
-        void remove(LoggerBase *r);
+        void remove(LoggerBase *logger);
         void removeAll();
-        void send(const char *o, const char *m, int w, const char *bl)
+        void send(const char *obj, const char *method, int level, const char *msg)
         {
-                send(handlers.size() - 1, o, m, w, bl);
+                send(loggers.size() - 1, obj, method, level, msg);
         }
         ~LoggerManager() { removeAll(); }
@@ -50 +53 @@
 
         void logPrintf(const char *o, const char *m, int w, const char *bl, ...);
-        void send(const char *o, const char *m, int w, const char *bl);
+        void send(const char *obj, const char *method, int level, const char *msg);
 
         bool isEnabled() { return manager ? true : false; }
@@ -68 +71 @@
         }
 
-        virtual void handle(const char *o, const char *m, int w, const char *bl) {}
+        virtual void handle(const char *obj, const char *method, int level, const char *msg) {}
 };
 
@@ -76 +79 @@
 {
 protected:
-        int maxlevel, minleveltostore, errcount, warncount, storedcount, infocount;
-        SString msgs;
+        int maxlevel, minleveltostore, errcount, warncount, infocount, storedcount;
+        string msgs;
 
 public:
 
-        void reset() { maxlevel = LOG_INFO - 1; errcount = warncount = storedcount = infocount = 0; msgs = 0; }
+        void reset() { maxlevel = LOG_INFO - 1; errcount = warncount = infocount = storedcount = 0; msgs = ""; }
 
         enum Options2
@@ -93 +96 @@
         int getStoredCount()      { return storedcount; }
         int getErrorLevel()       { return maxlevel; }
-        const SString& getMessages() { return msgs; }
+        const string getMessages() { return msgs; }
 
         LoggerToMemory(int opts = 0, int minimal_level_to_store = LOG_ERROR) :LoggerBase(opts), minleveltostore(minimal_level_to_store)
@@ -100 +103 @@
         }
 
-        void handle(const char *o, const char *m, int w, const char *bl);
+        void handle(const char *obj, const char *method, int level, const char *msg);
 };
 
@@ -107 +110 @@
         LoggerManager *other_manager;
 public:
-        RedirectingLogger(LoggerManager *other_mgr,int opts=0)
+        RedirectingLogger(LoggerManager *other_mgr, int opts = 0)
                 :LoggerBase(opts), other_manager(other_mgr) {}
 
-        void handle(const char *o, const char *m, int w, const char *bl)
+        void handle(const char *obj, const char *method, int level, const char *msg)
         {
-                other_manager->send(o, m, w, bl);
+                other_manager->send(obj, method, level, msg);
         }
 };

cpp/frams/loggers/loggertostdout.cpp

@@ -10 +10 @@
 #endif
 
-void LoggerToStdout::handle(const char *o, const char *m, int w, const char *bl)
+void LoggerToStdout::handle(const char *obj, const char *method, int level, const char *msg)
 {
-        if (w < -1) w = -1; else if (w>3) w = 3;
+        if (level < -1) level = -1; else if (level>3) level = 3;
 #ifdef SHP
-        AppLog(LOG_FORMAT "\n",LOG_LEVEL[w+1],o,m,bl);
+        AppLog(LOG_FORMAT "\n",LOG_LEVEL[level+1],obj,method,msg);
 #else
         if (file)
-                file->printf(LOG_FORMAT "\n", LOG_LEVEL[w + 1], o, m, bl);
+                file->printf(LOG_FORMAT "\n", LOG_LEVEL[level + 1], obj, method, msg);
         else
-                printf(LOG_FORMAT "\n", LOG_LEVEL[w + 1], o, m, bl);
+                printf(LOG_FORMAT "\n", LOG_LEVEL[level + 1], obj, method, msg);
 #endif
 }

cpp/frams/loggers/loggertostdout.h

@@ -14 +14 @@
 public:
         LoggerToStdout(int opts = 0, VirtFILE *_file = NULL) :LoggerBase(opts), file(_file) {}
-        void handle(const char *o, const char *m, int w, const char *bl);
+        void handle(const char *obj, const char *method, int level, const char *msg);
 };