Logger.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__LOGGER__HH
#define __DIADES__UTILS__LOGGER__HH

#include <string>
#include <vector>
#include <list>
#include <unordered_map>
#include <ostream>
#include <boost/date_time/posix_time/posix_time.hpp>

using namespace boost::posix_time;
using std::vector;
using std::list;
using std::pair;
using std::unordered_map;
using std::ostream;
using std::string;

namespace Diades
{


  namespace Utils
  {
        class LoggerFactory;
        class Log;


        typedef enum { LgNothing=0, LgOutput=1, LgProcess=2, LgCritical=3, LgError=4, LgWarning=5, LgInfo=6, LgDebug=7 } LogLevel;
  


        
        class LoggerData
        {
        public:
          typedef LogLevel Level;  
        private:
          mutable vector< list< pair<ptime,string> > > _logs;
          mutable vector< list< pair<ptime,string> >::iterator > _unsavedBegin;
          
          LoggerData();

        public:
          ~LoggerData()
          {
                _logs.clear(); _unsavedBegin.clear();
          }
        private:
          void trace(Level level, ptime time, const string & msg);
        

          void printLevel(Level level,ostream & os) const;
          
          
          friend ostream & operator << (ostream & os, const LoggerData & logger);
          friend class Logger;
          friend class LoggerFactory;
        };



        /*******************************************************************************/

        
        class Logger
        {
        private:
          //mutable 
          std::shared_ptr<LoggerData> _data;
        public:
          typedef LogLevel Level;  
        public:

          Logger();

          Logger(const string & name);

          Logger(const Logger & logger):_data(logger._data){}

          ~Logger(){}
          
        private:

          Logger(std::shared_ptr<LoggerData> data):_data(data){}


          void trace(Level level, ptime time, const string & msg) const
          {
                _data->trace(level,time,msg);
          }

        public:
          void printLevel(Level level,ostream & os)
          {
                _data->printLevel(level,os);
          }
          
          friend ostream & operator << (ostream & os, const Logger & logger)
          {
                return os << *(logger._data);
          }
          friend class LoggerFactory;
          friend class Log;       
        };

        
        /*******************************************************************************/
        
        class LoggerFactory
        {
        private:
          static LoggerFactory * _instance;
          std::shared_ptr<LoggerData> _defaultLogger;
          unordered_map<string, std::shared_ptr<LoggerData>> _loggers;
          vector<string> _levelLabels;
        protected:
          LoggerFactory();

          
        public:
          
          static void destroy();



  
        public:

          
          
          const string & getLabel(LogLevel level) const
          {
                return _levelLabels[level];
          }
          
          ~LoggerFactory();


          static LoggerFactory * factory();
          Logger  getLogger(const string & name)
          {
                unordered_map<string, std::shared_ptr<LoggerData> >::const_iterator it = _loggers.find(name);
                if(it==_loggers.end())
                  {
                        std::shared_ptr<LoggerData> newOne(new LoggerData());
                        _loggers[name]=newOne;
                        return Logger(newOne);
                  }
                return  Logger(it->second);
          }

          Logger  getRootLogger()
          {
                return Logger(_defaultLogger);
          }
          friend ostream & operator << (ostream & os, const LoggerFactory & loggers);
                
        };


  
        
  };
};


#endif