LogStream.hh

Go to the documentation of this file.

#ifndef SLIC_LOGSTREAM_HH_
#define SLIC_LOGSTREAM_HH_ 1
 
// LCDD
#include "TimeUtil.hh"
 
// STL
#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include <vector>
 
using std::ofstream;
using std::string;
using std::ostream;
using std::ios;
using std::ios_base;
 
namespace LOG {
 
enum EManip {
    done = 101, head = 102, time = 103, level = 104, name = 105, sep = 106, endl = 107
};
 
enum ELevel {
    none = 0, always = 1, fatal = 2, error = 3, warning = 4, okay = 5, verbose = 6, debug = 7, nlevels = 8
};
}
 
static std::string levelNames[LOG::nlevels] = { "NONE", "ALWAYS", "FATAL", "ERROR", "WARNING", "OKAY", "VERBOSE", "DEBUG" };
 
namespace slic {
 
class LogStream {
 
    protected:
 
        LogStream(std::string name, LOG::ELevel level, ostream* os = &std::cout) :
                m_name(name), m_outputLevel(level), m_currentMessageLevel(LOG::none), m_os(os), m_active(true), m_fos(0) {
            ;
        }
 
        LogStream() :
                m_name("NONE"), m_outputLevel(LOG::okay), m_currentMessageLevel(LOG::none), m_os(&std::cout), m_active(true), m_fos(0) {
            ;
        }
 
        virtual ~LogStream() {
        }
 
        friend class LogManager;
 
    public:
 
        const std::string& getName() const {
            return m_name;
        }
 
        bool isActive() const {
            return m_active;
        }
 
        LOG::ELevel getOutputLevel() const {
            return m_outputLevel;
        }
 
        void setOutputLevel(const LOG::ELevel& outputLevel) {
            m_outputLevel = outputLevel;
        }
 
        ostream& getOutputStream() const {
            return *m_os;
        }
 
        LOG::ELevel getCurrentLevel() const {
            return m_currentMessageLevel;
        }
 
        void setCurrentLevel(LOG::ELevel level) {
            m_currentMessageLevel = level;
        }
 
        LogStream& operator <<(const LOG::ELevel& level) {
 
            setCurrentLevel(level);
 
            if (getCurrentLevel() <= getOutputLevel()) {
                // Set active state.
                setActive(true);
            } else {
                // Set inactive state.
                setActive(false);
            }
            return *this;
        }
 
        LogStream& operator <<(const LOG::EManip& x) {
            if (isActive()) {
                // End of message.
                if (x == LOG::done) {
                    getOutputStream() << std::endl;
                    // Print full header info.
                } else if (x == LOG::head) {
                    getOutputStream() << TimeUtil::getAscTime() << " :: " << levelNames[m_currentMessageLevel] << " :: " << getName() << " :: ";
                    // Print current time.
                } else if (x == LOG::time) {
                    getOutputStream() << TimeUtil::getAscTime();
                    // Print current message level.
                } else if (x == LOG::level) {
                    getOutputStream() << levelNames[m_currentMessageLevel];
                    // Print logger name.
                } else if (x == LOG::name) {
                    getOutputStream() << getName();
                } else if (x == LOG::sep) {
                    getOutputStream() << " :: ";
                    // Print end of line terminator.
                } else if (x == LOG::endl) {
                    getOutputStream() << std::endl;
                }
            }
            return *this;
        }
 
        void setOutputFile(const std::string& file) {
            m_fos = new ofstream();
            m_fos->open(file.c_str(), ios::app | ios::out);
            m_os = m_fos;
        }
 
        LogStream& debug() {
            return *this << LOG::debug;
        }
 
        LogStream& verbose() {
            return *this << LOG::verbose;
        }
 
        LogStream& okay() {
            return *this << LOG::okay;
        }
 
        LogStream& warning() {
            return *this << LOG::warning;
        }
 
        LogStream& error() {
            return *this << LOG::error;
        }
 
        LogStream& fatal() {
            return *this << LOG::fatal;
        }
 
        LogStream& always() {
            return *this << LOG::always;
        }
 
        void log(const std::string& message, const LOG::ELevel& level) {
            (*this) << level << message << LOG::done;
        }
 
        void log(const std::string& mesg) {
            log(mesg, getOutputLevel());
        }
 
        void debug(const std::string& mesg) {
            log(mesg, LOG::debug);
        }
 
        void verbose(const std::string& mesg) {
            log(mesg, LOG::verbose);
        }
 
        void okay(const std::string& mesg) {
            log(mesg, LOG::okay);
        }
 
        void warning(const std::string& mesg) {
            log(mesg, LOG::warning);
        }
 
        void error(const std::string& mesg) {
            log(mesg, LOG::error);
        }
 
        void fatal(const std::string& mesg) {
            log(mesg, LOG::fatal);
        }
 
        void always(const std::string& mesg) {
            log(mesg, LOG::always);
        }
 
        //LogStream& operator <<(const std::_Setiosflags &manip) {
        //    if (isActive()) {
        //        getOutputStream() << manip;
        //    }
        //    return *this;
        //}
        //LogStream& operator <<(const std::_Resetiosflags &manip) {
        //    if (isActive()) {
        //        getOutputStream() << manip;
        //    }
        //    return *this;
        //}
        //LogStream& operator <<(const std::_Setbase &manip) {
        //    if (isActive()) {
        //        getOutputStream() << manip;
        //    }
        //    return *this;
        //}
        //LogStream& operator <<(const std::_Setprecision &manip) {
        //    if (isActive()) {
        //        getOutputStream() << manip;
        //    }
        //    return *this;
        //}
        //LogStream& operator <<(const std::_Setw &manip) {
        //    if (isActive()) {
        //        getOutputStream() << manip;
        //    }
        //    return *this;
        //}
        LogStream& operator <<(ios& (*manip)(std::ios&)) {
            if (isActive()) {
                getOutputStream() << manip;
            }
            return *this;
        }
 
        LogStream& operator <<(std::ios_base& (*manip)(std::ios_base&)) {
            if (isActive()) {
                getOutputStream() << manip;
            }
            return *this;
        }
 
        template<typename T>
        LogStream& operator<<(const T& arg) {
            if (isActive()) {
                getOutputStream() << arg;
            }
            return *this;
        }
 
        template<typename T>
        LogStream& operator <<(const std::vector<T>& v) {
            if (isActive()) {
                for (typename std::vector<T>::const_iterator i = v.begin(); i != v.end(); ++i) {
                    getOutputStream() << *i << " ";
                }
            }
            return *this;
        }
 
        int width() const {
            return isActive() ? getOutputStream().width() : 0;
        }
 
        int width(int v) {
            return isActive() ? getOutputStream().width(v) : 0;
        }
 
        long flags() const {
            return isActive() ? getOutputStream().flags() : 0;
        }
 
        long flags(std::ios_base::fmtflags v) {
            return isActive() ? getOutputStream().flags(v) : 0;
        }
 
        long setf(std::ios_base::fmtflags v) {
            return isActive() ? getOutputStream().setf(v) : 0;
        }
 
        char fill() const {
            return isActive() ? getOutputStream().fill() : -1;
        }
 
        char fill(char v) {
            return isActive() ? getOutputStream().fill(v) : -1;
        }
 
        int precision() const {
            return isActive() ? getOutputStream().precision() : 0;
        }
 
        int precision(int v) {
            return isActive() ? getOutputStream().precision(v) : 0;
        }
 
        int rdstate() const {
            return isActive() ? getOutputStream().rdstate() : std::ios_base::failbit;
        }
 
        int good() const {
            return isActive() ? getOutputStream().good() : 0;
        }
 
        int eof() const {
            return isActive() ? getOutputStream().eof() : 0;
        }
 
        int bad() const {
            return isActive() ? getOutputStream().bad() : 0;
        }
 
        long setf(std::ios_base::fmtflags _f, std::ios_base::fmtflags _m) {
            return isActive() ? getOutputStream().setf(_f, _m) : 0;
        }
 
        void unsetf(std::ios_base::fmtflags _l) {
            if (isActive()) {
                getOutputStream().unsetf(_l);
            }
        }
 
        void clear(std::ios_base::iostate _i = std::ios_base::failbit) {
            if (isActive()) {
                getOutputStream().clear(_i);
            }
        }
 
    private:
 
        void setActive(bool active) {
            m_active = active;
        }
 
    private:
        std::string m_name;
        LOG::ELevel m_outputLevel;
        LOG::ELevel m_currentMessageLevel;
        ostream* m_os;
        bool m_active;
        std::ofstream* m_fos;
};
}
 
#endif