beast_Journal.cpp

#include <xrpl/beast/utility/Journal.h>
 
#include <ios>
#include <ostream>
#include <string>
 
namespace beast {
 
//------------------------------------------------------------------------------
 
// A Sink that does nothing.
class NullJournalSink : public Journal::Sink
{
public:
    NullJournalSink() : Sink(severities::kDisabled, false)
    {
    }
 
    ~NullJournalSink() override = default;
 
    bool
    active(severities::Severity) const override
    {
        return false;
    }
 
    bool
    console() const override
    {
        return false;
    }
 
    void
    console(bool) override
    {
    }
 
    severities::Severity
    threshold() const override
    {
        return severities::kDisabled;
    }
 
    void
    threshold(severities::Severity) override
    {
    }
 
    void
    write(severities::Severity, std::string const&) override
    {
    }
 
    void
    writeAlways(severities::Severity, std::string const&) override
    {
    }
};
 
//------------------------------------------------------------------------------
 
Journal::Sink&
Journal::getNullSink()
{
    static NullJournalSink sink;
    return sink;
}
 
//------------------------------------------------------------------------------
 
Journal::Sink::Sink(Severity thresh, bool console) : thresh_(thresh), m_console(console)
{
}
 
Journal::Sink::~Sink() = default;
 
bool
Journal::Sink::active(Severity level) const
{
    return level >= thresh_;
}
 
bool
Journal::Sink::console() const
{
    return m_console;
}
 
void
Journal::Sink::console(bool output)
{
    m_console = output;
}
 
severities::Severity
Journal::Sink::threshold() const
{
    return thresh_;
}
 
void
Journal::Sink::threshold(Severity thresh)
{
    thresh_ = thresh;
}
 
//------------------------------------------------------------------------------
 
Journal::ScopedStream::ScopedStream(Sink& sink, Severity level) : m_sink(sink), m_level(level)
{
    // Modifiers applied from all ctors
    m_ostream << std::boolalpha << std::showbase;
}
 
Journal::ScopedStream::ScopedStream(Stream const& stream, std::ostream& manip(std::ostream&))
    : ScopedStream(stream.sink(), stream.level())
{
    m_ostream << manip;
}
 
Journal::ScopedStream::~ScopedStream()
{
    std::string const& s(m_ostream.str());
    if (!s.empty())
    {
        if (s == "\n")
            m_sink.write(m_level, "");
        else
            m_sink.write(m_level, s);
    }
}
 
std::ostream&
Journal::ScopedStream::operator<<(std::ostream& manip(std::ostream&)) const
{
    return m_ostream << manip;
}
 
//------------------------------------------------------------------------------
 
Journal::ScopedStream
Journal::Stream::operator<<(std::ostream& manip(std::ostream&)) const
{
    return ScopedStream(*this, manip);
}
 
}  // namespace beast