#ifndef JSON_JSONParser_INCLUDED

#define JSON_JSONParser_INCLUDED

#include "Poco/JSON/JSON.h"

#include "Poco/JSON/Object.h"

#include "Poco/JSON/Array.h"

#include "Poco/JSON/ParseHandler.h"

#include "Poco/JSON/JSONException.h"

#include "Poco/UTF8Encoding.h"

#include "Poco/Dynamic/Var.h"

#include <string>

namespace Poco {

namespace JSON {

class JSON_API Parser

/// A RFC 4627 compatible class for parsing JSON strings or streams.

///

/// See http://www.ietf.org/rfc/rfc4627.txt for specification.

///

/// Usage example:

///

/// std::string json = "{ \"name\" : \"Franky\", \"children\" : [ \"Jonas\", \"Ellen\" ] }";

/// Parser parser;

/// Var result = parser.parse(json);

/// // ... use result

/// parser.reset();

/// std::ostringstream ostr;

/// PrintHandler::Ptr pHandler = new PrintHandler(ostr);

/// parser.setHandler(pHandler);

/// parser.parse(json); // ostr.str() == json

///

{

typedef std::char_traits<char> CharTraits;

typedef CharTraits::int_type CharIntType;

enum Classes

};

enum States

};

enum Modes

};

enum Actions

};

enum JSONType

};

static const std::size_t JSON_PARSE_BUFFER_SIZE = 4096;

static const std::size_t JSON_PARSER_STACK_SIZE = 128;

static const int JSON_UNLIMITED_DEPTH = -1;

Parser(const Handler::Ptr& pHandler = new ParseHandler, std::size_t bufSize = JSON_PARSE_BUFFER_SIZE);

/// Creates JSON Parser.

virtual ~Parser();

/// Destroys JSON Parser.

void reset();

/// Resets the parser.

void setAllowComments(bool comments);

/// Allow comments. By default, comments are not allowed.

bool getAllowComments() const;

/// Returns true if comments are allowed, false otherwise.

/// By default, comments are not allowed.

void setAllowNullByte(bool nullByte);

/// Allow null byte in strings. By default, null byte is allowed.

bool getAllowNullByte() const;

/// Returns true if null byte is allowed, false otherwise.

/// By default, null bytes are allowed.

void setDepth(std::size_t depth);

/// Sets the allowed JSON depth.

std::size_t getDepth() const;

/// Returns the allowed JSON depth.

Dynamic::Var parse(const std::string& json);

/// Parses a string.

Dynamic::Var parse(std::istream& in);

/// Parses a JSON from the input stream.

void setHandler(const Handler::Ptr& pHandler);

/// Set the handler.

const Handler::Ptr& getHandler();

/// Returns the handler.

Dynamic::Var asVar() const;

/// Returns the result of parsing;

Dynamic::Var result() const;

/// Returns the result of parsing as Dynamic::Var;

Parser(const Parser&);

Parser& operator = (const Parser&);

typedef Poco::Buffer<char> BufType;

bool push(int mode);

/// Push a mode onto the _pStack. Return false if there is overflow.

bool pop(int mode);

/// Pops the stack, assuring that the current mode matches the expectation.

/// Returns false if there is underflow or if the modes mismatch.

void growBuffer();

void clearBuffer();

void parseBufferPushBackChar(char c);

void parseBufferPopBackChar();

void addCharToParseBuffer(CharIntType nextChar, int nextClass);

void addEscapedCharToParseBuffer(CharIntType nextChar);

CharIntType decodeUnicodeChar();

void assertNotStringNullBool();

void assertNonContainer();

void parseBuffer();

template <typename IT>

class Source

};

template <typename S>

bool parseChar(CharIntType nextChar, S& source)

}

bool done();

static CharIntType utf8CheckFirst(char byte);

static const int _asciiClass[128];

/// This array maps the 128 ASCII characters into character classes.

/// The remaining Unicode characters should be mapped to C_ETC.

/// Non-whitespace control characters are errors.

static const int _stateTransitionTable[NR_STATES][NR_CLASSES];

static const int xx = -1;

Handler::Ptr _pHandler;

signed char _state;

signed char _beforeCommentState;

JSONType _type;

signed char _escaped;

signed char _comment;

unsigned short _utf16HighSurrogate;

int _depth;

int _top;

BufType _stack;

BufType _parseBuffer;

char _decimalPoint;

bool _allowNullByte;

bool _allowComments;

};

inline void Parser::setAllowComments(bool comments)

{

_allowComments = comments;

}

inline bool Parser::getAllowComments() const

{

return _allowComments;

}

inline void Parser::setAllowNullByte(bool nullByte)

{

_allowNullByte = nullByte;

}

inline bool Parser::getAllowNullByte() const

{

return _allowNullByte;

}

inline void Parser::setDepth(std::size_t depth)

{

_depth = static_cast<int>(depth);

}

inline std::size_t Parser::getDepth() const

{

return static_cast<int>(_depth);

}

inline void Parser::setHandler(const Handler::Ptr& pHandler)

{

_pHandler = pHandler;

}

inline const Handler::Ptr& Parser::getHandler()

{

return _pHandler;

}

inline Dynamic::Var Parser::result() const

{

return _pHandler->asVar();

}

inline Dynamic::Var Parser::asVar() const

}

inline bool Parser::done()

{

return _state == OK && pop(MODE_DONE);

}

inline void Parser::assertNotStringNullBool()

}

inline void Parser::assertNonContainer()

}

inline void Parser::growBuffer()

{

_parseBuffer.setCapacity(_parseBuffer.size() * 2, true);

}

}} // namespace Poco::JSON

#endif // JSON_JSONParser_INCLUDED