| // 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 CPPTL_JSON_READER_H_INCLUDED |
| #define CPPTL_JSON_READER_H_INCLUDED |
| |
| #if !defined(JSON_IS_AMALGAMATION) |
| #include "features.h" |
| #include "value.h" |
| #endif // if !defined(JSON_IS_AMALGAMATION) |
| #include <deque> |
| #include <iosfwd> |
| #include <stack> |
| #include <string> |
| #include <istream> |
| |
| // 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) |
| |
| #if !defined(__SUNPRO_CC) |
| #pragma pack(push, 8) |
| #endif |
| |
| namespace Json { |
| |
| /** \brief Unserialize a <a HREF="http://www.json.org">JSON</a> document into a |
| *Value. |
| * |
| * deprecated Use CharReader and CharReaderBuilder. |
| */ |
| class JSONCPP_DEPRECATED("Use CharReader and CharReaderBuilder instead") JSON_API Reader { |
| public: |
| typedef char Char; |
| typedef const Char* Location; |
| |
| /** \brief An error tagged with where in the JSON text it was encountered. |
| * |
| * The offsets give the [start, limit) range of bytes within the text. Note |
| * that this is bytes, not codepoints. |
| * |
| */ |
| struct StructuredError { |
| ptrdiff_t offset_start; |
| ptrdiff_t offset_limit; |
| JSONCPP_STRING message; |
| }; |
| |
| /** \brief Constructs a Reader allowing all features |
| * for parsing. |
| */ |
| Reader(); |
| |
| /** \brief Constructs a Reader allowing the specified feature set |
| * for parsing. |
| */ |
| Reader(const Features& features); |
| |
| /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> |
| * document. |
| * \param document UTF-8 encoded string containing the document to read. |
| * \param root [out] Contains the root value of the document if it was |
| * successfully parsed. |
| * \param collectComments \c true to collect comment and allow writing them |
| * back during |
| * serialization, \c false to discard comments. |
| * This parameter is ignored if |
| * Features::allowComments_ |
| * is \c false. |
| * \return \c true if the document was successfully parsed, \c false if an |
| * error occurred. |
| */ |
| bool |
| parse(const std::string& document, Value& root, bool collectComments = true); |
| |
| /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> |
| document. |
| * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the |
| document to read. |
| * \param endDoc Pointer on the end of the UTF-8 encoded string of the |
| document to read. |
| * Must be >= beginDoc. |
| * \param root [out] Contains the root value of the document if it was |
| * successfully parsed. |
| * \param collectComments \c true to collect comment and allow writing them |
| back during |
| * serialization, \c false to discard comments. |
| * This parameter is ignored if |
| Features::allowComments_ |
| * is \c false. |
| * \return \c true if the document was successfully parsed, \c false if an |
| error occurred. |
| */ |
| bool parse(const char* beginDoc, |
| const char* endDoc, |
| Value& root, |
| bool collectComments = true); |
| |
| /// \brief Parse from input stream. |
| /// \see Json::operator>>(std::istream&, Json::Value&). |
| bool parse(JSONCPP_ISTREAM& is, Value& root, bool collectComments = true); |
| |
| /** \brief Returns a user friendly string that list errors in the parsed |
| * document. |
| * \return Formatted error message with the list of errors with their location |
| * in |
| * the parsed document. An empty string is returned if no error |
| * occurred |
| * during parsing. |
| * deprecated Use getFormattedErrorMessages() instead (typo fix). |
| */ |
| JSONCPP_DEPRECATED("Use getFormattedErrorMessages() instead.") |
| JSONCPP_STRING getFormatedErrorMessages() const; |
| |
| /** \brief Returns a user friendly string that list errors in the parsed |
| * document. |
| * \return Formatted error message with the list of errors with their location |
| * in |
| * the parsed document. An empty string is returned if no error |
| * occurred |
| * during parsing. |
| */ |
| JSONCPP_STRING getFormattedErrorMessages() const; |
| |
| /** \brief Returns a vector of structured erros encounted while parsing. |
| * \return A (possibly empty) vector of StructuredError objects. Currently |
| * only one error can be returned, but the caller should tolerate |
| * multiple |
| * errors. This can occur if the parser recovers from a non-fatal |
| * parse error and then encounters additional errors. |
| */ |
| std::vector<StructuredError> getStructuredErrors() const; |
| |
| /** \brief Add a semantic error message. |
| * \param value JSON Value location associated with the error |
| * \param message The error message. |
| * \return \c true if the error was successfully added, \c false if the |
| * Value offset exceeds the document size. |
| */ |
| bool pushError(const Value& value, const JSONCPP_STRING& message); |
| |
| /** \brief Add a semantic error message with extra context. |
| * \param value JSON Value location associated with the error |
| * \param message The error message. |
| * \param extra Additional JSON Value location to contextualize the error |
| * \return \c true if the error was successfully added, \c false if either |
| * Value offset exceeds the document size. |
| */ |
| bool pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra); |
| |
| /** \brief Return whether there are any errors. |
| * \return \c true if there are no errors to report \c false if |
| * errors have occurred. |
| */ |
| 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_; |
| JSONCPP_STRING message_; |
| Location extra_; |
| }; |
| |
| typedef std::deque<ErrorInfo> Errors; |
| |
| bool readToken(Token& token); |
| void skipSpaces(); |
| bool match(Location 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, JSONCPP_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 JSONCPP_STRING& message, Token& token, Location extra = 0); |
| bool recoverFromError(TokenType skipUntilToken); |
| bool addErrorAndRecover(const JSONCPP_STRING& message, |
| Token& token, |
| TokenType skipUntilToken); |
| void skipUntilSpace(); |
| Value& currentValue(); |
| Char getNextChar(); |
| void |
| getLocationLineAndColumn(Location location, int& line, int& column) const; |
| JSONCPP_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 JSONCPP_STRING normalizeEOL(Location begin, Location end); |
| |
| typedef std::stack<Value*> Nodes; |
| Nodes nodes_; |
| Errors errors_; |
| JSONCPP_STRING document_; |
| Location begin_; |
| Location end_; |
| Location current_; |
| Location lastValueEnd_; |
| Value* lastValue_; |
| JSONCPP_STRING commentsBefore_; |
| Features features_; |
| bool collectComments_; |
| }; // Reader |
| |
| /** Interface for reading JSON from a char array. |
| */ |
| class JSON_API CharReader { |
| public: |
| virtual ~CharReader() {} |
| /** \brief Read a Value from a <a HREF="http://www.json.org">JSON</a> |
| document. |
| * The document must be a UTF-8 encoded string containing the document to read. |
| * |
| * \param beginDoc Pointer on the beginning of the UTF-8 encoded string of the |
| document to read. |
| * \param endDoc Pointer on the end of the UTF-8 encoded string of the |
| document to read. |
| * Must be >= beginDoc. |
| * \param root [out] Contains the root value of the document if it was |
| * successfully parsed. |
| * \param errs [out] Formatted error messages (if not NULL) |
| * a user friendly string that lists errors in the parsed |
| * document. |
| * \return \c true if the document was successfully parsed, \c false if an |
| error occurred. |
| */ |
| virtual bool parse( |
| char const* beginDoc, char const* endDoc, |
| Value* root, JSONCPP_STRING* errs) = 0; |
| |
| class JSON_API Factory { |
| public: |
| virtual ~Factory() {} |
| /** \brief Allocate a CharReader via operator new(). |
| * \throw std::exception if something goes wrong (e.g. invalid settings) |
| */ |
| virtual CharReader* newCharReader() const = 0; |
| }; // Factory |
| }; // CharReader |
| |
| /** \brief Build a CharReader implementation. |
| |
| Usage: |
| \code |
| using namespace Json; |
| CharReaderBuilder builder; |
| builder["collectComments"] = false; |
| Value value; |
| JSONCPP_STRING errs; |
| bool ok = parseFromStream(builder, std::cin, &value, &errs); |
| \endcode |
| */ |
| class JSON_API CharReaderBuilder : public CharReader::Factory { |
| public: |
| // Note: We use a Json::Value so that we can add data-members to this class |
| // without a major version bump. |
| /** Configuration of this builder. |
| These are case-sensitive. |
| Available settings (case-sensitive): |
| - `"collectComments": false or true` |
| - true to collect comment and allow writing them |
| back during serialization, false to discard comments. |
| This parameter is ignored if allowComments is false. |
| - `"allowComments": false or true` |
| - true if comments are allowed. |
| - `"strictRoot": false or true` |
| - true if root must be either an array or an object value |
| - `"allowDroppedNullPlaceholders": false or true` |
| - true if dropped null placeholders are allowed. (See StreamWriterBuilder.) |
| - `"allowNumericKeys": false or true` |
| - true if numeric object keys are allowed. |
| - `"allowSingleQuotes": false or true` |
| - true if '' are allowed for strings (both keys and values) |
| - `"stackLimit": integer` |
| - Exceeding stackLimit (recursive depth of `readValue()`) will |
| cause an exception. |
| - This is a security issue (seg-faults caused by deeply nested JSON), |
| so the default is low. |
| - `"failIfExtra": false or true` |
| - If true, `parse()` returns false when extra non-whitespace trails |
| the JSON value in the input string. |
| - `"rejectDupKeys": false or true` |
| - If true, `parse()` returns false when a key is duplicated within an object. |
| - `"allowSpecialFloats": false or true` |
| - If true, special float values (NaNs and infinities) are allowed |
| and their values are lossfree restorable. |
| |
| You can examine 'settings_` yourself |
| to see the defaults. You can also write and read them just like any |
| JSON Value. |
| \sa setDefaults() |
| */ |
| Json::Value settings_; |
| |
| CharReaderBuilder(); |
| ~CharReaderBuilder() JSONCPP_OVERRIDE; |
| |
| CharReader* newCharReader() const JSONCPP_OVERRIDE; |
| |
| /** \return true if 'settings' are legal and consistent; |
| * otherwise, indicate bad settings via 'invalid'. |
| */ |
| bool validate(Json::Value* invalid) const; |
| |
| /** A simple way to update a specific setting. |
| */ |
| Value& operator[](JSONCPP_STRING key); |
| |
| /** Called by ctor, but you can use this to reset settings_. |
| * \pre 'settings' != NULL (but Json::null is fine) |
| * \remark Defaults: |
| * snippet src/lib_json/json_reader.cpp CharReaderBuilderDefaults |
| */ |
| static void setDefaults(Json::Value* settings); |
| /** Same as old Features::strictMode(). |
| * \pre 'settings' != NULL (but Json::null is fine) |
| * \remark Defaults: |
| * snippet src/lib_json/json_reader.cpp CharReaderBuilderStrictMode |
| */ |
| static void strictMode(Json::Value* settings); |
| }; |
| |
| /** Consume entire stream and use its begin/end. |
| * Someday we might have a real StreamReader, but for now this |
| * is convenient. |
| */ |
| bool JSON_API parseFromStream( |
| CharReader::Factory const&, |
| JSONCPP_ISTREAM&, |
| Value* root, std::string* errs); |
| |
| /** \brief Read from 'sin' into 'root'. |
| |
| Always keep comments from the input JSON. |
| |
| This can be used to read a file into a particular sub-object. |
| For example: |
| \code |
| Json::Value root; |
| cin >> root["dir"]["file"]; |
| cout << root; |
| \endcode |
| Result: |
| \verbatim |
| { |
| "dir": { |
| "file": { |
| // The input stream JSON would be nested here. |
| } |
| } |
| } |
| \endverbatim |
| \throw std::exception on parse error. |
| \see Json::operator<<() |
| */ |
| JSON_API JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM&, Value&); |
| |
| } // namespace Json |
| |
| #if !defined(__SUNPRO_CC) |
| #pragma pack(pop) |
| #endif |
| |
| #if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) |
| #pragma warning(pop) |
| #endif // if defined(JSONCPP_DISABLE_DLL_INTERFACE_WARNING) |
| |
| #endif // CPPTL_JSON_READER_H_INCLUDED |