errMsgQueue.h

Go to the documentation of this file.

#ifndef __errMsgQueue_h__
#define __errMsgQueue_h__
 
#include <sstream>
#include <iostream>
#include <syslog.h>
#include "waitQueues.h"
#include "syslogstream.h"
namespace errMsg {
    class location {
        const char*function;
        const char*file;
        int line;
      public:
        #if defined(__has_builtin) // we probably use CLANG
        #if __has_builtin(__builtin_FUNCTION)
#define __useBuiltinFunction__
        #endif
        #else // we probably use GCC
#define __useBuiltinFunction__
        #endif
        #ifdef __useBuiltinFunction__
        constexpr location(const char *aFunc = __builtin_FUNCTION(),
                           int aLine = __builtin_LINE(),
                           const char *aFile = __builtin_FILE()):
#undef __useBuiltinFunction__
        #else // no info available....
        constexpr location(const char *aFunc = "unknown",
                           int aLine = 0,
                           const char *aFile = "unknown"):
        #endif
 
            function(aFunc),
            file(aFile),
            line(aLine) {}
        const char* getFunc() const {
            return function;
        };
        const char* getFile() const {
            return file;
        };
        int getLine() const {
            return line;
        };
    };
    enum class level {
        emerg = LOG_EMERG,
        alert = LOG_ALERT,
        crit = LOG_CRIT,
        err = LOG_ERR,
        warning = LOG_WARNING,
        notice = LOG_NOTICE,
        info = LOG_INFO,
        debug = LOG_DEBUG
    };
    class message {
      private:
        std::string object;
        std::string action;
        std::string msg;
        location loc;
        std::thread::id threadId;
        std::chrono::system_clock::time_point timeStamp;
        level logLevel;
        message(level aLogLevel,
                const location& aLocation,
                const std::string& aObject,
                const std::string& aAction,
                const std::string& aMessage):
            object(aObject),
            action(aAction),
            msg(aMessage),
            loc(aLocation),
            threadId(std::this_thread::get_id()),
            timeStamp(std::chrono::system_clock::now()),
            logLevel(aLogLevel) {
            std::unique_ptr<message> u(this);
            getQueue().enqueue(u);
        }
      public:
        static waitQueues::simple<message>& getQueue() {
            static std::remove_reference<decltype(getQueue())>::type queue;
            return queue;
        }
        static void printMsgs() {
            while (auto msg = getQueue().dequeue()) {
                std::cerr << msg->loc.getFile() << ":" << msg->loc.getLine() << ": in " << msg->loc.getFunc()  << ": " << msg->object << " " << msg->action << " " << msg->msg << "\n";
            }
        }
 
        ~message() {
        }
        static void generateMsg(level aLogLevel,
                                const location& aLocation,
                                const std::string& aObject,
                                const std::string& aAction,
                                const std::string& aMessage) {
            new message(aLogLevel, aLocation, aObject, aAction, aMessage);
        }
        const std::string& getObject() const {
            return object;
        };
        const std::string& getAction() const {
            return action;
        };
        const std::string& getMessage() const {
            return msg;
        };
        const location& getLoc() const {
            return loc;
        };
        std::thread::id getThreadId() const {
            return threadId;
        };
        std::chrono::system_clock::time_point getTimeStamp() const {
            return timeStamp;
        };
        logstream::level getLogLevel() const {
            return static_cast<logstream::level>(logLevel);
        };
    };
 
 
    template <typename T> void conCatString(std::ostringstream& msg, const T& begin) {
        msg << begin;
    }
    template <typename T, typename ... Args> inline void conCatString(std::ostringstream& msg,
            const T& begin,
            const Args& ... args) {
        msg << begin;
        if (sizeof...(args)) {
            conCatString(msg, args...);
        }
    }
 
    template <typename ... Args> inline void emit(level aLogLevel, 
            const location& loc, 
            const std::string& aObject, 
            const std::string& aAction, 
            const Args& ... args 
                                                 ) {
        std::ostringstream msg;
        conCatString(msg, args...);
        message::generateMsg(aLogLevel, loc, aObject, aAction, msg.str());
    }
    // template <typename ... Args> inline void debug(level aLogLevel,bool doit, const location& loc,const Args& ... args) {
    //      if (__builtin_expect(doit,false)) {
    //      std::ostringstream msg;
    //      conCatString(msg,args...);
    //      message::generateMsg(aLogLevel,loc,msg.str());
    //  }
    //}
}; // end namespace errMsg
 
#endif