CLogger.hpp

Go to the documentation of this file.

#ifndef CLOGGER_HPP
#define CLOGGER_HPP

#include <cstdlib>
#include <fstream>
#include <string>

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/foreach.hpp>
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/program_options.hpp>
#include <boost/shared_ptr.hpp>

namespace po = boost::program_options;

// Pretty function is nonstandard. Fallback to standards if not using GNU C++.
// Note that GNU __PRETTY_FUNCTION__ is a local variable, NOT a macro!!!
#ifndef __GNUG__
#define __PRETTY_FUNCTION__ ( std::string("At ") + basename(__FILE__) + \
std::string(" line ") + boost::lexical_cast<std::string>(__LINE__) ).c_str()
#endif

namespace freedm {
namespace broker {

std::string basename( const std::string s );

class CLocalLogger;

typedef CLocalLogger* CLoggerPointer;

class CGlobalLogger : private boost::noncopyable
{
    public:
        static CGlobalLogger& instance();
        void RegisterLocalLogger(const std::string logger);
        void SetOutputLevel(const std::string logger, const unsigned int level);
        unsigned int GetOutputLevel(const std::string logger) const;
        void SetGlobalLevel(const unsigned int level);
        void SetInitialLoggerLevels(const std::string loggerCfgFile);
        void ListLoggers() const;
    private:
        unsigned int m_default;
        typedef std::map< const std::string, unsigned int > OutputMap;
        OutputMap m_loggers;
};

class CLog : public boost::iostreams::sink
{
    public:
        CLog(const CLoggerPointer p, const unsigned int level_,
                const std::string name_, std::ostream* const out_= &std::clog );
        std::streamsize write( const char* const s, std::streamsize n);
        unsigned int GetOutputLevel() const;
    private:
        const CLoggerPointer m_parent;
        unsigned int m_level;
        const std::string m_name;
        std::ostream * const m_ostream;
};

class CLocalLogger : private boost::noncopyable
{
    public:
        CLocalLogger(const std::string loggername);
        boost::iostreams::stream<CLog> Trace;
    boost::iostreams::stream<CLog> Debug;
        boost::iostreams::stream<CLog> Info;
        boost::iostreams::stream<CLog> Notice;
        boost::iostreams::stream<CLog> Status;
        boost::iostreams::stream<CLog> Warn;
        boost::iostreams::stream<CLog> Error;
        boost::iostreams::stream<CLog> Alert;
        boost::iostreams::stream<CLog> Fatal;
        std::string GetName() const;
        unsigned int GetOutputLevel() const;
        void SetOutputLevel(const unsigned int level);

    private:
        const std::string m_name;
};

} // namespace broker
} // namespace freedm

#endif