Log.h

#pragma once
#include "util/mutex.h"
#include <string>

#define MAX_DEBUG_STRING_LENGTH 1024

namespace ParaEngine
{
    class CLogger;

    namespace LogDetail
    {
        class PE_CORE_DECL LocationInfo
        {
        public:

            static const char * const NA;
            static const char * const NA_METHOD;

            static const LocationInfo& getLocationUnavailable();


            LocationInfo( const char * const fileName,
                const char * const functionName,
                int lineNumber);

            LocationInfo();

            LocationInfo( const LocationInfo & src );

            LocationInfo & operator = ( const LocationInfo & src );

            void clear();


            const std::string getClassName();

            const char * getFileName();

            int getLineNumber();

            const std::string getMethodName();

            void write(CLogger* pOutput) const;

        private:
            int lineNumber;

            const char * fileName;

            const char * methodName;
        };
    }

#ifdef WIN32
#pragma warning( push )
// warning C4251: 'ParaEngine::CLogger::m_log_file_name' : class 'std::basic_string<_Elem,_Traits,_Ax>' needs to have dll-interface to be used by clients of class 'ParaEngine::CLogger'
#pragma warning( disable : 4251 ) 
#endif

    class PE_CORE_DECL CLogger
    {
    public:
        CLogger();
        ~CLogger();

        static CLogger& GetSingleton();

        void AddLogStr(const char * pStr);
        void AddLogStr(const wchar_t * pStr);

        void AddLogStr_st(const char * pStr);
        void AddLogStr_st(const wchar_t * pStr);

        void SetLogFile(const std::string& sFile);
        const std::string& GetLogFile();

        void WriteFormated(const char *, ...);
        void WriteFormatedVarList(const char *, va_list args);
        void WriteFormated(const wchar_t *, ...);
        void WriteFormated_WithTime(const char *, ...);

        void WriteFormated_st(const char *, ...);
        void WriteFormated_st(const wchar_t *, ...);

        int Write(const char * buf, int nLength);

        int Write_st(const char * buf, int nLength);

        int GetPos();

        const char* GetLog(int fromPos, int nCount);

        void CloseLog();

        FILE* GetLogFileHandle();
    
        void WriteDebugStr(const char * zFormat,const char * str, const char* sFile,int nLine);

    public:
        const std::string& GetName();


        void SetAppendMode(bool bAppendToExistingFile);

        void SetForceFlush(bool bForceFlush);

        int GetLevel();

        void SetLevel(const int level1);

        bool IsEnabledFor(int level);

        void log(const int level, const std::string& message,
            const ParaEngine::LogDetail::LocationInfo& location);
        void log(const int level, const char* message,
            const ParaEngine::LogDetail::LocationInfo& location);
        void log(const int level, const std::string& message);
        void log(const int level, const char* message);

        void ForcedLog(const int level, const std::string& message,
            const ParaEngine::LogDetail::LocationInfo& location);
        void ForcedLog(const int level, const char* message,
            const ParaEngine::LogDetail::LocationInfo& location);
        void ForcedLog(const int level, const std::string& message);
        void ForcedLog(const int level, const char* message);

    protected:
        // file name
        std::string m_log_file_name;
        // file handle
        FILE* m_file_handle;
        // debug string buffer.
        char m_buffer[MAX_DEBUG_STRING_LENGTH*2+2];
        // for multi-threaded logging. 
        mutex   m_mutex;
        // whether this is first time this logger is used. we will create new file if it is true, otherwise we will append to existing file. 
        bool m_is_first_time_open;
        bool m_bForceFlush;

        std::string m_name;

        int m_level;

    };
#ifdef WIN32
#pragma warning( pop ) 
#endif

}

#ifndef OUTPUT_LOG
#define OUTPUT_LOG ParaEngine::CLogger::GetSingleton().WriteFormated
#endif

#define OUTPUT_LOG1 ParaEngine::CLogger::GetSingleton().WriteFormated_WithTime

#ifdef _DEBUG
#define OUTPUT_DEBUG(a) ParaEngine::CLogger::GetSingleton().WriteDebugStr("%s called from %s:%d\n",a, __FILE__,__LINE__);
#else
#define OUTPUT_DEBUG(a)
#endif


#if !defined(SERVICE_LOG_LOCATION)
#if defined(_MSC_VER)
#if _MSC_VER >= 1300
#define __SERVICE_LOG_FUNC__ __FUNCSIG__
#endif
#else
#if defined(__GNUC__)
#define __SERVICE_LOG_FUNC__ __PRETTY_FUNCTION__
#endif
#endif
#if !defined(__SERVICE_LOG_FUNC__)
#define __SERVICE_LOG_FUNC__ ""
#endif
#define SERVICE_LOG_LOCATION ParaEngine::LogDetail::LocationInfo(__FILE__, \
    __SERVICE_LOG_FUNC__,                                                         \
    __LINE__)
#endif


#define APP_LOG(message) ParaEngine::CLogger::GetSingleton().ForcedLog(0, message, SERVICE_LOG_LOCATION);