/home/fwph/code/wurde/rde/core/Logger.H

Go to the documentation of this file.

#ifndef _LOGGER_H
#define _LOGGER_H

#include <Capability.H>
#include <LoggerTransport.H>
#include <queue>
#include <syslog.h>
#include <sstream>
#include <streambuf>
#include <iostream>
#include <vector>
#include <pthread.h>

// $Id: Logger.H 68 2007-02-01 17:56:57Z fwph $

#define LOGGER "Logger"

namespace WURDE {


        const char *priorityToString(int priority);
        
        class Logger : public LoggerTransport{
                
        public:
                Logger(std::string somename);
                
                Logger(std::string somename, std::string filename);
                
                ~Logger(){};
                
                void initLogger();
                
                //             Logger & operator <<(ostringstream & right);
                //             Logger & operator <<(string right);
                
                /*             void log(){
                               info(m_stream.str());
                               }*/
                
                /*             std::stringstream& operator<<(const std::string& s){
                               m_stream.str(std::string());
                               m_stream << s;
                               return m_stream;
                               }*/
                
                //             std::ostream &flush();
                
                void log(std::string somestring, int priority);
                
                void debug(std::string somestring) { log(somestring, LOG_DEBUG); };
                
                void info(std::string somestring) { log(somestring, LOG_INFO);};
                
                void notice(std::string somestring) { log(somestring, LOG_NOTICE);};
                
                void warn(std::string somestring) { log(somestring, LOG_WARNING);};
                
                void error(std::string somestring) { log(somestring,LOG_ERR);};
                
                
                void fatal(std::string somestring) { log(somestring,LOG_CRIT);}; 
                
                void log(std::string somestring) { log(somestring,LOG_INFO); }; 
                
                void setNetworkLogging(bool value);
                
                void setSysLogging(bool value);
                
                void setStderr(bool value);
                
                void logData(std::string description, std::string format, std::string data);
                
                void setLogLevel(int priority){m_logLevel=priority;}
                
        private:
                void init(std::string somename);
                
                
                /* Gives the output file, and whether or not to log to one. Default is no.
                   Currently have not decided how to output the data, or how to deal with format strings.
                   There will be a sensible default. */
                
                std::string m_outFilename;
                bool m_toFile;
                
                /* Specifies whether to log to the network. Default is yes. */
                bool m_toNetwork;
                
                /* Specifies whether to log to syslog. Default is yes. Data arrays will *not* be sent, only pure strings. */
                bool m_toSyslog;
                
                /* Specifies whether to have syslog also send to stderr. Default is yes */
                bool m_toStderr;
                
                int m_logLevel;
                
                bool m_init;
                std::string m_logName;

                pthread_mutex_t mutex;
        };

        extern Logger *g_robotLoggerPtr;        
        
        inline void g_log(std::string logString, int priority){
                if(g_robotLoggerPtr){
                        g_robotLoggerPtr->log(logString,priority);
                }else{
                        std::cerr << priorityToString(priority) << logString; 
                }
        }

        inline void g_debug(std::string logString){g_log(logString,LOG_DEBUG);};
        
        inline void g_info(std::string logString){g_log(logString,LOG_INFO);};
        
        inline void g_notice(std::string logString){g_log(logString,LOG_NOTICE);};
        
        inline void g_warn(std::string logString){g_log(logString,LOG_WARNING);};
        
        inline void g_error(std::string logString){g_log(logString,LOG_ERR);};
        
        inline void g_fatal(std::string logString){g_log(logString,LOG_CRIT);};
        
        /*       inline void theCallback(std::ios_base::event ev, std::ios_base& ios, int index){
                 if(ev==std::ios_base::copyfmt_event){
                 if(g_robotLoggerPtr){
                 g_robotLoggerPtr->log();
                 }
                 }
              }*/
        
        class LoggerStreamBuf : 
                public std::basic_streambuf<char, std::char_traits<char> >{
        private:
                //            std::vector<char> m_buffer;
                std::stringstream m_out;           
                int m_priority;
                std::string m_buffer;
                std::vector<char> m_vector;
                //typedef typename std::basic_streambuf<charT, traits>::int_type int_type;
                //std::basic_streambuf<charT, traits>* out_;
                pthread_mutex_t mutex;
        public:
                
                virtual int overflow(int c){
                        pthread_mutex_lock(&mutex);
                        if(std::char_traits<char>::not_eof(c)){
                                m_vector.push_back(c);
                                //                          m_buffer += (char) c;
                                //                          m_buffer.push_back(c);
                                //                          m_out.put(c);
                        }
                        pthread_mutex_unlock(&mutex);
                        return std::char_traits<char>::not_eof(c);
                }
                
                LoggerStreamBuf(int priority){ 
                        m_priority=priority;
                        m_buffer= " ";
                        mutex=(pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
                }
              
                virtual int sync(){
                        pthread_mutex_lock(&mutex);
                        //                          m_out.sputn(&buffer_[0], static_cast<std::streamsize>(m_buffer.size()));
                        // m_buffer.clear();
                        if(m_vector.size()>0){
                                std::vector<char>::iterator iter;
                                //                          m_vector.push_back('\0');
                                for(iter=m_vector.begin();iter!=m_vector.end();iter++){
                                        m_buffer+=*iter;
                                }
                                //                          iter=m_vector.begin();
                                //m_buffer=&(*iter);
                                // m_out.flush();
                                g_log(m_buffer,m_priority);
                                //  delete m_out;
                                // m_out = new std::stringstream;
                                //m_out.str(std::string());
                                m_buffer=" ";
                                m_vector.clear();
                        }
                        pthread_mutex_unlock(&mutex);
                        return 0;
                }
                
                ~LoggerStreamBuf(){
                        sync();
                }
                
                virtual std::streamsize xsputn(const char* s, std::streamsize num){
                        //char buf[num+1];
                        //memcpy(buf,s,num);
                        //buf[num]='\0';
                        //                   m_buffer += buf;
                        // m_out << s;
                        //                   m_out.write(s,num);
                        pthread_mutex_lock(&mutex);
                        std::copy(s, s+num,std::back_inserter<std::vector<char> >(m_vector));
                        pthread_mutex_unlock(&mutex);
                        return num;
                }
        };
        
        class LoggerStringBuf : virtual public std::stringbuf{
        public:
                LoggerStringBuf(int priority){
                        m_priority=priority;
                }
                ~LoggerStringBuf(){sync();}
                
                virtual int sync(){               
                        g_log(str(),m_priority);
                        str(std::string());
                        return 0;
                }
                
        private:
                int m_priority;
        };
        
        class LoggerStreamBuf_init{
        private:
                LoggerStreamBuf buf_;
        public:
                LoggerStreamBuf_init(int priority):
                        buf_(priority){}
                LoggerStreamBuf* buf()
                {
                        return &buf_;
                }
        };
        
        class LoggerStream : 
                private LoggerStreamBuf_init,
                public std::ostream{
                //            public std::ostream<char, std::char_traits<char> >{
        public:
                LoggerStream(int priority) :
                        LoggerStreamBuf_init(priority),
                        std::ostream(LoggerStreamBuf_init::buf()) { }
                //                   std::basic_ostream<char, std::char_traits<char> >(LoggerStreamBuf_init::buf()) { }
        };
        
        extern LoggerStream g_logdebug;
        extern LoggerStream g_loginfo;
        extern LoggerStream g_lognotice;
        extern LoggerStream g_logwarn;
        extern LoggerStream g_logerror;
        extern LoggerStream g_logfatal;
        
}


#endif

---