initial import of latest svn version

1 files changed, 273 insertions, 0 deletions

diff --git a/src/util/consoleLogger.h b/src/util/consoleLogger.h
new file mode 100644
index 0000000..3a0950d
--- /dev/null
+++ b/src/util/consoleLogger.h
@@ -0,0 +1,273 @@
+
+#include "util.h"
+#include "dispatcher.h"
+#include <vector>
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <list>
+
+
+//#define as_daemon
+#ifndef _CONSOLELOGGER_H_
+#define _CONSOLELOGGER_H_
+
+/**********************************************************************************************************************/
+//  Console-, and Message Dispatching / Logging  (With timestamping!)
+/**********************************************************************************************************************/
+//
+//  :: Usage ::
+//
+#define ConsoleLog ConsoleLogger::getLogger()-> //ease of acces!
+//
+//
+//  *Logging:
+//
+//  ConsoleLog writeLine(<string/char*>);            // sends out a message with "normal" loglevel
+//  ConsoleLog writeLine(<string/char*>, <loglevel>);   // sends out a message with the chosen loglevel --> enum LOG_LEVEL
+//  ConsoleLog writeError(<string/char*>);          // sends out a message with "Error" loglevel
+//  ConsoleLog writeTerminal(<string/char*>);       // sends out a message with "Terminal" loglevel, which means it is
+//                                                                                           // also printed on stdout
+//  ConsoleLog writeNetwork(<string/char*>);         // sends out a message with "network" loglevel
+//  ConsoleLog writeChat(<string/char*>);         // sends out a message with "Chat" loglevel
+//
+//  *un/subscribing to the LogDispatcher
+//
+//  ConsoleLog addListener(<pointer-to-object-of-Type-myClass>, &myClass::myMethod);
+//      callback signature --> typedef void (T::*callback)(ConsoleEntry); // with <U, T> as template  // for more on ConsoleEntry, see later
+//  ConsoleLog removeListener(<pointer-to-object-of-Type-myClass>, &myClass::myMethod);
+//
+//  *Misc
+//
+//  ConsoleLog setLogPath(<string-path-to-log-directory>);    // set the log directory (with a final /, the logfilename is appended.)
+//  ConsoleLog setLogName(<string-name>);         // like the above, but for the filename.
+//  ConsoleLog dumpLog(DUMP_MODE);
+//
+//  DUMP_FILE               ::>>        Dumps the whole log since the logger was started into the specified logfile. the file content gets overwritten
+//  DUMP_FILE_CONCAT        ::>>        The Same as above, but it will just append itself to the previously (if implemented) log which got \**
+//                                              ***\ read from the logfile which was present at logger start. if no log is found or logfile was not read, behaves as DUMP_FILE
+//  DUMP_TERMINAL           ::>>        Dumps the whole log into the terminal
+//  DUMP_ALL_LISTENERS      ::>>        Dumps the whole log to all listeners
+//
+//  Alternatively, you can request a dump to a certain listener:
+//  ConsoleLog dump2Listener(<pointer-to-object-of-Type-myClass>, &myClass::myMethod); // it expects the same information as when subscribing
+//              // the PVS-Server console makes heavy use of this feature to implement its filters
+//
+//
+//  :: using the ConsoleEntry class ::
+//
+//  *methods and members
+//
+//
+//        LOG_LEVEL getLevel()      // returns the loglevel as LOG_LEVEL Enum-type
+//        QString getLine()     // returns the complete line as shown in the logfile, with timestamp, loglevel prefix etc
+//        QString getMessage()  // returns the message body, no gimmicks attached
+//        QString getPrefix()   // returns the loglevel as string-represenation
+//        QString getTimeStamp() // returns the timestamp which was set at the creation of the object
+//
+//
+//
+//
+//
+//
+/**********************************************************************************************************************/
+
+
+
+
+
+
+// Typdef at bottom of file :
+// typedef ConsoleLogger::ConsoleEntry LogEntry;
+
+
+class ConsoleLogger
+{
+public:
+
+    enum LOG_LEVEL { LOG_NORMAL,
+                     LOG_ERROR,
+                     LOG_CHAT,
+                     LOG_TERMINAL,
+                     LOG_NETWORK
+                   };
+    enum DUMP_MODE { DUMP_FILE,
+                     DUMP_FILE_CONCAT,
+                     DUMP_TERMINAL,
+                     DUMP_ALL_LISTENERS,
+                   };
+    class ConsoleEntry
+    {
+    public:
+        ConsoleEntry(QString timeStamp, QString message, LOG_LEVEL level)
+        {
+            setLine(timeStamp, message, level);
+        };
+        void setLine(QString timeStamp, QString message, LOG_LEVEL level)
+        {
+            _message = message;
+            _prefix = _prefixLine(level);
+            _timeStamp = timeStamp;
+            _line.append(QString("[ ").append(timeStamp));
+            _line.append(QString(" ] ").append(_prefix));
+            _line.append(QString(": ").append(message));
+            _level = level;
+           if ('\n' != _line[_line.size()-1] && '\n' != _line[_line.size()])
+                _line.push_back('\n');    // add an explicit newline char, so it looks better in the logfile
+            //#ifndef as_daemon
+            if (_level == LOG_TERMINAL) // may look strange here, but its quite central :-)
+                printf("%s\n", _line.toUtf8().data());
+            //#endif
+        };
+        LOG_LEVEL getLevel()
+        {
+            return _level;
+        };
+        QString getLine()
+        {
+            return _line;
+        };
+        QString getMessage()
+        {
+            return _message;
+        };
+        QString getPrefix()
+        {
+            return _prefix;
+        };
+        QString getTimeStamp()
+        {
+            return _timeStamp;
+        };
+
+    private:
+        QString _prefixLine(LOG_LEVEL level)
+        {
+            // switch anyone?
+            if (level == LOG_NORMAL)
+                return QString("PVS");
+            if (level == LOG_ERROR)
+                return QString("PVS ERROR");
+            if (level == LOG_TERMINAL)
+                return QString("PVS Terminal");
+            if (level == LOG_CHAT)
+                return QString("PVS Chat");
+            if (level == LOG_NETWORK)
+                return QString("PVS Network");
+            return QString("UNDEFINED");
+        };
+        QString _line; // the complete line with timestamp and everything
+        QString _message; // the message itself
+        QString _prefix; // just the prefix
+        QString _timeStamp; // just the timestamp
+        LOG_LEVEL _level;
+    };
+
+    class LogNotifyEntry
+    {
+    public:
+        virtual void fire(ConsoleEntry consoleEntry) {};
+        LogNotifyEntry() {};
+    };
+
+#ifdef never
+private:
+    template<class T>
+    class LogNotify : public LogNotifyEntry
+    {
+    public:
+        typedef void (T::*callback)(ConsoleEntry);
+        LogNotify(T* who, callback func )//void (T :: *func)(QString))
+        {
+            callee = who;
+            //callback = func;
+            myCB = func;
+        };
+        virtual void fire(ConsoleEntry consoleEntry)
+        {
+            if (callee)
+                (callee->*myCB)(consoleEntry);
+        };
+        T* getCallee()
+        {
+            return callee;
+        };
+        callback getCB()
+        {
+            return myCB;
+        };
+
+    private:
+        T *callee;
+        callback myCB;
+    };
+
+public:
+#endif
+    // interfaces for the dispatcher for easy of access ( --> ConsoleLog Makro)
+    template<class T> void addListener(T* who, void (T :: *func)(ConsoleEntry))
+    {
+        entryDispatcher.addListener(who, func);
+    };
+    template<class T> void removeListener(T* who, void (T :: *func)(ConsoleEntry))
+    {
+        entryDispatcher.removeListener(who, func);
+    };
+    template<class T> void dump2Listener(T* who, void (T :: *func)(ConsoleEntry))
+    {
+        for (int i = 0; i < int(_log.size()) ; i++)
+            (who->*func)(_log[i]);
+    };
+
+    int writeLine(QString message, LOG_LEVEL = LOG_NORMAL);
+    int writeline(const char* message, LOG_LEVEL = LOG_NORMAL);
+    int writeError(QString error);
+    int writeError(const char* error);
+    int writeTerminal(QString terminal);
+    int writeTerminal(const char* terminal);
+    int writeNetwork(QString network);
+    int writeNetwork(const char* network);
+    int writeChat(QString chat);
+    int writeChat(const char* chat);
+    void getLine(int lineNum, char* line);
+    void getLine(int lineNum, QString* line);
+    void setLogPath(QString logPath);
+    void setLogName(QString logName);
+    void dumpLog(DUMP_MODE mode = DUMP_FILE);
+    static ConsoleLogger* getLogger();
+    static int count;
+private:
+
+
+    std::vector<ConsoleEntry>* _getLog()
+    {
+        return &_log;
+    };
+    static ConsoleLogger* _logger;
+    void _prepareLog();
+    void _writeLine2File(QString line);
+    void _writeLog(bool concat = false);
+    void _announceWrite(ConsoleEntry consoleEntry);
+    void _readLog(QString path = QString(""));
+    QString _getTimeStamp();
+    void _prefixLine(QString* line, LOG_LEVEL level = LOG_NORMAL);
+
+
+
+    ConsoleLogger();
+    ~ConsoleLogger();
+
+    QString _logName;
+    QString _logPath;
+
+    bool _logFileGood, _fileRead;
+//    std::list<LogNotifyEntry*> _CBLog;
+    EventDispatcher<ConsoleEntry> entryDispatcher;
+    std::vector<ConsoleEntry> _log;
+    std::vector<ConsoleEntry> _prev_log;
+    std::ofstream _logFile;
+};
+
+typedef ConsoleLogger::ConsoleEntry LogEntry;
+
+#endif