json_reader.h

#pragma once
 
#include <xrpl/json/json_forwards.h>
#include <xrpl/json/json_value.h>
 
#include <boost/asio/buffer.hpp>
 
#include <deque>
#include <istream>
#include <stack>
#include <string>
 
namespace json {

class Reader
{
public:
    using Char = char;
    using Location = Char const*;

    Reader() = default;

    bool
    parse(std::string const& document, Value& root);

    bool
    parse(char const* beginDoc, char const* endDoc, Value& root);

    bool
    parse(std::istream& is, Value& root);

    template <class BufferSequence>
    bool
    parse(Value& root, BufferSequence const& bs);

    [[nodiscard]] std::string
    getFormattedErrorMessages() const;
 
    static constexpr unsigned kNestLimit{25};
 
private:
    enum class TokenType {
        EndOfStream = 0,
        ObjectBegin,
        ObjectEnd,
        ArrayBegin,
        ArrayEnd,
        String,
        Integer,
        Double,
        True,
        False,
        Null,
        ArraySeparator,
        MemberSeparator,
        Comment,
        Error
    };
 
    class Token
    {
    public:
        explicit Token() = default;
 
        TokenType type;
        Location start;
        Location end;
    };
 
    class ErrorInfo
    {
    public:
        explicit ErrorInfo() = default;
 
        Token token{};
        std::string message;
        Location extra{};
    };
 
    using Errors = std::deque<ErrorInfo>;
 
    bool
    expectToken(TokenType type, Token& token, char const* message);
    bool
    readToken(Token& token);
    void
    skipSpaces();
    bool
    match(Location pattern, int patternLength);
    bool
    readComment();
    bool
    readCStyleComment();
    bool
    readCppStyleComment();
    bool
    readString();
    Reader::TokenType
    readNumber();
    bool
    readValue(unsigned depth);
    bool
    readObject(Token& token, unsigned depth);
    bool
    readArray(Token& token, unsigned depth);
    bool
    decodeNumber(Token& token);
    bool
    decodeString(Token& token);
    bool
    decodeString(Token& token, std::string& decoded);
    bool
    decodeDouble(Token& token);
    bool
    decodeUnicodeCodePoint(Token& token, Location& current, Location end, unsigned int& unicode);
    bool
    decodeUnicodeEscapeSequence(
        Token& token,
        Location& current,
        Location end,
        unsigned int& unicode);
    bool
    addError(std::string const& message, Token& token, Location extra = nullptr);
    bool
    recoverFromError(TokenType skipUntilToken);
    bool
    addErrorAndRecover(std::string const& message, Token& token, TokenType skipUntilToken);
    void
    skipUntilSpace();
    Value&
    currentValue();
    Char
    getNextChar();
    void
    getLocationLineAndColumn(Location location, int& line, int& column) const;
    std::string
    getLocationLineAndColumn(Location location) const;
    void
    skipCommentTokens(Token& token);
 
    using Nodes = std::stack<Value*>;
    Nodes nodes_;
    Errors errors_;
    std::string document_;
    Location begin_{};
    Location end_{};
    Location current_{};
    Location lastValueEnd_{};
    Value* lastValue_{};
};
 
template <class BufferSequence>
bool
Reader::parse(Value& root, BufferSequence const& bs)
{
    using namespace boost::asio;
    std::string s;
    s.reserve(buffer_size(bs));
    for (auto const& b : bs)
        s.append(static_cast<char const*>(b.data()), buffer_size(b));
    return parse(s, root);
}

std::istream&
operator>>(std::istream&, Value&);
 
}  // namespace json