---

log.h

Go to the documentation of this file.

/* 
 * This file is part of the rfc822 library (C) rebel42@users.sourceforge.net.
 *
 * The rfc822 library is released under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version. See the file COPYING
 * as included in the distribution for details.
 */
#ifndef UTILS_LOG_H
#define UTILS_LOG_H

#include <string>
#include <list>
#include <strstream>
#include <fstream>

#include "receiver.h"

using namespace std;

namespace utils {


namespace logging {


class msg: public string 
{
public:

        const char* file;
        

        int line;

        msg(const char* f, int l): 
                file(f), line(l)
                { }

        msg(const msg& m): string(m), file(m.file), line(m.line)
                { }
                
        msg& operator = (const msg& m)
        { 
                string::operator = (m); file = m.file; line = m.line; 
                return *this; 
        }
};



class listener {
public:
        listener();
        
        virtual ~listener();
                

        virtual bool onMsg(const msg& msg) = 0;
        
protected:

        void attach();


        void detach();
};


struct ostream_listener: public listener
{
        ostream& out;
public:
        ostream_listener(ostream& o = cerr);
        ~ostream_listener();
                
        bool onMsg(const msg& msg);
};

struct file_listener: private ofstream, public ostream_listener
{
public:
        file_listener(const string& name): 
                ofstream(name.c_str()), 
                ostream_listener((ofstream&)*this)
                { }
};



struct logfunc
{
        void operator()(const msg&);
};


class logger: public utils::receiver<msg, logfunc> {
public:
        logger();
        ~logger();
        
        void attach(listener* p);
        bool detach(listener* p);

        void handle(const msg& m);
        
private:
        boost::mutex    list_mutex;
        list<listener*> listeners;

public: 
        static logger   the_logger;
};


class dolog: public msg
{
public:
        dolog(const char* file, int line): msg(file, line) {};
        dolog(): msg(0, -1) {};
        ~dolog();
        
        mutable ostrstream buf;
};


const dolog& operator << (const dolog& l, const string& s);


template <class T>
const dolog& operator << (const dolog& l, const T& val)
{
        l.buf << val;
        return l;
}

struct nolog
{
        nolog(const char* file, int line) {};
        nolog() {};
};

template <class T>
inline const nolog& operator << (const nolog& l, const T& val)
        { return l; }


}       // namespace logging
};  // namespace utils


#define log utils::logging::dolog(__FILE__, __LINE__)

#ifdef NDEBUG
        #define dlog utils::logging::nolog()
#else


        #define dlog utils::logging::dolog(__FILE__, __LINE__)
#endif


#define LOG(v) log << #v << '=' << v << endl;


#define DLOG(v) dlog << #v << '=' << v << endl;

#endif

---