Log.h

Go to the documentation of this file.

/*
* True Reality Open Source Game and Simulation Engine
* Copyright © 2021 Acid Rain Studios LLC
*
* The Base of this class has been adopted from the Delta3D engine
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 3.0 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Class Inspired by the Delta3D Engine
* http://delta3dengine.org/
*
* @author Matthew W. Campbell
* @author Erik Johnson
* @author David Guthrie
* @author Maxim Serebrennik
*/
#pragma once
#include <trUtil/Export.h>

#include <trUtil/DateTime.h>
#include <trUtil/Logging/LogFile.h>
#include <trUtil/Logging/LogLevel.h>

#include <string>
#include <cstdarg>
#include <vector>
#include <sstream>

#include <osg/Referenced>
#include <osg/ref_ptr>


namespace trUtil::Logging
{
    // Fwd declaration
    class LogWriter;
    class LogTimeProvider;
    class LogManager;
    class LogImpl;

#define TR_LOG_SOURCE __FILE__, __FUNCTION__, __LINE__

#define LOG_FULL(level, name, msg) \
    {\
        trUtil::Logging::Log& logger = trUtil::Logging::Log::GetInstance(name); \
        if (logger.IsLevelEnabled(level)) \
        {\
            std::ostringstream st;\
            st << msg;\
            logger.LogMessage(TR_LOG_SOURCE, st.str(), level); \
        }\
    }\


#define LOGN_D(name, msg) LOG_FULL(trUtil::Logging::LogLevel::LOG_DEBUG, name, msg)

#define LOGN_I(name, msg) LOG_FULL(trUtil::Logging::LogLevel::LOG_INFO, name, msg)

#define LOGN_W(name, msg) LOG_FULL(trUtil::Logging::LogLevel::LOG_WARNING, name, msg)

#define LOGN_E(name, msg) LOG_FULL(trUtil::Logging::LogLevel::LOG_ERROR, name, msg)

#define LOGN_A(name, msg) LOG_FULL(trUtil::Logging::LogLevel::LOG_ALWAYS, name, msg)

#define LOG_D(msg) LOGN_D(trUtil::Logging::Log::LOG_DEFAULT_NAME, msg)

#define LOG_I(msg) LOGN_I(trUtil::Logging::Log::LOG_DEFAULT_NAME, msg)

#define LOG_W(msg) LOGN_W(trUtil::Logging::Log::LOG_DEFAULT_NAME, msg)

#define LOG_E(msg) LOGN_E(trUtil::Logging::Log::LOG_DEFAULT_NAME, msg)

#define LOG_A(msg) LOGN_A(trUtil::Logging::Log::LOG_DEFAULT_NAME, msg)

#define LOG_PRINT_TEST \
    LOG_D("Test Message") \
    LOG_I("Test Message") \
    LOG_W("Test Message") \
    LOG_E("Test Message") \
    LOG_A("Test Message")

    class TR_UTIL_EXPORT Log : public osg::Referenced
    {
    public:

        struct LogTestData
        {
            trUtil::Logging::LogLevel logLevel; 
            trUtil::DateTime time;              
            unsigned frameNumber;               
            std::string logName;                
            std::string file;                   
            std::string method;                 
            int line;                           
            std::string msg;                    
        };

        static const std::string LOG_DEFAULT_NAME;

        void LogMessage(const std::string& cppFile, const std::string& method, int line, const std::string& msg, LogLevel logLevel) const;

        void LogMessage(LogLevel logLevel, const std::string& source, int line, const char* msg, ...) const;

        void LogMessage(LogLevel logLevel, const std::string& source, int line, const std::string& msg) const;

        void LogMessage(LogLevel logLevel, const std::string& source, int line, const char* msg, va_list list) const;

        void LogMessage(LogLevel logLevel, const std::string &source, const char *msg, ...) const;

        void LogHorizRule();

        bool IsLevelEnabled(LogLevel logLevel) const;

        void SetLogLevel(LogLevel logLevel);

        LogLevel GetLogLevel() const;

        static const std::string GetLogLevelString(LogLevel logLevel);

        static LogLevel GetLogLevelForString(const std::string& levelString);

        static Log& GetInstance(const std::string& name = Log::LOG_DEFAULT_NAME);

        static void SetDefaultLogLevel(LogLevel newLevel);

        static void SetAllLogLevels(LogLevel newLevel);

        static void SetLogTimeProvider(LogTimeProvider* ltp);

        void AddWriter(LogWriter& writer);

        void RemoveWriter(LogWriter& writer);

        using LogWriterContainer = std::vector<osg::ref_ptr<LogWriter>>;

        const LogWriterContainer& GetWriters() const;

        LogWriterContainer& GetWriters();

        enum OutputStreamOptions
        {
            NO_OUTPUT = 0x00000000, /* Log messages don't get written to any device*/
            TO_FILE = 0x00000001,   /* Log messages get sent to the output file*/
            TO_CONSOLE = 0x00000002,/* Log messages get sent to the console*/
            TO_WRITER = 0x00000004,/* Log messages get sent to all registered writers*/
            STANDARD = TO_FILE | TO_CONSOLE | TO_WRITER /* The default setting*/
        };

        void SetOutputStreamBit(unsigned int option);

        static void SetAllOutputStreamBits(unsigned int option);

        unsigned int GetOutputStreamBit() const;

        const std::string& GetName() const;

        LogManager& GetLogManagerRef();

        void SetTestMode(bool state);

        LogTestData* GetLastLogData() const;

    protected:

        Log(const std::string& name);

        ~Log();

    private:
        LogImpl* mImpl;

        bool mTestingMode = false;
        mutable LogTestData mLogTestData;
    };

    class TR_UTIL_EXPORT LoggingOff
    {
    public:

        LoggingOff(const std::string& name = Log::LOG_DEFAULT_NAME);

        ~LoggingOff();
    private:
        trUtil::Logging::Log& mLog;
        LogLevel mOldLevel;
    };
}