Log.h

Go to the documentation of this file.

#pragma once

#include <QTextStream>
#include <string>


#define LOGGING_ENABLED

namespace Base
{
    enum LOGLEVEL
    {
        D_OFF = 0,
        D_FATAL = 1,
        D_ERROR = 2,
        D_WARN = 3,
        D_INFO = 4,
        D_DEBUG = 5,
        D_ALL = 6
    };

    LX_BASE_EXPORT void setLogLevel(LOGLEVEL);
    LX_BASE_EXPORT LOGLEVEL getLogLevel();
    
    class LX_BASE_EXPORT LastError
    {
    public:
        static LastError& Instance();
        LastError& setError(std::string& where, std::string& msg);
        LastError& setError(const char* where, const char* msg, ...);
        LastError& append(std::string& msg);
        std::string getError();
        std::string getErrorMsg();
        LastError();
        ~LastError();

    private:
        std::string m_where;
        std::string m_msg;
        int m_msgID = -1;
    };

    #define LASTERROR(msg, ...) Base::LastError::Instance().setError(__FUNCTION__, msg, __VA_ARGS__)
    #define CLEARLASTERROR() Base::LastError::Instance().setError("", "")

    class LX_BASE_EXPORT ScopedLogger
    {
    public:
        ScopedLogger(LOGLEVEL level, const std::string& s);
        ~ScopedLogger();

        static int getIndent();

        class ScopedLoggerP;
        ScopedLoggerP* _piml;
    };


    class LogBaseClass
    {
    public:
        virtual LogBaseClass& space() = 0;
        virtual LogBaseClass& nospace() = 0;
        virtual LogBaseClass& maybeSpace() = 0;
        virtual LogBaseClass& operator<<(QChar t) = 0;
        virtual LogBaseClass& operator<<(bool t) = 0;
        virtual LogBaseClass& operator<<(char t) = 0;
        virtual LogBaseClass& operator<<(signed short t) = 0;
        virtual LogBaseClass& operator<<(unsigned short t) = 0;
        virtual LogBaseClass& operator<<(signed int t) = 0;
        virtual LogBaseClass& operator<<(unsigned int t) = 0;
        virtual LogBaseClass& operator<<(signed long t) = 0;
        virtual LogBaseClass& operator<<(unsigned long t) = 0;
        virtual LogBaseClass& operator<<(qint64 t) = 0;
        virtual LogBaseClass& operator<<(quint64 t) = 0;
        virtual LogBaseClass& operator<<(float t) = 0;
        virtual LogBaseClass& operator<<(double t) = 0;
        virtual LogBaseClass& operator<<(const char* t) = 0;
        virtual LogBaseClass& operator<<(const QString& t) = 0;
        virtual LogBaseClass& operator<<(const QStringRef& t) = 0;
        virtual LogBaseClass& operator<<(const QLatin1String& t) = 0;
        virtual LogBaseClass& operator<<(const QByteArray& t) = 0;
        virtual LogBaseClass& operator<<(const void* t) = 0;
        virtual LogBaseClass& operator<<(QTextStreamFunction f) = 0;
        virtual LogBaseClass& operator<<(QTextStreamManipulator m) = 0;
    

    };

    class NoDebugClass
    {
    public:
        inline NoDebugClass& operator<<(QTextStreamFunction) { return *this; }
        inline NoDebugClass& operator<<(QTextStreamManipulator) { return *this; }
        inline NoDebugClass& space() { return *this; }
        inline NoDebugClass& nospace() { return *this; }
        inline NoDebugClass& maybeSpace() { return *this; }
        inline NoDebugClass& quote() { return *this; }
        inline NoDebugClass& noquote() { return *this; }
        inline NoDebugClass& maybeQuote(const char = '"') { return *this; }

        template<typename T>
        inline NoDebugClass& operator<<(const T&) { return *this; }
    };

   
    class LogClass : public LogBaseClass
    {
        struct Stream
        {
            Stream(QIODevice* device) : ts(device), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
            Stream(QString* string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
            Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true), message_output(true) {}
            QTextStream ts;
            QString buffer;
            int ref;
            QtMsgType type;
            bool space;
            bool message_output;
        } * stream;

        LOGLEVEL mylevel;
    #if QT_VERSION >= 0x050000
        QMessageLogContext context;
    #endif


    public:
        inline LogClass(QIODevice* device) : stream(new Stream(device)) {}
        inline LogClass(QString* string) : stream(new Stream(string)) {}
        inline LogClass(LOGLEVEL level, QtMsgType t) : mylevel(level), stream(new Stream(t)) {}
        inline LogClass(const LogClass& o) : stream(o.stream) { ++stream->ref; }
        inline LogClass& operator=(const QDebug& other);
        inline ~LogClass()
        {
            if (!--stream->ref)
            {
                if (stream->message_output && !stream->buffer.isEmpty())
                {
                    if (mylevel <= getLogLevel())
                    {
                        char buf2[6000];
                        if (mylevel == D_ALL)
                            sprintf_s(buf2, 6000, "ALL:   %*s", ScopedLogger::getIndent() * 2, "");
                        if (mylevel == D_DEBUG)
                            sprintf_s(buf2, 6000, "DEBUG: %*s", ScopedLogger::getIndent() * 2, "");
                        if (mylevel == D_ERROR)
                            sprintf_s(buf2, 6000, "ERROR: %*s", ScopedLogger::getIndent() * 2, "");
                        if (mylevel == D_FATAL)
                            sprintf_s(buf2, 6000, "FATAL: %*s", ScopedLogger::getIndent() * 2, "");
                        if (mylevel == D_WARN)
                            sprintf_s(buf2, 6000, "%*s", ScopedLogger::getIndent() * 2, "");
                        if (mylevel == D_INFO)
                            sprintf_s(buf2, 6000, "INFO:  %*s", ScopedLogger::getIndent() * 2, "");
                        if (mylevel == D_OFF)
                            sprintf_s(buf2, 6000, "OFF:   %*s", ScopedLogger::getIndent() * 2, "");

                        QString msg = QString(buf2) + QString(stream->buffer);
                        QMessageLogContext context;
                        qt_message_output(stream->type, context, msg);
                    }
                }
                delete stream;
            }
        }
        inline LogClass& space()
        {
            stream->space = true;
            stream->ts << " ";
            return *this;
        }
        inline LogClass& nospace()
        {
            stream->space = false;
            return *this;
        }
        inline LogClass& maybeSpace()
        {
            if (stream->space)
                stream->ts << " ";
            return *this;
        }

        inline LogClass& operator<<(QChar t)
        {
            stream->ts << "\'" << t << "\'";
            return maybeSpace();
        }
        inline LogClass& operator<<(bool t)
        {
            stream->ts << (bool(t) ? "true" : "false");
            return maybeSpace();
        }
        inline LogClass& operator<<(char t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(signed short t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(unsigned short t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(signed int t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(unsigned int t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(signed long t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(unsigned long t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(qint64 t)
        {
            stream->ts << QString::number(t);
            return maybeSpace();
        }
        inline LogClass& operator<<(quint64 t)
        {
            stream->ts << QString::number(t);
            return maybeSpace();
        }
        inline LogClass& operator<<(float t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(double t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(const char* t)
        {
            stream->ts << qPrintable(t);
            return maybeSpace();
        }
        inline LogClass& operator<<(const QString& t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(const QStringRef& t) { return operator<<(t.toString()); }
        inline LogClass& operator<<(const QLatin1String& t)
        {
            stream->ts << t.latin1();
            return maybeSpace();
        }
        inline LogClass& operator<<(const QByteArray& t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(const void* t)
        {
            stream->ts << t;
            return maybeSpace();
        }
        inline LogClass& operator<<(QTextStreamFunction f)
        {
            stream->ts << f;
            return *this;
        }

        inline LogClass& operator<<(QTextStreamManipulator m)
        {
            stream->ts << m;
            return *this;
        }

        static bool is_activated;
    };

#ifdef LOGGING_ENABLED
    void LogV(LOGLEVEL level, const QString& s, va_list ap);
    LX_BASE_EXPORT LogClass Log(Base::LOGLEVEL level);
    LX_BASE_EXPORT LogClass Log(Base::LOGLEVEL level, const char* msg, ...);
#endif
        
   
    #define LOGCOMMAND_DEBUG(x) Base::ScopedLogger _____scopedLogger(Base::D_DEBUG, x);
    #define LOGCOMMAND_INFO(x) Base::ScopedLogger _____scopedLogger(Base::D_INFO, x);
    #define LOGCOMMAND(x) Base::ScopedLogger _____scopedLogger(Base::D_WARN, x);
    #define LOGCOMMAND_WARN(x) Base::ScopedLogger _____scopedLogger(Base::D_WARN, x);
    #define cUserDebug(...) \
        if (Base::Settings::getInstance()->getDebugUser()) \
        { \
            cWarn( __VA_ARGS__); \
        }
    #define LOGVAR(var) cDebug() << QString("%1 = %2").arg(#var).arg(var);

    class LX_BASE_EXPORT AssertSingleton
    {
        public:
            static AssertSingleton& getInstance()
            {
                static AssertSingleton instance;
                // volatile int dummy{};
                return instance;
            }

            void setCallBack( std::function<bool(std::string)> f ) { mCallback = f; }
            bool callCallBack(std::string s) { if(mCallback) return mCallback(s); return false; }

        private:
            std::function<bool(std::string)> mCallback;
            AssertSingleton()= default;
            ~AssertSingleton()= default;
            AssertSingleton(const AssertSingleton&)= delete;
            AssertSingleton& operator=(const AssertSingleton&)= delete;
  
    };

    class LX_BASE_EXPORT Logger
    {
    public:
        static Logger& instance();
        static void log( const char* format, ... );
        static void log( QString s );
        

    private:
        Logger(QString path) : logFilePath(path) {}
        ~Logger() {}

        QString logFilePath;
    };

    class LX_BASE_EXPORT ScopedLog
    {
    public:
        ScopedLog(QString a) : m_msg(a) {}
        ~ScopedLog() { Logger::instance().log(m_msg); }
        QString m_msg;
    };

#define myLog(a) Logger::instance().writeToLog(a);
#define myLogAtFinish(a) ScopedLog(a);


    

}  // namespace Core

#ifdef LOGGING_ENABLED

#define cAssert(condition, message) \
do { \
    if (! (condition)) { \
        std::stringstream ss;\
        ss << "Assertion: `" #condition << "` --> '" << message << "' failed in \n" << __FILE__ << ":" << __LINE__ << "\n"; \
        std::cerr << ss.str();\
        if( Base::AssertSingleton::getInstance().callCallBack(ss.str())) exit(1);\
    } \
} while (false)


LX_BASE_EXPORT void cDebuggerBreak(char* message);
LX_BASE_EXPORT Base::LogClass cDebug();
LX_BASE_EXPORT Base::LogClass cInfo();
LX_BASE_EXPORT Base::LogClass cError();
LX_BASE_EXPORT Base::LogClass cWarn();

LX_BASE_EXPORT Base::LogClass cDebug(const QString s);
LX_BASE_EXPORT Base::LogClass cInfo(const QString s);
LX_BASE_EXPORT Base::LogClass cError(const QString s);
LX_BASE_EXPORT Base::LogClass cWarn(const QString s);

LX_BASE_EXPORT Base::LogClass cDebug(const char* msg, ...);
LX_BASE_EXPORT Base::LogClass cInfo(const char* msg, ...);
LX_BASE_EXPORT Base::LogClass cError(const char* msg, ...);
LX_BASE_EXPORT Base::LogClass cWarn(const char* msg, ...);



#else

LX_CORE_EXPORT Base::NoDebugClass noDebug();
LX_CORE_EXPORT void noDebug(const char*, ...);
LX_CORE_EXPORT void noDebug(const QString &);

#define cAssert(condition, message) do { } while (false)
#define cDebug while(false) noDebug
#define cInfo  while(false) noDebug
#define cError while(false) noDebug
#define cWarn  while(false) noDebug


#endif