Sfx_Logger.h

Go to the documentation of this file.

 
#pragma once
 
// C++ includes
#include <cstdio>
#include <fstream>
#include <filesystem>
// SfxBase19 lib includes
#include "include/Sfx_Object.h"
#include "include/Sfx_ILogger.h"
#include "include/Singleton.hpp"
 
namespace Sfx 
{
    //  Design Note (January 16, 2011)
    //   We inherit from Object, it's because we use the Global insertProvider(Object*).
    //   In the actual implementation of Object it doesn't make sense, it's only for debugging.
    //   In our migration towards the new architecture this inheritance will be revised.
    //   Probably insertProvider(Provider*) would be more appropriate of inserting Object*
    //  
    //  febuary 3rd, 2018
    // This class still under construction (we are merging many version of the Logger 
    // implementation). Final version will used in the new version of the API Dbpp. 

    class Logger : public Sfx::Singleton<Logger>,
        public Sfx::Object,
        public virtual Sfx::ILogger
    {
    public:
        enum class eOpeningMode { fstream = 0, FILE = 1 };

        bool Init();
        bool Shutdown();
        void OutputNewline();
        void OutputError(char* text, ...);
        void OutputSuccess(char* text, ...);
        void write2File(const std::string aMessage);
        // NOTE in the current version we support 2 mode for writing
        // to log file. This is because we have merged different version
        // of the logger and we want back compatibility  
        eOpeningMode getOpeningMode() { return m_openMode; }
        void setOpeningMode(const eOpeningMode aOpenMode)
        {
            if (m_openMode == eOpeningMode::fstream)
            {
                // check if file is open
                if (m_fStream.is_open())
                {
                    m_fStream.close();
                }
                m_openMode = aOpenMode;
            }
        }
 
        //
        // ILogger interface
        //
 
        //static Logger* Instance();

        bool openLogFile( std::string logFile);
        void writeToLogFile( const std::string aStr);
        bool closeLogFile();

        friend class Singleton<Logger>;
 
    protected:
        Logger();
        ~Logger();

    Logger(const Logger& aOther) = delete;
        Logger& operator= (const Logger& aOther) = delete;
        FILE* m_logfile;                  
        bool m_opened;                    
        eOpeningMode m_openMode;          
        std::string m_fileName;           
        std::filesystem::path m_filePath; 
        std::ofstream m_fStream;          
        char m_logFileNAME[256];          
        void close();
    };
}  // End of namespace