include/json/reader.h

#pragma once

#include "features.h"
#include "value.h"
#include <deque>
#include <iostream>
#include <stack>
#include <string>

namespace Json
{
  /** \brief Unserialize a <a href="http://www.json.org">JSON</a> document into a Value.
   *
   */
  class JSON_API Reader
  {
  public:
    typedef char Char;
    typedef const Char *Location;

    /** \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 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 char *beginDoc, const char *endDoc, Value &root, bool collectComments = true);

    /*
     * / \brief Parse from input stream.
     * / \see Json::operator>>(std::istream&, Json::Value&).
     */
    bool parse (std::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.
     */
    std::string getFormatedErrorMessages () const;

  private:
    enum TokenType
    {
      tokenEndOfStream = 0,
      tokenObjectBegin,
      tokenObjectEnd,
      tokenArrayBegin,
      tokenArrayEnd,
      tokenString,
      tokenNumber,
      tokenTrue,
      tokenFalse,
      tokenNull,
      tokenArraySeparator,
      tokenMemberSeparator,
      tokenComment,
      tokenError
    };

    struct Token
    {
      Location start_;
      Location end_;
      TokenType type_;
    };

    struct ErrorInfo
    {
      Token token_;
      std::string message_;
      Location extra_;
    };

    typedef std::deque<ErrorInfo> Errors;

    bool expectToken (TokenType type, Token &token, const char *message);
    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 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 (const std::string &message, Token &token, Location extra = 0);
    bool recoverFromError (TokenType skipUntilToken);
    bool addErrorAndRecover (const std::string &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 addComment (Location begin, Location end, CommentPlacement placement);
    void skipCommentTokens (Token &token);

    typedef std::stack<Value *> Nodes;
    Nodes nodes_;
    Errors errors_;
    std::string document_;
    Location begin_;
    Location end_;
    Location current_;
    Location lastValueEnd_;
    Value *lastValue_;
    std::string commentsBefore_;
    Features features_;
    bool collectComments_;
  };

  /** \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<<()
   */
  std::istream &operator >> (std::istream &is, Value &value);
} /* namespace Json */
Revision:	1.1
Committed:	Sun Oct 17 08:14:53 2010 UTC (15 years, 11 months ago) by sf-pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import
#	User	Rev	Content
1	sf-pippijn	1.1	#pragma once
2
3			#include "features.h"
4			#include "value.h"
5			#include <deque>
6			#include <iostream>
7			#include <stack>
8			#include <string>
9
10			namespace Json
11			{
12			/** \brief Unserialize a <a href="http://www.json.org">JSON</a> document into a Value.
13			*
14			*/
15			class JSON_API Reader
16			{
17			public:
18			typedef char Char;
19			typedef const Char *Location;
20
21			/** \brief Constructs a Reader allowing all features
22			* for parsing.
23			*/
24			Reader ();
25
26			/** \brief Constructs a Reader allowing the specified feature set
27			* for parsing.
28			*/
29			Reader (const Features &features);
30
31			/** \brief Read a Value from a <a href="http://www.json.org">JSON</a> document.
32			* \param document UTF-8 encoded string containing the document to read.
33			* \param root [out] Contains the root value of the document if it was
34			* successfully parsed.
35			* \param collectComments \c true to collect comment and allow writing them back during
36			* serialization, \c false to discard comments.
37			* This parameter is ignored if Features::allowComments_
38			* is \c false.
39			* \return \c true if the document was successfully parsed, \c false if an error occurred.
40			*/
41			bool parse (const std::string &document, Value &root, bool collectComments = true);
42
43			/** \brief Read a Value from a <a href="http://www.json.org">JSON</a> document.
44			* \param document UTF-8 encoded string containing the document to read.
45			* \param root [out] Contains the root value of the document if it was
46			* successfully parsed.
47			* \param collectComments \c true to collect comment and allow writing them back during
48			* serialization, \c false to discard comments.
49			* This parameter is ignored if Features::allowComments_
50			* is \c false.
51			* \return \c true if the document was successfully parsed, \c false if an error occurred.
52			*/
53			bool parse (const char beginDoc, const char endDoc, Value &root, bool collectComments = true);
54
55			/*
56			* / \brief Parse from input stream.
57			* / \see Json::operator>>(std::istream&, Json::Value&).
58			*/
59			bool parse (std::istream &is, Value &root, bool collectComments = true);
60
61			/** \brief Returns a user friendly string that list errors in the parsed document.
62			* \return Formatted error message with the list of errors with their location in
63			* the parsed document. An empty string is returned if no error occurred
64			* during parsing.
65			*/
66			std::string getFormatedErrorMessages () const;
67
68			private:
69			enum TokenType
70			{
71			tokenEndOfStream = 0,
72			tokenObjectBegin,
73			tokenObjectEnd,
74			tokenArrayBegin,
75			tokenArrayEnd,
76			tokenString,
77			tokenNumber,
78			tokenTrue,
79			tokenFalse,
80			tokenNull,
81			tokenArraySeparator,
82			tokenMemberSeparator,
83			tokenComment,
84			tokenError
85			};
86
87			struct Token
88			{
89			Location start_;
90			Location end_;
91			TokenType type_;
92			};
93
94			struct ErrorInfo
95			{
96			Token token_;
97			std::string message_;
98			Location extra_;
99			};
100
101			typedef std::deque<ErrorInfo> Errors;
102
103			bool expectToken (TokenType type, Token &token, const char *message);
104			bool readToken (Token &token);
105			void skipSpaces ();
106			bool match (Location pattern, int patternLength);
107			bool readComment ();
108			bool readCStyleComment ();
109			bool readCppStyleComment ();
110			bool readString ();
111			void readNumber ();
112			bool readValue ();
113			bool readObject (Token &token);
114			bool readArray (Token &token);
115			bool decodeNumber (Token &token);
116			bool decodeString (Token &token);
117			bool decodeString (Token &token, std::string &decoded);
118			bool decodeDouble (Token &token);
119			bool decodeUnicodeCodePoint (Token &token, Location &current, Location end, unsigned int &unicode);
120			bool decodeUnicodeEscapeSequence (Token &token, Location &current, Location end, unsigned int &unicode);
121			bool addError (const std::string &message, Token &token, Location extra = 0);
122			bool recoverFromError (TokenType skipUntilToken);
123			bool addErrorAndRecover (const std::string &message, Token &token, TokenType skipUntilToken);
124			void skipUntilSpace ();
125			Value &currentValue ();
126			Char getNextChar ();
127			void getLocationLineAndColumn (Location location, int &line, int &column) const;
128			std::string getLocationLineAndColumn (Location location) const;
129			void addComment (Location begin, Location end, CommentPlacement placement);
130			void skipCommentTokens (Token &token);
131
132			typedef std::stack<Value *> Nodes;
133			Nodes nodes_;
134			Errors errors_;
135			std::string document_;
136			Location begin_;
137			Location end_;
138			Location current_;
139			Location lastValueEnd_;
140			Value *lastValue_;
141			std::string commentsBefore_;
142			Features features_;
143			bool collectComments_;
144			};
145
146			/** \brief Read from 'sin' into 'root'.
147			*
148			* Always keep comments from the input JSON.
149			*
150			* This can be used to read a file into a particular sub-object.
151			* For example:
152			* \code
153			* Json::Value root;
154			* cin >> root["dir"]["file"];
155			* cout << root;
156			* \endcode
157			* Result:
158			* \verbatim
159			* {
160			* "dir": {
161			* "file": {
162			* // The input stream JSON would be nested here.
163			* }
164			* }
165			* }
166			* \endverbatim
167			* \throw std::exception on parse error.
168			* \see Json::operator<<()
169			*/
170			std::istream &operator >> (std::istream &is, Value &value);
171			} /* namespace Json */