osblog.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Stephan Broennimann (vb)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.20 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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 General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _OSBLOG_H_
#define _OSBLOG_H_

// ************************************************************************
// included header files
// + standard includes
#include <ostream>
#include <memory>

// + libraries

// + local headers

// + class declarations

// ************************************************************************
// namespace extensions
namespace OSB_LIB {

// ************************************************************************
// forward declarations

// ************************************************************************
// type definitions

// ************************************************************************
// class definitions
    class LogBase {
    public:
        struct HeadFiller {
            char filler_;
        };
    public:
        explicit LogBase(int logLevel);
        virtual ~LogBase();

    public:

        inline LogBase& fatal();
        inline LogBase& error();
        inline LogBase& warn();
        inline LogBase& info();

        inline LogBase& raw(int level);

        inline LogBase& debug(int level);

    public:
        virtual void elog() = 0;

        virtual void endlog() = 0;

        virtual LogBase& nl() = 0;
        virtual LogBase& head(char filler) = 0;

    public:


        inline void operator<<(
            void (*func)(LogBase&)
        );
        inline LogBase& operator<<(
            LogBase& (*func)(LogBase&)
        );
        inline LogBase& operator<<(
            const HeadFiller& filler
        );

        template<typename T>
        inline LogBase& operator<<(const T& t);


        inline LogBase& operator<<(
            std::ostream& (*func)(std::ostream&)
        );
        inline LogBase& operator<<(
            std::ios& (*func)(std::ios&)
        );
        inline LogBase& operator<<(
            std::ios_base& (*func)(std::ios_base&)
        );

    public:


        virtual int logLevel() const;
        virtual bool verbose() const;
        virtual void setLevel(int logLevel);
        virtual void setVerbose(bool on);

    protected:
        virtual LogBase& start(int level, bool noHead = false) = 0;

        virtual std::ostream& plog() = 0;
        virtual std::ostream* slog() = 0;

        inline bool mustLog() const;

    protected:
        int logLevel_;
        int curLevel_;
        bool verbose_;
        bool noHead_;
        bool useIndent_;
        std::string indent_;
    };                                  // class LogBase

    class Log {
    public:


        inline static LogBase& fatal();
        inline static LogBase& error();
        inline static LogBase& warn();
        inline static LogBase& info();

        inline static LogBase& raw(int level = 4);

        inline static LogBase& cont();
        inline static void endlog();
        inline static void empty(int level, int lines = 1);
        inline static LogBase& debug(int level = 1);

        inline static LogBase& nl(LogBase& log);
        inline static void elog(LogBase& log);
        inline static void endlog(LogBase& log);
        inline static const LogBase::HeadFiller head(char filler = ' ');

    public:


        static LogBase* setInstance(LogBase* instance);
        static LogBase* setInstance(
            std::auto_ptr<LogBase> instance
        );
        inline static int logLevel();
        inline static bool verbose();
        inline static void setLevel(int logLevel);
        inline static void setVerbose(bool on);
    private:
        Log();
    private:
        static LogBase& instance();
    private:
        static LogBase* instance_;
        static bool ownsInstance_;
    };                                  // class Log

    class ConsoleLog : public LogBase {
    public:
        explicit ConsoleLog(int logLevel);

    public:
        LogBase& nl();
        virtual void elog();
        virtual void endlog();
        LogBase& head(char);

    protected:
        virtual LogBase& start(int level, bool noHead);

    private:
        LogBase& init(const char* what);

        std::ostream& plog();
        std::ostream* slog();

    private:
        bool useCerr_;
    };                                  // class ConsoleLog
}                                       // namespace OSB_LIB

// ************************************************************************
// inline definitions
namespace OSB_LIB {
    // ********************************************************************
    // class Log
    LogBase& Log::fatal()
    {
        return instance().fatal();
    }

    LogBase& Log::error()
    {
        return instance().error();
    }

    LogBase& Log::warn()
    {
        return instance().warn();
    }

    LogBase& Log::info()
    {
        return instance().info();
    }

    LogBase& Log::raw(int level)
    {
        return instance().raw(level);
    }

    LogBase& Log::debug(int level)
    {
        return instance().debug(level);
    }

    LogBase& Log::cont()
    {
        return instance();
    }

    void Log::endlog()
    {
        instance().endlog();
    }

    void Log::empty(int level, int lines)
    {
        if (1 > lines) return;

        raw(level);
        for (int i = 0; i < lines; ++i) cont() << "\n";
        endlog();
    }

    LogBase& Log::nl(LogBase& log)
    {
        return log.nl();
    }

    void Log::elog(LogBase& log)
    {
        log.elog();
    }

    void Log::endlog(LogBase& log)
    {
        log.endlog();
    }

    const LogBase::HeadFiller Log::head(char filler)
    {
        LogBase::HeadFiller rc;
        rc.filler_ = filler;
        return rc;
    }

    int Log::logLevel()
    {
        return instance().logLevel();
    }

    void Log::setLevel(int logLevel)
    {
        return instance().setLevel(logLevel);
    }

    bool Log::verbose()
    {
        return instance().verbose();
    }

    void Log::setVerbose(bool on)
    {
        return instance().setVerbose(on);
    }

    // ********************************************************************
    // class LogBase
    LogBase& LogBase::fatal()
    {
        return start(1);
    }

    LogBase& LogBase::error()
    {
        return start(2);
    }

    LogBase& LogBase::warn()
    {
        return start(3);
    }

    LogBase& LogBase::info()
    {
        return start(4);
    }

    LogBase& LogBase::raw(int level)
    {
        return start(level, true);
    }

    LogBase& LogBase::debug(int level)
    {
        return start(level+4);
    }

    bool LogBase::mustLog() const
    {
        if (-1 == logLevel_) return true;
        if (curLevel_ > logLevel_) return false;
        return true;
    }

    void LogBase::operator<<(
        void (*func)(LogBase&)
    )
    {
        func(*this);
    }

    LogBase& LogBase::operator<<(
        LogBase& (*func)(LogBase&)
    )
    {
        return func(*this);
    }

    LogBase& LogBase::operator<<(
        const HeadFiller& filler
    )
    {
        return this->head(filler.filler_);
    }

    template<typename T>
    LogBase& LogBase::operator<<(const T& t)
    {
        if (useIndent_) {
            useIndent_ = false;
            *this << indent_;
        }

        if (!mustLog()) return *this;

        plog() << t;
        if (verbose_) {
            std::ostream* s = slog();
            if (s) *s << t;
        }
        return *this;
    }

    LogBase& LogBase::operator<<(
        std::ostream& (*func)(std::ostream&)
    )
    {
        if (!mustLog()) return *this;

        plog() << func;
        if (verbose_) {
            std::ostream* s = slog();
            if (s) *s << func;
        }
        return *this;
    }

    LogBase& LogBase::operator<<(
        std::ios& (*func)(std::ios&)
    )
    {
        if (!mustLog()) return *this;

        plog() << func;
        if (verbose_) {
            std::ostream* s = slog();
            if (s) *s << func;
        }
        return *this;
    }

    LogBase& LogBase::operator<<(
        std::ios_base& (*func)(std::ios_base&)
    )
    {
        if (!mustLog()) return *this;

        plog() << func;
        if (verbose_) {
            std::ostream* s = slog();
            if (s) *s << func;
        }
        return *this;
    }
}                                       // namespace OSB_LIB
#endif                                  // #ifndef _OSBLOG_H_

---