json_writer.h

#pragma once
 
#include <xrpl/json/json_forwards.h>
#include <xrpl/json/json_value.h>
 
#include <cstddef>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
 
namespace json {
 
class Value;

class WriterBase
{
public:
    virtual ~WriterBase() = default;
    virtual std::string
    write(Value const& root) = 0;
};

 
class FastWriter : public WriterBase
{
public:
    FastWriter() = default;
    ~FastWriter() override = default;
 
public:  // overridden from Writer
    std::string
    write(Value const& root) override;
 
private:
    void
    writeValue(Value const& value);
 
    std::string document_;
};

class StyledWriter : public WriterBase
{
public:
    StyledWriter();
    ~StyledWriter() override = default;
 
public:  // overridden from Writer
    std::string
    write(Value const& root) override;
 
private:
    void
    writeValue(Value const& value);
    void
    writeArrayValue(Value const& value);
    bool
    isMultilineArray(Value const& value);
    void
    pushValue(std::string const& value);
    void
    writeIndent();
    void
    writeWithIndent(std::string const& value);
    void
    indent();
    void
    unindent();
 
    using ChildValues = std::vector<std::string>;
 
    ChildValues childValues_;
    std::string document_;
    std::string indentString_;
    int rightMargin_{74};
    int indentSize_{3};
    bool addChildValues_{};
};

class StyledStreamWriter
{
public:
    StyledStreamWriter(std::string indentation = "\t");
    ~StyledStreamWriter() = default;
 
public:
    void
    write(std::ostream& out, Value const& root);
 
private:
    void
    writeValue(Value const& value);
    void
    writeArrayValue(Value const& value);
    bool
    isMultilineArray(Value const& value);
    void
    pushValue(std::string const& value);
    void
    writeIndent();
    void
    writeWithIndent(std::string const& value);
    void
    indent();
    void
    unindent();
 
    using ChildValues = std::vector<std::string>;
 
    ChildValues childValues_;
    std::ostream* document_{nullptr};
    std::string indentString_;
    int rightMargin_{74};
    std::string indentation_;
    bool addChildValues_{};
};
 
std::string
valueToString(Int value);
std::string
valueToString(UInt value);
std::string
valueToString(double value);
std::string
valueToString(bool value);
std::string
valueToQuotedString(char const* value);

std::ostream&
operator<<(std::ostream&, Value const& root);
 
//------------------------------------------------------------------------------
 
// Helpers for stream
namespace detail {
 
template <class Write>
void
writeString(Write const& write, std::string const& s)
{
    write(s.data(), s.size());
}
 
template <class Write>
void
writeValue(Write const& write, Value const& value)
{
    switch (value.type())
    {
        case ValueType::Null:
            write("null", 4);
            break;
 
        case ValueType::Int:
            writeString(write, valueToString(value.asInt()));
            break;
 
        case ValueType::UInt:
            writeString(write, valueToString(value.asUInt()));
            break;
 
        case ValueType::Real:
            writeString(write, valueToString(value.asDouble()));
            break;
 
        case ValueType::String:
            writeString(write, valueToQuotedString(value.asCString()));
            break;
 
        case ValueType::Boolean:
            writeString(write, valueToString(value.asBool()));
            break;
 
        case ValueType::Array: {
            write("[", 1);
            int const size = value.size();
            for (int index = 0; index < size; ++index)
            {
                if (index > 0)
                    write(",", 1);
                writeValue(write, value[index]);
            }
            write("]", 1);
            break;
        }
 
        case ValueType::Object: {
            Value::Members const members = value.getMemberNames();
            write("{", 1);
            for (auto it = members.begin(); it != members.end(); ++it)
            {
                std::string const& name = *it;
                if (it != members.begin())
                    write(",", 1);
 
                writeString(write, valueToQuotedString(name.c_str()));
                write(":", 1);
                writeValue(write, value[name]);
            }
            write("}", 1);
            break;
        }
    }
}
 
}  // namespace detail

template <class Write>
void
stream(json::Value const& jv, Write const& write)
{
    detail::writeValue(write, jv);
    write("\n", 1);
}

class Compact
{
    json::Value jv_;
 
public:
    Compact(json::Value&& jv) : jv_{std::move(jv)}
    {
    }
 
    friend std::ostream&
    operator<<(std::ostream& o, Compact const& cJv)
    {
        detail::writeValue(
            [&o](void const* data, std::size_t n) { o.write(static_cast<char const*>(data), n); },
            cJv.jv_);
        return o;
    }
};
 
}  // namespace json