json/Writer.h

#pragma once
 
#include <xrpl/basics/ToString.h>
#include <xrpl/basics/contract.h>
#include <xrpl/json/Output.h>
#include <xrpl/json/json_value.h>
 
#include <memory>
 
namespace json {

 
class Writer
{
public:
    enum class CollectionType { Array, Object };
 
    explicit Writer(Output const& output);
    Writer(Writer&&) noexcept;
    Writer&
    operator=(Writer&&) noexcept;
 
    ~Writer();

    void startRoot(CollectionType);

    void startAppend(CollectionType);

    void
    startSet(CollectionType, std::string const& key);

    void
    finish();

    void
    finishAll();

    template <typename Scalar>
    void
    append(Scalar t)
    {
        rawAppend();
        output(t);
    }

    void
    rawAppend();

    template <typename Type>
    void
    set(std::string const& tag, Type t)
    {
        rawSet(tag);
        output(t);
    }

    void
    rawSet(std::string const& key);
 
    // You won't need to call anything below here until you are writing single
    // items (numbers, strings, bools, null) to a JSON stream.
 
    /*** Output a string. */
    void
    output(std::string const&);
 
    /*** Output a literal constant or C string. */
    void
    output(char const*);
 
    /*** Output a json::Value. */
    void
    output(json::Value const&);

    void output(std::nullptr_t);

    void
    output(float);

    void
    output(double);

    void
    output(bool);

    template <typename Type>
    void
    output(Type t)
    {
        implOutput(std::to_string(t));
    }
 
    void
    output(json::StaticString const& t)
    {
        output(t.cStr());
    }
 
private:
    class Impl;
    std::unique_ptr<Impl> impl_;
 
    void
    implOutput(std::string const&);
};
 
inline void
check(bool condition, std::string const& message)
{
    if (!condition)
        xrpl::Throw<std::logic_error>(message);
}
 
}  // namespace json