reader.h

// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
#ifndef NIM_CPP_WRAPPER_UTIL_JSON_READER_H_INCLUDED
#define NIM_CPP_WRAPPER_UTIL_JSON_READER_H_INCLUDED
 
#if !defined(JSON_IS_AMALGAMATION)
#include "json_features.h"
#include "value.h"
#endif  // if !defined(JSON_IS_AMALGAMATION)
#include <deque>
#include <iosfwd>
#include <istream>
#include <stack>
#include <string>
 
// Disable warning C4251: <data member>: <type> needs to have dll-interface to
// be used by...
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif  // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
#pragma pack(push, 8)
 
namespace nim_cpp_wrapper_util {
namespace Json {
 
class JSON_API Reader {
public:
    using Char = char;
    using Location = const Char*;
 
    struct StructuredError {
        ptrdiff_t offset_start;
        ptrdiff_t offset_limit;
        String message;
    };
 
    Reader();
 
    Reader(const Features& features);
 
    bool parse(const std::string& document, Value& root, bool collectComments = true);
 
    bool parse(const char* beginDoc, const char* endDoc, Value& root, bool collectComments = true);
 
    bool parse(IStream& is, Value& root, bool collectComments = true);
 
    String getFormatedErrorMessages() const;
 
    String getFormattedErrorMessages() const;
 
    std::vector<StructuredError> getStructuredErrors() const;
 
    bool pushError(const Value& value, const String& message);
 
    bool pushError(const Value& value, const String& message, const Value& extra);
 
    bool good() const;
 
private:
    enum TokenType {
        tokenEndOfStream = 0,
        tokenObjectBegin,
        tokenObjectEnd,
        tokenArrayBegin,
        tokenArrayEnd,
        tokenString,
        tokenNumber,
        tokenTrue,
        tokenFalse,
        tokenNull,
        tokenArraySeparator,
        tokenMemberSeparator,
        tokenComment,
        tokenError
    };
 
    class Token {
    public:
        TokenType type_;
        Location start_;
        Location end_;
    };
 
    class ErrorInfo {
    public:
        Token token_;
        String message_;
        Location extra_;
    };
 
    using Errors = std::deque<ErrorInfo>;
 
    bool readToken(Token& token);
    void skipSpaces();
    bool match(const Char* pattern, int patternLength);
    bool readComment();
    bool readCStyleComment();
    bool readCppStyleComment();
    bool readString();
    void readNumber();
    bool readValue();
    bool readObject(Token& token);
    bool readArray(Token& token);
    bool decodeNumber(Token& token);
    bool decodeNumber(Token& token, Value& decoded);
    bool decodeString(Token& token);
    bool decodeString(Token& token, String& decoded);
    bool decodeDouble(Token& token);
    bool decodeDouble(Token& token, Value& decoded);
    bool decodeUnicodeCodePoint(Token& token, Location& current, Location end, unsigned int& unicode);
    bool decodeUnicodeEscapeSequence(Token& token, Location& current, Location end, unsigned int& unicode);
    bool addError(const String& message, Token& token, Location extra = nullptr);
    bool recoverFromError(TokenType skipUntilToken);
    bool addErrorAndRecover(const String& message, Token& token, TokenType skipUntilToken);
    void skipUntilSpace();
    Value& currentValue();
    Char getNextChar();
    void getLocationLineAndColumn(Location location, int& line, int& column) const;
    String getLocationLineAndColumn(Location location) const;
    void addComment(Location begin, Location end, CommentPlacement placement);
    void skipCommentTokens(Token& token);
 
    static bool containsNewLine(Location begin, Location end);
    static String normalizeEOL(Location begin, Location end);
 
    using Nodes = std::stack<Value*>;
    Nodes nodes_;
    Errors errors_;
    String document_;
    Location begin_{};
    Location end_{};
    Location current_{};
    Location lastValueEnd_{};
    Value* lastValue_{};
    String commentsBefore_;
    Features features_;
    bool collectComments_{};
};  // Reader
 
class JSON_API CharReader {
public:
    virtual ~CharReader() = default;
    virtual bool parse(char const* beginDoc, char const* endDoc, Value* root, String* errs) = 0;
 
    class JSON_API Factory {
    public:
        virtual ~Factory() = default;
        virtual CharReader* newCharReader() const = 0;
    };  // Factory
};      // CharReader
 
class JSON_API CharReaderBuilder : public CharReader::Factory {
public:
    // Note: We use a nim_cpp_wrapper_util::Json::Value so that we can add data-members to this class
    // without a major version bump.
    nim_cpp_wrapper_util::Json::Value settings_;
 
    CharReaderBuilder();
    ~CharReaderBuilder() override;
 
    CharReader* newCharReader() const override;
 
    bool validate(nim_cpp_wrapper_util::Json::Value* invalid) const;
 
    Value& operator[](const String& key);
 
    static void setDefaults(nim_cpp_wrapper_util::Json::Value* settings);
    static void strictMode(nim_cpp_wrapper_util::Json::Value* settings);
};
 
bool JSON_API parseFromStream(CharReader::Factory const&, IStream&, Value* root, String* errs);
 
JSON_API IStream& operator>>(IStream&, Value&);
 
}  // namespace Json
}  // namespace nim_cpp_wrapper_util
 
#pragma pack(pop)
 
#if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
#pragma warning(pop)
#endif  // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING)
 
#endif  // JSON_READER_H_INCLUDED