log/log.h

/*--------------------------------------------------------------------------

  This is part of the Distributed system of the Karoo project.

  (C) 2006,2007,2008 Brian Modra <brian@zwartberg.com>

  This library is free software; you can redistribute them and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License,
  or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with these libraries; if not, write to the Free Software Foundation,
  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

--------------------------------------------------------------------------*/

#ifndef log_h
#define log_h

#ifndef _REENTRANT
#define _REENTRANT
#endif

#include "config.h"
#include "base.h"
#include "util.h"

using std::ostream;

namespace karoo {

    enum log_level {
        LOG_LEVEL_LOW_DEBUG = 0,
        LOG_LEVEL_DEBUG,
        LOG_LEVEL_INFO,
        LOG_LEVEL_WARNING,
        LOG_LEVEL_ERROR,
        LOG_LEVEL_FATAL
    };

    class log_output: public referable
    {
    private:
    protected:
        enum log_level level;
        text name;
        void message(const text& msg, enum log_level level);
        karoo_mutex sem;
    public:
        log_output(enum log_level level = LOG_LEVEL_WARNING);
        virtual ~log_output();

        void setName(const char* name);
        void setName(const text& name);
        void setLevel(enum log_level level);

        void low_debug(const text& msg);
        void debug(const text& msg);
        void info(const text& msg);
        void warning(const text& msg);
        void error(const text& msg);
        void fatal(const text& msg);

        operator enum log_level() const { return level; }
    };

    class logstream;

    class log
    {
    private:
    protected:
        mutable karoo_mutex sem;
        mutable log_output* logger;
    public:
        log();
        log(enum log_level level);
        log(const log& ref);
        log(log_output* r);
        virtual ~log();

        void setName(const char* name);
        void setName(const text& name);

        void setLevel(enum log_level level);

        void debug(const text& msg);
        void info(const text& msg);
        void warning(const text& msg);
        void error(const text& msg);
        void fatal(const text& msg);

        const log& operator=(const log& ref);
        const log& operator=(log_output* r);

        operator bool() const;
        operator enum log_level() const;
        operator logstream() const;

        logstream* new_logstream() const;
    };
    
    class logstream
    {
    private:
    protected:
        mutable karoo_mutex sem;
        mutable log_output* logger;
        char* buf;
        size_t buf_pos;
        size_t buf_size;
        enum log_level buf_level;
        void appendBuf(const char* str);
        void appendBuf(char c);
        void resizeBuf(size_t sz);
    public:
        logstream(log_output* logger);
        logstream(const logstream& ref);
        logstream& operator=(const logstream& ref);
        virtual ~logstream();

        logstream& operator<<(const enum log_level val);
        logstream& operator<<(bool val);
        logstream& operator<<(short val);
        logstream& operator<<(unsigned short val);
        logstream& operator<<(int val);
        logstream& operator<<(unsigned int val);
        logstream& operator<<(long val);
        logstream& operator<<(unsigned long val);
        logstream& operator<<(long long val);
        logstream& operator<<(unsigned long long val);
        logstream& operator<<(float val);
        logstream& operator<<(double val);
        logstream& operator<<(long double val);
        
        logstream& operator<<(char c);
        logstream& operator<<(unsigned char c);
        
        logstream& operator<<(const char* s);
        logstream& operator<<(const unsigned char* s);
        logstream& operator<<(const text& s);
        
        logstream& flush();
    };
    
}

#endif

---