Journal.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <cstdint>
#include <ostream>
#include <sstream>
#include <string>
#include <type_traits>
 
namespace beast {

enum class Severity : std::uint8_t {
    All = 0,
 
    Trace = All,
    Debug = 1,
    Info = 2,
    Warning = 3,
    Error = 4,
    Fatal = 5,
 
    Disabled = 6,
    None = Disabled
};

class Journal
{
public:
    class Sink;
 
private:
    // Invariant: sink_ always points to a valid Sink
    Sink* sink_;
 
public:
    //--------------------------------------------------------------------------

    class Sink
    {
    protected:
        explicit Sink(Sink const& sink) = default;
        Sink(Severity thresh, bool console);
 
    public:
        virtual ~Sink() = 0;
 
        Sink() = delete;
        Sink&
        operator=(Sink const& lhs) = delete;

        [[nodiscard]] virtual bool
        active(Severity level) const;

        [[nodiscard]] virtual bool
        console() const;

        virtual void
        console(bool output);

        [[nodiscard]] virtual Severity
        threshold() const;

        virtual void
        threshold(Severity thresh);

        virtual void
        write(Severity level, std::string const& text) = 0;

        virtual void
        writeAlways(Severity level, std::string const& text) = 0;
 
    private:
        Severity thresh_;
        bool console_;
    };
 
#ifndef __INTELLISENSE__
    static_assert(!std::is_default_constructible_v<Sink>);
    static_assert(!std::is_copy_constructible_v<Sink>);
    static_assert(!std::is_move_constructible_v<Sink>);
    static_assert(!std::is_copy_assignable_v<Sink>);
    static_assert(!std::is_move_assignable_v<Sink>);
    static_assert(std::is_nothrow_destructible_v<Sink>);
#endif

    static Sink&
    getNullSink();
 
    //--------------------------------------------------------------------------
 
    class Stream;
 
    /* Scoped ostream-based container for writing messages to a Journal. */
    class ScopedStream
    {
    public:
        ScopedStream(ScopedStream const& other) : ScopedStream(other.sink_, other.level_)
        {
        }
 
        ScopedStream(Sink& sink, Severity level);
 
        template <typename T>
        ScopedStream(Stream const& stream, T const& t);
 
        ScopedStream(Stream const& stream, std::ostream& manip(std::ostream&));
 
        ScopedStream&
        operator=(ScopedStream const&) = delete;
 
        ~ScopedStream();
 
        std::ostringstream&
        ostream() const
        {
            return ostream_;
        }
 
        std::ostream&
        operator<<(std::ostream& manip(std::ostream&)) const;
 
        template <typename T>
        std::ostream&
        operator<<(T const& t) const;
 
    private:
        Sink& sink_;
        Severity const level_;
        std::ostringstream mutable ostream_;
    };
 
#ifndef __INTELLISENSE__
    static_assert(!std::is_default_constructible_v<ScopedStream>);
    static_assert(std::is_copy_constructible_v<ScopedStream>);
    static_assert(std::is_move_constructible_v<ScopedStream>);
    static_assert(!std::is_copy_assignable_v<ScopedStream>);
    static_assert(!std::is_move_assignable_v<ScopedStream>);
    static_assert(std::is_nothrow_destructible_v<ScopedStream>);
#endif
 
    //--------------------------------------------------------------------------
public:
    class Stream
    {
    public:
        explicit Stream() : sink_(getNullSink()), level_(Severity::Disabled)
        {
        }

        Stream(Sink& sink, Severity level) : sink_(sink), level_(level)
        {
            XRPL_ASSERT(
                level_ < Severity::Disabled, "beast::Journal::Stream::Stream : maximum level");
        }

        Stream(Stream const& other) : Stream(other.sink_, other.level_)
        {
        }
 
        Stream&
        operator=(Stream const& other) = delete;

        [[nodiscard]] Sink&
        sink() const
        {
            return sink_;
        }

        [[nodiscard]] Severity
        level() const
        {
            return level_;
        }

        [[nodiscard]] bool
        active() const
        {
            return sink_.active(level_);
        }
 
        explicit
        operator bool() const
        {
            return active();
        }


        ScopedStream
        operator<<(std::ostream& manip(std::ostream&)) const;
 
        template <typename T>
        ScopedStream
        operator<<(T const& t) const;
 
    private:
        Sink& sink_;
        Severity level_;
    };
 
#ifndef __INTELLISENSE__
    static_assert(std::is_default_constructible_v<Stream>);
    static_assert(std::is_copy_constructible_v<Stream>);
    static_assert(std::is_move_constructible_v<Stream>);
    static_assert(!std::is_copy_assignable_v<Stream>);
    static_assert(!std::is_move_assignable_v<Stream>);
    static_assert(std::is_nothrow_destructible_v<Stream>);
#endif
 
    //--------------------------------------------------------------------------

    Journal() = delete;

    explicit Journal(Sink& sink) : sink_(&sink)
    {
    }

    [[nodiscard]] Sink&
    sink() const
    {
        return *sink_;
    }

    [[nodiscard]] Stream
    stream(Severity level) const
    {
        return Stream(*sink_, level);
    }

    [[nodiscard]] bool
    active(Severity level) const
    {
        return sink_->active(level);
    }

    [[nodiscard]] Stream
    trace() const
    {
        return {*sink_, Severity::Trace};
    }
 
    [[nodiscard]] Stream
    debug() const
    {
        return {*sink_, Severity::Debug};
    }
 
    [[nodiscard]] Stream
    info() const
    {
        return {*sink_, Severity::Info};
    }
 
    [[nodiscard]] Stream
    warn() const
    {
        return {*sink_, Severity::Warning};
    }
 
    [[nodiscard]] Stream
    error() const
    {
        return {*sink_, Severity::Error};
    }
 
    [[nodiscard]] Stream
    fatal() const
    {
        return {*sink_, Severity::Fatal};
    }

};
 
#ifndef __INTELLISENSE__
static_assert(!std::is_default_constructible_v<Journal>);
static_assert(std::is_copy_constructible_v<Journal>);
static_assert(std::is_move_constructible_v<Journal>);
static_assert(std::is_copy_assignable_v<Journal>);
static_assert(std::is_move_assignable_v<Journal>);
static_assert(std::is_nothrow_destructible_v<Journal>);
#endif
 
//------------------------------------------------------------------------------
 
template <typename T>
Journal::ScopedStream::ScopedStream(Journal::Stream const& stream, T const& t)
    : ScopedStream(stream.sink(), stream.level())
{
    ostream_ << t;
}
 
template <typename T>
std::ostream&
Journal::ScopedStream::operator<<(T const& t) const
{
    ostream_ << t;
    return ostream_;
}
 
//------------------------------------------------------------------------------
 
template <typename T>
Journal::ScopedStream
Journal::Stream::operator<<(T const& t) const
{
    return ScopedStream(*this, t);
}
 
namespace detail {
 
template <class CharT, class Traits = std::char_traits<CharT>>
class LogStreamBuf : public std::basic_stringbuf<CharT, Traits>
{
    beast::Journal::Stream strm_;
 
    void
    write(char const* s)
    {
        if (strm_)
            strm_ << s;
    }
 
    void
    write(wchar_t const* s)
    {
        if (strm_)
            strm_ << s;
    }
 
public:
    explicit LogStreamBuf(beast::Journal::Stream const& strm) : strm_(strm)
    {
    }
 
    ~LogStreamBuf() override
    {
        sync();
    }
 
    int
    sync() override
    {
        write(this->str().c_str());
        this->str("");
        return 0;
    }
 
    template <class T>
    void
    write(T const*) = delete;
};
 
}  // namespace detail
 
template <class CharT, class Traits = std::char_traits<CharT>>
class BasicLogstream : public std::basic_ostream<CharT, Traits>
{
    using char_type = CharT;
    using traits_type = Traits;
    using int_type = traits_type::int_type;
    using pos_type = traits_type::pos_type;
    using off_type = traits_type::off_type;
 
    detail::LogStreamBuf<CharT, Traits> buf_;
 
public:
    explicit BasicLogstream(beast::Journal::Stream const& strm)
        : std::basic_ostream<CharT, Traits>(&buf_), buf_(strm)
    {
    }
};
 
using logstream = BasicLogstream<char>;
using logwstream = BasicLogstream<wchar_t>;
 
}  // namespace beast