Logger.hxx

/*
 * Copyright (c) 2017 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see  <http://www.gnu.org/licenses/>
 */

#include <ostream>

namespace fifr
{
namespace util
{
class Logger
{
public:
    class LogStream
    {
    public:
        LogStream(const char* name, std::ostream* s) : stream_(s)
        {
            if (s) {
                *s << name << " ";
            }
        }

        ~LogStream()
        {
            if (stream_) *stream_ << std::endl;
        }

        std::ostream* stream() { return stream_; }

    private:
        std::ostream* stream_;
    };

public:
    enum class Level {
        Debug,  
        Info,   
        Warn,   
        Error,  
        None,   
    };

public:
    Logger(std::ostream& out) : out_(out), level_(Level::Info) {}

    void set_level(Level level) { level_ = level; }

    Level level() const { return level_; }

    LogStream info() { return {"I  ", level_ <= Level::Info ? &out_ : nullptr}; }

    LogStream warn() { return {"W  ", level_ <= Level::Warn ? &out_ : nullptr}; }

    LogStream error() { return {"E  ", level_ <= Level::Error ? &out_ : nullptr}; }

    LogStream debug() { return {"D  ", level_ <= Level::Debug ? &out_ : nullptr}; }

private:
    std::ostream& out_;
    Level level_;

public:
    static Logger default_logger;
};

inline Logger::LogStream info()
{
    return Logger::default_logger.info();
}

inline Logger::LogStream warn()
{
    return Logger::default_logger.warn();
}

inline Logger::LogStream error()
{
    return Logger::default_logger.error();
}

inline Logger::LogStream debug()
{
    return Logger::default_logger.debug();
}

template <class T>
Logger::LogStream& operator<<(Logger::LogStream& log, const T& x)
{
    auto s = log.stream();
    if (s) *s << x;
    return log;
}

template <class T>
Logger::LogStream& operator<<(Logger::LogStream&& log, const T& x)
{
    auto s = log.stream();
    if (s) *s << x;
    return log;
}
}  // namespace util
}  // namespace fifr