LogBinding.h

Go to the documentation of this file.

#ifndef LOGGER_BINDING_LOGBINDING_H
#define LOGGER_BINDING_LOGBINDING_H

#include <string>
#include <iostream>
#include <sstream>
#include <baselib_binding/SharedPtr.h>

namespace logger_binding
{

class Log
{
public:
    typedef baselib_binding::shared_ptr<Log>::type LogPtr;

    static void print(const std::stringstream& str)
    {
        if (sglOK(str.str().c_str())) Singleton->implPrint(str);
    }
    static void printError(const std::stringstream& str)
    {
        if (sglOK(str.str().c_str())) Singleton->implPrintError(str);
    }
    static void printWarn(const std::stringstream& str)
    {
        if (sglOK(str.str().c_str())) Singleton->implPrintWarn(str);
    }

    static void print(const char * str)
    {
        if (sglOK(str)) Singleton->implPrint(str);
    }
    static void printError(const char * str)
    {
        if (sglOK(str)) Singleton->implPrintError(str);
    }
    static void printWarn(const char * str)
    {
        if (sglOK(str)) Singleton->implPrintWarn(str);
    }

    static void printLn(const std::stringstream& str)
    {
        if (sglOK(str.str().c_str()))
        {
            Singleton->implPrint(str);
            Singleton->printNewLine(false);
        }
    }
    static void printErrorLn(const std::stringstream& str)
    {
        if (sglOK(str.str().c_str()))
        {
            Singleton->implPrintError(str);
            Singleton->printNewLine(false);
        }
    }
    static void printWarnLn(const std::stringstream& str)
    {
        if (sglOK(str.str().c_str()))
        {
            Singleton->implPrintWarn(str);
            Singleton->printNewLine(false);
        }
    }

    static void printLn(const char * str)
    {
        if (sglOK(str))
        {
            Singleton->implPrint(str);
            Singleton->printNewLine(false);
        }
    }
    static void printErrorLn(const char * str)
    {
        if (sglOK(str))
        {
            Singleton->implPrintError(str);
            Singleton->printNewLine(false);
        }
    }
    static void printWarnLn(const char * str)
    {
        if (sglOK(str))
        {
            Singleton->implPrintWarn(str);
            Singleton->printNewLine(false);
        }
    }

    static LogPtr Singleton;

protected:
    virtual void implPrint(const std::stringstream& str) = 0;
    virtual void implPrintError(const std::stringstream& str) = 0;
    virtual void implPrintWarn(const std::stringstream& str) = 0;
    virtual void implPrint(const char * str) = 0;
    virtual void implPrintError(const char * str) = 0;
    virtual void implPrintWarn(const char * str) = 0;
    virtual void printNewLine(bool errorStream) = 0;

private:

    static bool sglOK(const char * msg)
    {
        if (Singleton.get()) return true;

        if (!initSglWarningPrinted)
        {
            std::cerr << "WARNING: Initialise Log Singleton to use the proper Logger. Now printing to std out." << std::endl;
            initSglWarningPrinted = true;
        }
        std::cout << msg << std::endl;
        return false;
    }

    // print warning that Singleton is not initialized only once.
    static bool initSglWarningPrinted;
};

class StdLog: public Log
{
protected:
    virtual void implPrint(const std::stringstream& str)
    {
        std::cout << str.str();
    }
    virtual void implPrintError(const std::stringstream& str)
    {
        std::cerr << "ERROR:" << str.str();
    }
    virtual void implPrintWarn(const std::stringstream& str)
    {
        std::cout << "WARNING:" << str.str();
    }

    virtual void implPrint(const char* str)
    {
        std::cout << str;
    }
    virtual void implPrintError(const char* str)
    {
        std::cerr << "ERROR: " << str;
    }
    virtual void implPrintWarn(const char* str)
    {
        std::cout << "WARNING: " << str;
    }


    virtual void printNewLine(bool errorStream)
    {
        if (errorStream) std::cerr << std::endl;
        else std::cout << std::endl;
    }
};

}  // namespace logger_binding

extern std::string getFilenameFromPath(const std::string& path);

// in a path to a file name, erase the filename from it and return only directory path
extern std::string getFileDirectory(const std::string& pathToFile);

// initialize the print log singleton to use std::out and std::err
#define PRINT_INIT_STD() \
{\
    if (logger_binding::Log::Singleton) \
    {\
        std::cerr << "Singleton already set, overwriting!" << std::endl;\
    }\
    logger_binding::Log::Singleton = SHARED_PTR<logger_binding::Log>(new logger_binding::StdLog()); \
}


#define PRINTMSG(msg) \
{\
    std::stringstream _str_; \
    _str_ << msg << " - "<< getFilenameFromPath(__FILE__) << ", " << __LINE__; \
    logger_binding::Log::printLn(_str_); \
}

#define PRINTDEBUG(msg) \
{\
    std::stringstream _str_; \
    _str_ << msg << " - "<< getFilenameFromPath(__FILE__) << ", " << __LINE__; \
    logger_binding::Log::printLn(_str_); \
}

#define PRINTERROR(msg) \
{\
    std::stringstream _str_; \
    _str_ << msg << " - "<< getFilenameFromPath(__FILE__) << ", " << __LINE__; \
    logger_binding::Log::printErrorLn(_str_); \
}

#define PRINTWARN(msg) \
{\
    std::stringstream _str_; \
    _str_ << msg << " - "<< getFilenameFromPath(__FILE__) << ", " << __LINE__; \
    logger_binding::Log::printWarnLn(_str_); \
}


#endif  // LOGGER_BINDING_LOGBINDING_H