Utilities/cmjsoncpp/include/json/reader.h - third_party/github.com/Kitware/CMake - Git at Google

 // 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
	// 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