OptimizerLog.h

Go to the documentation of this file.

//*************************************************************************//
//                                                                         //
//  LibCudaOptimize                                                        //
//  Copyright (C) 2012 Ibislab, University of Parma                        //
//  Authors: Youssef S.G. Nashed, Roberto Ugolotti                         //
//                                                                         //
//  You should have received a copy of the GNU General Public License      //
//  along with this program.  If not, see <http://www.gnu.org/licenses/>   //
//                                                                         //
//*************************************************************************//

/* http://www.drdobbs.com/cpp/logging-in-c/201804215 */

#ifndef __LOG_H__
#define __LOG_H__

#include <sstream>
#include <string>
#include <stdio.h>
enum LOG_LEVEL {logERROR, logWARNING, logINFO, logINFOEXT, logDEBUG, logDEBUG1, logDEBUG2, logDEBUG3, logDEBUG4, LOG_LEVEL_NUM};

#ifndef PRIVATE_DOXYGEN

//only messages with a level lower than or equal to FILELOG_MAX_LEVEL will be shown
#ifndef FILELOG_MAX_LEVEL
#define FILELOG_MAX_LEVEL logDEBUG4
#endif

template <typename T>
class Log
{
public:
    Log();
    virtual ~Log();
    std::ostringstream& Get(LOG_LEVEL level = logINFO);
public:
    static LOG_LEVEL& ReportingLevel();
    static std::string ToString(LOG_LEVEL level);
    static LOG_LEVEL FromString(const std::string& level);
protected:
    std::ostringstream os;
private:
    Log(const Log&);
    Log& operator =(const Log&);
};

template <typename T>
Log<T>::Log()
{
}

template <typename T>
std::ostringstream& Log<T>::Get(LOG_LEVEL level)
{
        os << ToString(level) << ": ";
    os << std::string(level > logDEBUG ? level - logDEBUG : 0, '\t');
    return os;
}

template <typename T>
Log<T>::~Log()
{
    os << std::endl;
    T::Output(os.str());
}

template <typename T>
LOG_LEVEL& Log<T>::ReportingLevel()
{
    static LOG_LEVEL reportingLevel = logDEBUG4;
    return reportingLevel;
}

template <typename T>
std::string Log<T>::ToString(LOG_LEVEL level)
{
        static const char* const buffer[] = {"ERROR", "WARNING", "INFO", "INFOEXT", "DEBUG", "DEBUG1", "DEBUG2", "DEBUG3", "DEBUG4"};
    return buffer[level];
}

template <typename T>
LOG_LEVEL Log<T>::FromString(const std::string& level)
{
    if (level == "DEBUG4")
        return logDEBUG4;
    if (level == "DEBUG3")
        return logDEBUG3;
    if (level == "DEBUG2")
        return logDEBUG2;
    if (level == "DEBUG1")
        return logDEBUG1;
    if (level == "DEBUG")
        return logDEBUG;
    if (level == "INFO")
        return logINFO;
    if (level == "INFOEXT")
        return logINFOEXT;
    if (level == "WARNING")
        return logWARNING;
    if (level == "ERROR")
        return logERROR;
    Log<T>().Get(logWARNING) << "Unknown logging level '" << level << "'. Using INFO level as default.";
    return logINFO;
}
#ifndef PRIVATE_DOXYGEN
class Output2FILE
{
public:
    static FILE*& Stream(const std::string fOut="");
    static void Output(const std::string& msg, const std::string fOut="");
};

inline FILE*& Output2FILE::Stream(const std::string fOut)
{
    static FILE* pStream = fOut.length() ? fopen(fOut.c_str(), "a+") : stderr;
    return pStream;
}

inline void Output2FILE::Output(const std::string& msg, const std::string fOut)
{   
    FILE* pStream = Stream(fOut);
    if (!pStream)
        return;
    fprintf(pStream, "%s", msg.c_str());
    fflush(pStream);
}
#endif
#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
#   if defined (BUILDING_FILELOG_DLL)
#       define FILELOG_DECLSPEC   __declspec (dllexport)
#   elif defined (USING_FILELOG_DLL)
#       define FILELOG_DECLSPEC   __declspec (dllimport)
#   else
#       define FILELOG_DECLSPEC
#   endif // BUILDING_DBSIMPLE_DLL
#else
#   define FILELOG_DECLSPEC
#endif // _WIN32

class FILELOG_DECLSPEC FILELog : public Log<Output2FILE> {};

#endif //private doxygen

#define FILE_LOG(level, maxLevel, outFile) \
    if (level > maxLevel) ;\
    else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream(outFile)) ; \
    else FILELog().Get(level)

#endif //__LOG_H__