Log.h

Go to the documentation of this file.

#pragma once

#include <Core/core_defines2.h>

#include <Geom/Ax2.h>
#include <Geom/Dir.h>
#include <Geom/Pnt.h>
#include <Geom/Vec.h>
#include <Geom/Vec2d.h>

#include <QTextStream>
#include <sstream>
#include <string>

#define LOGGING_ENABLED

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

    CORE_EXPORT void setLogLevel(LOGLEVEL);
    CORE_EXPORT LOGLEVEL getLogLevel();
    
    class CORE_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, ...) Core::LastError::Instance().setError(__FUNCTION__, msg, __VA_ARGS__)
    #define CLEARLASTERROR() Core::LastError::Instance().setError("", "")

    class LogWriter
    {
    public:
        virtual void write(const QString& s) = 0;
        virtual void write(QString fontName, int fontsize, Geom::Vec2d position, Geom::Vec color, const QString& msg) = 0;
    };

    class CORE_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<<(const Geom::Pnt2d& p) = 0;
        virtual LogBaseClass& operator<<(const Geom::Pnt& p) = 0;
        virtual LogBaseClass& operator<<(const Geom::Vec& p) = 0;
        virtual LogBaseClass& operator<<(const Geom::Dir& p) = 0;    
        virtual LogBaseClass& operator<<(const Geom::Ax2& p) = 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:
        CORE_EXPORT static void addLogWriter(LogWriter* writer);
        CORE_EXPORT static void removeLogWriter(LogWriter* writer);
        static std::vector<LogWriter*> logwriter;

        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<<(const Geom::Pnt2d& p)
        {
            stream->ts << qSetRealNumberPrecision(12) << p.x() << " " << p.y();
            return maybeSpace();
        }
        inline LogClass& operator<<(const Geom::Pnt& p)
        {
            stream->ts << qSetRealNumberPrecision(12) << p.x() << " " << p.y() << " " << p.z();
            return maybeSpace();
        }
        inline LogClass& operator<<(const Geom::Vec& p)
        {
            stream->ts << qSetRealNumberPrecision(12) << p.x() << " " << p.y() << " " << p.z();
            return maybeSpace();
        }
        inline LogClass& operator<<(const Geom::Dir& p)
        {
            stream->ts << qSetRealNumberPrecision(12) << p.x() << " " << p.y() << " " << p.z();
            return maybeSpace();
        }
        inline LogClass& operator<<(const Geom::Ax2& p)
        {
            //stream->ts << "AX2 DIR: " << p.direction().xyz() << " LOCATION: " << p.location().xyz();
            return maybeSpace();
        }


        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);
    CORE_EXPORT LogClass Log(Core::LOGLEVEL level);
    CORE_EXPORT LogClass Log(Core::LOGLEVEL level, const char* msg, ...);
#endif
        
    CORE_EXPORT void MessageAtScreen(QString fontName, int fontsize, Geom::Vec2d position, Geom::Vec color, const char* msg, ...);
    CORE_EXPORT void MessageAtScreen(const char* msg, ...);
    

    #define LOGCOMMAND_DEBUG(x) Core::ScopedLogger _____scopedLogger(Core::D_DEBUG, x);
    #define LOGCOMMAND_INFO(x) Core::ScopedLogger _____scopedLogger(Core::D_INFO, x);
    #define LOGCOMMAND(x) Core::ScopedLogger _____scopedLogger(Core::D_WARN, x);
    #define LOGCOMMAND_WARN(x) Core::ScopedLogger _____scopedLogger(Core::D_WARN, x);
    #define cUserDebug(...) \
        if (Core::Settings::getInstance()->getDebugUser()) \
        { \
            cWarn( __VA_ARGS__); \
        }
    #define LOGVAR(var) cDebug() << QString("%1 = %2").arg(#var).arg(var);

    class CORE_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;
  
    };


    

}  // namespace Core

#ifdef LOGGING_ENABLED

CORE_EXPORT void cDebuggerBreak(char* message);
CORE_EXPORT Core::LogClass cDebug();
CORE_EXPORT Core::LogClass cInfo();
CORE_EXPORT Core::LogClass cError();
CORE_EXPORT Core::LogClass cWarn();

CORE_EXPORT Core::LogClass cDebug(const QString s);
CORE_EXPORT Core::LogClass cInfo(const QString s);
CORE_EXPORT Core::LogClass cError(const QString s);
CORE_EXPORT Core::LogClass cWarn(const QString s);

CORE_EXPORT Core::LogClass cDebug(const char* msg, ...);
CORE_EXPORT Core::LogClass cInfo(const char* msg, ...);
CORE_EXPORT Core::LogClass cError(const char* msg, ...);
CORE_EXPORT Core::LogClass cWarn(const char* msg, ...);

#else

CORE_EXPORT Core::NoDebugClass noDebug();
CORE_EXPORT void noDebug(const char*, ...);
CORE_EXPORT void noDebug(const QString &);

#define cDebug while(false) noDebug
#define cInfo  while(false) noDebug
#define cError while(false) noDebug
#define cWarn  while(false) noDebug


#endif