/users/dtb26/GITROOT/vetsim/vs-core/include/logger.h

Go to the documentation of this file.

/*
* AUTHOR    : David Brooks (dtb@iplatypus.org)
* VERSION   : 3.x series
* PLATFORM  : non-specific
* DATE      : 4/15/2012 9:42:57 AM
* COPYRIGHT : Copyright(c)2012, David Brooks,  All Rights Reserved
*
* File      : $Source:$
* Revision  : $Revision:$
* Author    : $Author:$
* Date      : $Date:$
* Tag name  : $Name:$
* Locker    : $Locker:$
* State     : $State: Exp $
*/
#ifndef LOGGER_H_INCLUDED
#define LOGGER_H_INCLUDED

#include <fstream>
#include <string>
#include "boost/filesystem.hpp"
#include "boost/interprocess/sync/file_lock.hpp"
#include "boost/interprocess/sync/scoped_lock.hpp"
#include <ctime>

#ifdef  NULLPTR
#undef  NULLPTR
#endif
#define NULLPTR 0

namespace iplatypus {

const unsigned int LOGGER_MAX_FLAGS = 5;

class logger {
        public:
        typedef enum log_t { debug = 0, info, warn, error, fatal } priority; 

        static logger * instance(const std::string & src, const log_t level = warn);

     static logger * instance(const std::string & src, const std::string & homedir, const log_t level = warn);

     inline static void terminate(void) { if( instance_ ) delete instance_; instance_ = NULLPTR; }

     void bind(const log_t lt, const std::string& to_file = CONSOLE);
 
        void bind_specific(const log_t lt, const std::string& to_file = CONSOLE);

     inline void log_level(const log_t newlevel) { this->log_level_ = newlevel; }
     
     inline const log_t log_level(void) const { return(this->log_level_); }
     
     void write(const log_t lt, const std::string& msg);
 
     void write(const std::string & srcfile, const log_t lt, const std::string& msg);           
     
        inline void write_debug(const std::string & msg) { this->write(debug, msg); }
        
        inline void write_info(const std::string & msg) { this->write(info, msg); }
                
        inline void write_warn(const std::string & msg) { this->write(warn, msg); }
                
        inline void write_error(const std::string & msg) { this->write(error, msg); }
                
        inline void write_fatal(const std::string & msg) { this->write(fatal, msg); }
                                                                                
        protected:
        logger(void){;}
    logger(const std::string & src, const log_t level = warn);
    logger(const std::string & src, const std::string & homedir, const log_t level = warn);
    virtual ~logger(void){ if(logs_){logs_->clear(); delete logs_; logs_ = NULL;}}
        logger(const logger & refcpy){;}
        std::string timestamp(void);
  
                
        private:
        const static std::string CONSOLE;
        const static std::string DFLTDIR;
        const static std::string DFLTFILE;
        const static std::string FLAGSTR[LOGGER_MAX_FLAGS];
                        
     bool                      dir_defined_; 
     log_t                     log_level_;   
        static logger*            instance_;     
     std::string               home_dir_;    
     std::string               src_file_;        
     std::vector<std::string>* logs_;            
};//eoc logger
}//eon iplatypus


#endif /*LOGGER_H_INCLUDED*/

---