tb_debug_logger.hpp

#ifndef TurtleBrains_DebugLogger_hpp
#define TurtleBrains_DebugLogger_hpp

#include <turtle_brains/core/debug/tb_debug_tool_set.hpp>
#include <turtle_brains/core/tb_formatter.hpp>
#include <turtle_brains/core/tb_string.hpp>

#include <unordered_map>
#include <sstream>
#include <string>
#include <list>


#if defined(tb_enable_debug_set) || defined(tb_generate_documentation)

    #define tb_log(formattedMessage, ...) \
        TurtleBrains::Core::Debug::TheLogger() << TurtleBrains::Core::Debug::StartOfEntry() << \
            TurtleBrains::Core::Formatter(formattedMessage, ##__VA_ARGS__) << TurtleBrains::Core::Debug::EndOfEntry();

    #define tb_log_if(testResult, formattedMessage, ...) \
        if (testResult) { \
            TurtleBrains::Core::Debug::TheLogger() << TurtleBrains::Core::Debug::StartOfEntry() << \
                TurtleBrains::Core::Formatter(formattedMessage, ##__VA_ARGS__) << TurtleBrains::Core::Debug::EndOfEntry(); }

    #define tb_debug_log(log_stream) TurtleBrains::Core::Debug::TheLogger() << TurtleBrains::Core::Debug::StartOfEntry() << log_stream << TurtleBrains::Core::Debug::EndOfEntry();
    #define tb_debug_log_if(testResult, log_stream) if (testResult) { TurtleBrains::Core::Debug::TheLogger() << TurtleBrains::Core::Debug::StartOfEntry() << log_stream << TurtleBrains::Core::Debug::EndOfEntry(); }
    #define tb_debug_hexdump(message, rawData, dataSize) TurtleBrains::Core::Debug::LogHexDump(message, rawData, dataSize)

#else   //NO tb_enable_debug_set
    #define tb_log(formattedMessage, ...) ((void)formattedMessage);
    #define tb_log_if(test, formattedMessage, ...) ((void)(test));((void)formattedMessage);

    #define tb_debug_log(log_stream) ;
    #define tb_debug_log_if(testResult, log_stream) ;
    #define tb_debug_hexdump(message, rawData, dataSize) ((void)message);((void)rawData);((void)dataSize);

#endif /* tb_enable_debug_set */

#define tb_always_log(log_stream) TurtleBrains::Core::Debug::TheLogger() << TurtleBrains::Core::Debug::StartOfEntry() << log_stream << TurtleBrains::Core::Debug::EndOfEntry();
#define tb_always_log_if(testResult, log_stream) if (testResult) { TurtleBrains::Core::Debug::TheLogger() << TurtleBrains::Core::Debug::StartOfEntry() << log_stream << TurtleBrains::Core::Debug::EndOfEntry(); }
#define tb_always_hexdump(message, rawData, dataSize) TurtleBrains::Core::Debug::LogHexDump(message, rawData, dataSize)


namespace TurtleBrains
{
    namespace Core
    {
        namespace Debug
        {
            class StartOfEntry;
            class EndOfEntry;
            class ContinueEntry;
            class LogWithColor;
            class LogWithQuotes;

            enum LogLevel
            {
                kAlways,
                kError,
                kWarning,
                kInfo,
                kDebug,
                kTrace,
            };

            enum class LogColor
            {
                Black,
                Red,
                Green,
                Yellow,
                Blue,
                Magenta,
                Cyan,
                White,
                Gray,
                BrightRed,
                BrightGreen,
                BrightYellow,
                BrightBlue,
                BrightMagenta,
                BrightCyan,
                BrightWhite,
                Reset
            };

            void OpenLog(const std::string& logFile, bool createConsoleWindow);

            void SaveLog(void);

            void CloseLog(void);

            void Log(const char* formattedMessage, ...);

            void LogIf(const bool testResult, const char* formattedMessage, ...);

            void LogHexDump(const char* message, const void* rawData, size_t dataSize);


            class StreamLogger
            {
            public:
                StreamLogger(void);
                ~StreamLogger(void);

                LogLevel GetLogLevel(void) const;
                void SetLogLevel(const LogLevel& level);
                void LogIfLevel(const LogLevel& level);

                void SetCurrentChannel(const tbCore::tbString& channel);
                LogLevel GetLogLevel(const tbCore::tbString& channel) const;
                void SetLogLevel(const tbCore::tbString& channel, const LogLevel& level);

                void SaveSettings(void);
                void LoadSettings(void);

            private:
                template<typename Type> friend StreamLogger& operator<<(StreamLogger& stream, const Type& value);
                //template<> friend StreamLogger& operator<<(StreamLogger& stream, const LogColor& color);

                friend StreamLogger& operator<<(StreamLogger& stream, const StartOfEntry& startOfEntry);
                friend StreamLogger& operator<<(StreamLogger& stream, const EndOfEntry& startOfEntry);
                friend StreamLogger& operator<<(StreamLogger& stream, const ContinueEntry& startOfEntry);
                friend StreamLogger& operator<<(StreamLogger& stream, const Formatter& formatted);
                friend StreamLogger& operator<<(StreamLogger& stream, const LogColor& color);
                friend StreamLogger& operator<<(StreamLogger& stream, const LogWithColor& coloredMessage);
                friend StreamLogger& operator<<(StreamLogger& stream, const LogWithQuotes& quotedMessage);

                //Ultimately would like this to go away but C++ template specialization in translation unit wasn't
                //working very well, though I suspect is very posssible since the type is known.
                void SetColor(const LogColor& color);
                void PushColor(const LogColor& color);
                void PopColor(void);

                void ClearEntry(void);
                void PostEntry(void);
                void ContinueEntry(void);


                std::stringstream mLogEntry;
                LogLevel mDebugLevel;
                LogLevel mDefaultLevel;
                int mContinueEntry;
                bool mDoOutput;
                bool mHasSetChannel;

                typedef std::unordered_map<std::string, LogLevel> ChannelLevelTable;
                ChannelLevelTable mChannelLevels;
                std::string mCurrentChannel;
                std::list<LogColor> mColorStack;
            };

            //This needed to live above where-ever it gets used below because the compiler needs to know about.
            //This should be considered as a private implementation detail, use the macros tb_debug_log or tb_always_log.
            StreamLogger& TheLogger(void);

            class LogChannel
            {
            public:
                LogChannel(const std::string& channelName) :
                    mChannelName(channelName)
                {
                }

                friend StreamLogger& operator<<(StreamLogger& stream, const LogChannel& channel)
                {
                    stream.SetCurrentChannel(channel.mChannelName);
                    return stream;
                }

            private:
                const std::string mChannelName;
            };

            class ContinueEntry
            {
            public:
                ContinueEntry(void) { }
                friend StreamLogger& operator<<(StreamLogger& stream, const ContinueEntry& continueEntry);
            };

            class StartOfEntry
            {
            public:
                friend StreamLogger& operator<<(StreamLogger& stream, const StartOfEntry& startOfEntry);
            };

            class EndOfEntry
            {
            public:
                friend StreamLogger& operator<<(StreamLogger& stream, const EndOfEntry& endOfEntry);
            };

            class LogWithColor
            {
            public:
                LogWithColor(const LogColor color, const tbCore::tbString& message) :
                    mMessage(message),
                    mColor(color)
                {
                }

                static LogWithColor Black(const tbCore::tbString& message) { return LogWithColor(LogColor::Black, message); }
                static LogWithColor Red(const tbCore::tbString& message) { return LogWithColor(LogColor::Red, message); }
                static LogWithColor Green(const tbCore::tbString& message) { return LogWithColor(LogColor::Green, message); }
                static LogWithColor Yellow(const tbCore::tbString& message) { return LogWithColor(LogColor::Yellow, message); }
                static LogWithColor Blue(const tbCore::tbString& message) { return LogWithColor(LogColor::Blue, message); }
                static LogWithColor Magenta(const tbCore::tbString& message) { return LogWithColor(LogColor::Magenta, message); }
                static LogWithColor Cyan(const tbCore::tbString& message) { return LogWithColor(LogColor::Cyan, message); }
                static LogWithColor White(const tbCore::tbString& message) { return LogWithColor(LogColor::White, message); }
                static LogWithColor Gray(const tbCore::tbString& message) { return LogWithColor(LogColor::Gray, message); }
                static LogWithColor BrightRed(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightRed, message); }
                static LogWithColor BrightGreen(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightGreen, message); }
                static LogWithColor BrightYellow(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightYellow, message); }
                static LogWithColor BrightBlue(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightBlue, message); }
                static LogWithColor BrightMagenta(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightMagenta, message); }
                static LogWithColor BrightCyan(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightCyan, message); }
                static LogWithColor BrightWhite(const tbCore::tbString& message) { return LogWithColor(LogColor::BrightWhite, message); }

            private:
                friend StreamLogger& operator<<(StreamLogger& stream, const LogWithColor& coloredMessage);

                const tbCore::tbString mMessage;
                const LogColor mColor;
            };

            class LogWithQuotes
            {
            public:
                LogWithQuotes(const tbCore::tbString& message) :
                    mMessage(message)
                {
                }

            private:
                friend StreamLogger& operator<<(StreamLogger& stream, const LogWithQuotes& quotedMessage);

                const tbCore::tbString mMessage;
            };

            template<typename ChannelNamer> class LogChannelLevel
            {
            public:
                class Setter
                {
                public:
                    explicit Setter(const LogLevel& level) : mLogLevel(level) { }

                    friend tbCore::Debug::StreamLogger& operator<<(tbCore::Debug::StreamLogger& stream, const Setter& setter)
                    {
                        stream.SetCurrentChannel(ChannelNamer::AsString());
                        stream.LogIfLevel(setter.mLogLevel);
                        return stream;
                    }

                    LogLevel mLogLevel;
                };

                //Hacking a test in to see if printf can work with channels / severities...
                //
                // Would love to see all log calls go through the same macro "tb_log" (always/debug) and always support
                // the option of Channels / Severity by doing some magic to include printf formatting in a friendly way.
                //
                // This should NOT call tb_always_out from within, as that would not allow it to work.
                //
                //  Most desired call:
                //      tb_always_out(LogInit::LogAlways("Hello %s with %d bytes.", "turtles", 42));
                //          might be able to do the above with a Formatter object that holds a buffer to output in
                //          StreamLogger<< operator quite like the below line, and return this Format
                //          object from LogAlways() or AlwaysFormat() or whatever. This would give channel/severity
                //          to printf like-logging; and keep tb_log defined to the Formatter object. (though still deprecate).
                //
                //      tb_always_out(LogInit::Always() << Formatter("Hello %s with %d bytes.", "turtles", 42));
                //
                //  Note the coloring thing could work quite the same way.
                //
                // Currently this is working:
                //      LogInit::LogAlways("Hello %s with %d bytes.", "turtles", 42);

                //The following is the desired way to call it:
                //

                //NOTE: If this is supported we should do all severity levels like it. If it is not supported then it
                //   should be removed and the ContinueEntry/StartOfEntry/EndOfEntry should be moved below the object.
                static void LogAlways(const char* formattedMessage, ...)
                {
                    va_list argumentsList;
                    va_start(argumentsList, formattedMessage);
                    TheLogger() << StartOfEntry() << Formatter::FromArgumentList(formattedMessage, argumentsList) << EndOfEntry();
                    va_end(argumentsList);
                }

                static LogWithQuotes Quote(const tbCore::tbString& message) { return LogWithQuotes(message); }

                static LogLevel GetLogLevel(void)
                {
                    return TheLogger().GetLogLevel(ChannelNamer::AsString());
                }

                static void SetLogLevel(const LogLevel& logLevel)
                {
                    TheLogger().SetLogLevel(ChannelNamer::AsString(), logLevel);
                }

                static inline tbCore::tbString AsString(void) { return ChannelNamer::AsString(); }

                static inline Setter Always(void) { return Setter(LogLevel::kAlways); }
                static inline Setter Error(void) { return Setter(LogLevel::kError); }
                static inline Setter Warning(void) { return Setter(LogLevel::kWarning); }
                static inline Setter Info(void) { return Setter(LogLevel::kInfo); }
                static inline Setter Debug(void) { return Setter(LogLevel::kDebug); }
                static inline Setter Trace(void) { return Setter(LogLevel::kTrace); }
            };


            template<typename Type> StreamLogger& operator<<(StreamLogger& stream, const Type& value)
            {
                if (stream.mDoOutput)
                {
                    stream.mLogEntry << value;
                }
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const LogColor& color)
            {
                //SetColor(color);
                if (LogColor::Reset == color)
                {
                    stream.PopColor();
                }
                else
                {
                    stream.PushColor(color);
                }
                return stream;
            }


            inline StreamLogger& operator<<(StreamLogger& stream, const LogLevel& logLevel)
            {
                stream.LogIfLevel(logLevel);
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const ContinueEntry& continueEntry)
            {
                (void(continueEntry));
                stream.ContinueEntry();
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const StartOfEntry& startOfEntry)
            {
                (void(startOfEntry));
                stream.ClearEntry();
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const EndOfEntry& endOfEntry)
            {
                (void(endOfEntry));
                stream.PostEntry();
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const Formatter& formatted)
            {
                if (true == stream.mDoOutput)
                {
                    stream.mLogEntry << formatted.c_str();
                }
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const LogWithColor& coloredMessage)
            {
                if (true == stream.mDoOutput)
                {
                    stream << coloredMessage.mColor << coloredMessage.mMessage << LogColor::Reset;
                }
                return stream;
            }

            inline StreamLogger& operator<<(StreamLogger& stream, const LogWithQuotes& quotedMessage)
            {
                if (true == stream.mDoOutput)
                {
                    stream << "\"" << quotedMessage << "\"";
                }
                return stream;
            }

            //struct SystemChannel { static tbCore::tbString AsString(void) { return ("System"); } };
            //typedef TurtleBrains::Core::Debug::LogChannelLevel<SystemChannel> LogSystem;
            struct GraphicsChannel { static tbCore::tbString AsString(void) { return ("Graphics"); } };
            typedef TurtleBrains::Core::Debug::LogChannelLevel<GraphicsChannel> LogGraphics;
            struct GameplayChannel { static std::string AsString(void) { return ("Gameplay"); } };
            typedef TurtleBrains::Core::Debug::LogChannelLevel<GameplayChannel> LogGameplay;
            struct NetworkChannel { static std::string AsString(void) { return ("Network"); } };
            typedef TurtleBrains::Core::Debug::LogChannelLevel<NetworkChannel> LogNetwork;
            struct PhysicsChannel { static std::string AsString(void) { return ("Physics"); } };
            typedef TurtleBrains::Core::Debug::LogChannelLevel<PhysicsChannel> LogPhysics;

        }; /* namespace Debug */
    }; /* namespace Core */
}; /* namespace TurtleBrains */

#endif /* TurtleBrains_DebugLogger_hpp */