rapidjson::GenericReader< Encoding, Allocator > Class Template Reference

SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator. More...

#include <reader.h>

Public Types
typedef Encoding::Ch	Ch

Public Member Functions
	GenericReader (Allocator *allocator=0, size_t stackCapacity=kDefaultStackCapacity)
	Constructor. More...
template<unsigned parseFlags, typename Stream , typename Handler >
bool	Parse (Stream &stream, Handler &handler)
	Parse JSON text. More...
bool	HasParseError () const
const char *	GetParseError () const
size_t	GetErrorOffset () const

Private Member Functions
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseObject (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseArray (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseNaNNull_ (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseInfinity (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseTrue (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseFalse (Stream &stream, Handler &handler)
template<typename Stream >
unsigned	ParseHex4 (Stream &stream)
template<class Ch >
std::enable_if< to_int(std::numeric_limits< Ch >::max())< to_int(256), bool >::type characterOk(Ch) { return true;} template< class Ch > typename std::enable_if< to_int(std::numeric_limits< Ch >::max()) >=to_int(256), bool >::type	characterOk (Ch c)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseString (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseNumber (Stream &stream, Handler &handler)
template<unsigned parseFlags, typename Stream , typename Handler >
void	ParseValue (Stream &stream, Handler &handler)

Static Private Member Functions
template<class T >
static constexpr int	to_int (T t)

Private Attributes
internal::Stack< Allocator >	stack_
	A stack for storing decoded string temporarily during non-destructive parsing. More...
jmp_buf	jmpbuf_
	setjmp buffer for fast exit from nested parsing function calls. More...
const char *	parseError_
size_t	errorOffset_

Static Private Attributes
static const size_t	kDefaultStackCapacity = 256
	Default stack capacity in bytes for storing a single decoded string. More...

Detailed Description

template<typename Encoding, typename Allocator = MemoryPoolAllocator<>>
class rapidjson::GenericReader< Encoding, Allocator >

SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator.

GenericReader parses JSON text from a stream, and send events synchronously to an object implementing Handler concept.

It needs to allocate a stack for storing a single decoded string during non-destructive parsing.

For in-situ parsing, the decoded string is directly written to the source text string, no temporary buffer is required.

A GenericReader object can be reused for parsing multiple JSON text.

Template Parameters

Encoding	Encoding of both the stream and the parse output.
Allocator	Allocator type for stack.

Member Typedef Documentation

Ch

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

typedef Encoding::Ch rapidjson::GenericReader< Encoding, Allocator >::Ch

Constructor & Destructor Documentation

GenericReader()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

rapidjson::GenericReader< Encoding, Allocator >::GenericReader ( Allocator *  allocator = 0, size_t  stackCapacity = kDefaultStackCapacity  )

inline

Constructor.

Parameters

allocator	Optional allocator for allocating stack memory. (Only use for non-destructive parsing)
stackCapacity	stack capacity in bytes for storing a single decoded string. (Only use for non-destructive parsing)

: stack_(allocator, stackCapacity), parseError_(0), errorOffset_(0) {}

Member Function Documentation

characterOk()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<class Ch >

std::enable_if< to_int(std::numeric_limits<Ch>::max()) < to_int(256), bool>::type characterOk( Ch ) { return true; } template<class Ch> typename std::enable_if< to_int(std::numeric_limits<Ch>::max()) >= to_int(256), bool>::type rapidjson::GenericReader< Encoding, Allocator >::characterOk ( Ch  c )

inlineprivate

  { return c < 256; }

Referenced by rapidjson::GenericReader< Encoding, Allocator >::ParseString().

GetErrorOffset()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

size_t rapidjson::GenericReader< Encoding, Allocator >::GetErrorOffset ( ) const

inline

{ return errorOffset_; }

References rapidjson::GenericReader< Encoding, Allocator >::errorOffset_.

Referenced by rapidjson::GenericDocument< Encoding, Allocator >::ParseStream().

GetParseError()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

const char* rapidjson::GenericReader< Encoding, Allocator >::GetParseError ( ) const

inline

{ return parseError_; }

References rapidjson::GenericReader< Encoding, Allocator >::parseError_.

Referenced by rapidjson::GenericDocument< Encoding, Allocator >::ParseStream().

HasParseError()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

bool rapidjson::GenericReader< Encoding, Allocator >::HasParseError ( ) const

inline

{ return parseError_ != 0; }

References rapidjson::GenericReader< Encoding, Allocator >::parseError_.

Parse()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

bool rapidjson::GenericReader< Encoding, Allocator >::Parse ( Stream &  stream, Handler &  handler  )

inline

Parse JSON text.

Template Parameters

parseFlags	Combination of ParseFlag.
Stream	Type of input stream.
Handler	Type of handler which must implement Handler concept.

Parameters

stream	Input stream to be parsed.
handler	The handler to receive events.

Returns

Whether the parsing is successful.

                                                 {
        parseError_ = 0;
        errorOffset_ = 0;
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4611) // interaction between '_setjmp' and C++ object destruction is non-portable
#endif
        if (setjmp(jmpbuf_)) {
#ifdef _MSC_VER
#pragma warning(pop)
#endif
            stack_.Clear();
            return false;
        }
 
        SkipWhitespace(stream);
 
        if (stream.Peek() == '\0')
            RAPIDJSON_PARSE_ERROR("Text only contains white space(s)", stream.Tell());
        else {
            switch (stream.Peek()) {
                case '{': ParseObject<parseFlags>(stream, handler); break;
                case '[': ParseArray<parseFlags>(stream, handler); break;
                default: RAPIDJSON_PARSE_ERROR("Expect either an object or array at root", stream.Tell());
            }
            SkipWhitespace(stream);
 
            if (stream.Peek() != '\0' && stream.Peek() != static_cast<Ch>(std::char_traits<Ch>::eof()))
                RAPIDJSON_PARSE_ERROR("Nothing should follow the root object or array.", stream.Tell());
        }
 
        return true;
    }

References rapidjson::GenericReader< Encoding, Allocator >::errorOffset_, rapidjson::GenericReader< Encoding, Allocator >::jmpbuf_, rapidjson::GenericReader< Encoding, Allocator >::parseError_, RAPIDJSON_PARSE_ERROR, rapidjson::SkipWhitespace(), and rapidjson::GenericReader< Encoding, Allocator >::stack_.

ParseArray()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseArray ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                      {
        RAPIDJSON_ASSERT(stream.Peek() == '[');
        stream.Take();  // Skip '['
        handler.StartArray();
        SkipWhitespace(stream);
 
        if (stream.Peek() == ']') {
            stream.Take();
            handler.EndArray(0); // empty array
            return;
        }
 
        for (SizeType elementCount = 0;;) {
            ParseValue<parseFlags>(stream, handler);
            ++elementCount;
            SkipWhitespace(stream);
 
            switch (stream.Take()) {
                case ',': SkipWhitespace(stream); break;
                case ']': handler.EndArray(elementCount); return;
                default:  RAPIDJSON_PARSE_ERROR("Must be a comma or ']' after an array element.", stream.Tell());
            }
        }
    }

References RAPIDJSON_ASSERT, RAPIDJSON_PARSE_ERROR, and rapidjson::SkipWhitespace().

ParseFalse()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseFalse ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                      {
        RAPIDJSON_ASSERT(stream.Peek() == 'f');
        stream.Take();
 
        if (stream.Take() == 'a' && stream.Take() == 'l' && stream.Take() == 's' && stream.Take() == 'e')
            handler.Bool_(false);
        else
            RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell() - 1);
    }

References RAPIDJSON_ASSERT, and RAPIDJSON_PARSE_ERROR.

ParseHex4()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<typename Stream >

unsigned rapidjson::GenericReader< Encoding, Allocator >::ParseHex4 ( Stream &  stream )

inlineprivate

                                       {
        Stream s = stream;  // Use a local copy for optimization
        unsigned codepoint = 0;
        for (int i = 0; i < 4; i++) {
            Ch c = s.Take();
            codepoint <<= 4;
            codepoint += c;
            if (c >= '0' && c <= '9')
                codepoint -= '0';
            else if (c >= 'A' && c <= 'F')
                codepoint -= 'A' - 10;
            else if (c >= 'a' && c <= 'f')
                codepoint -= 'a' - 10;
            else
                RAPIDJSON_PARSE_ERROR("Incorrect hex digit after \\u escape", s.Tell() - 1);
        }
        stream = s; // Restore stream
        return codepoint;
    }

References constants::i, and RAPIDJSON_PARSE_ERROR.

Referenced by rapidjson::GenericReader< Encoding, Allocator >::ParseString().

ParseInfinity()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseInfinity ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                         {
        RAPIDJSON_ASSERT(stream.Peek() == 'i');
        stream.Take();
 
    if (stream.Take() == 'n' && stream.Take() == 'f')
      handler.Double( std::numeric_limits<double>::infinity() );
    else
            RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell() - 1);
    }

References RAPIDJSON_ASSERT, and RAPIDJSON_PARSE_ERROR.

ParseNaNNull_()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseNaNNull_ ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                         {
        RAPIDJSON_ASSERT(stream.Peek() == 'n');
        stream.Take();
 
    if( stream.Peek() == 'a' && stream.Take() == 'a' && stream.Take() == 'n' )
      handler.Double( std::numeric_limits<double>::quiet_NaN() );
    else if (stream.Take() == 'u' && stream.Take() == 'l' && stream.Take() == 'l')
            handler.Null_();
    else
            RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell() - 1);
    }

References RAPIDJSON_ASSERT, and RAPIDJSON_PARSE_ERROR.

ParseNumber()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseNumber ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                       {
        Stream s = stream; // Local copy for optimization
 
        // Parse minus
        bool minus = false;
        if (s.Peek() == '-') {
            minus = true;
            s.Take();
        }
 
        // Parse int: zero / ( digit1-9 *DIGIT )
        unsigned i;
        bool try64bit = false;
        if (s.Peek() == '0') {
            i = 0;
            s.Take();
        }
        else if (s.Peek() >= '1' && s.Peek() <= '9') {
            i = s.Take() - '0';
 
            if (minus)
                while (s.Peek() >= '0' && s.Peek() <= '9') {
                    if (i >= 214748364) { // 2^31 = 2147483648
                        if (i != 214748364 || s.Peek() > '8') {
                            try64bit = true;
                            break;
                        }
                    }
                    i = i * 10 + (s.Take() - '0');
                }
            else
                while (s.Peek() >= '0' && s.Peek() <= '9') {
                    if (i >= 429496729) { // 2^32 - 1 = 4294967295
                        if (i != 429496729 || s.Peek() > '5') {
                            try64bit = true;
                            break;
                        }
                    }
                    i = i * 10 + (s.Take() - '0');
                }
        }
        else {
            RAPIDJSON_PARSE_ERROR("Expect a value here.", stream.Tell());
            return;
        }
 
        // Parse 64bit int
        uint64_t i64 = 0;
        bool useDouble = false;
        if (try64bit) {
            i64 = i;
            if (minus)
                while (s.Peek() >= '0' && s.Peek() <= '9') {
                    if (i64 >= 922337203685477580uLL) // 2^63 = 9223372036854775808
                        if (i64 != 922337203685477580uLL || s.Peek() > '8') {
                            useDouble = true;
                            break;
                        }
                    i64 = i64 * 10 + (s.Take() - '0');
                }
            else
                while (s.Peek() >= '0' && s.Peek() <= '9') {
                    if (i64 >= 1844674407370955161uLL) // 2^64 - 1 = 18446744073709551615
                        if (i64 != 1844674407370955161uLL || s.Peek() > '5') {
                            useDouble = true;
                            break;
                        }
                    i64 = i64 * 10 + (s.Take() - '0');
                }
        }
 
        // Force double for big integer
        double d = 0.0;
        if (useDouble) {
            d = (double)i64;
            while (s.Peek() >= '0' && s.Peek() <= '9') {
                if (d >= 1E307) {
                    RAPIDJSON_PARSE_ERROR("Number too big to store in double", stream.Tell());
                    return;
                }
                d = d * 10 + (s.Take() - '0');
            }
        }
 
        // Parse frac = decimal-point 1*DIGIT
        int expFrac = 0;
        if (s.Peek() == '.') {
            if (!useDouble) {
                d = try64bit ? (double)i64 : (double)i;
                useDouble = true;
            }
            s.Take();
 
            if (s.Peek() >= '0' && s.Peek() <= '9') {
                d = d * 10 + (s.Take() - '0');
                --expFrac;
            }
            else {
                RAPIDJSON_PARSE_ERROR("At least one digit in fraction part", stream.Tell());
                return;
            }
 
            while (s.Peek() >= '0' && s.Peek() <= '9') {
                if (expFrac > -20) {
                    d = d * 10 + (s.Peek() - '0');
                    --expFrac;
                }
                s.Take();
            }
        }
 
        // Parse exp = e [ minus / plus ] 1*DIGIT
        int exp = 0;
        if (s.Peek() == 'e' || s.Peek() == 'E') {
            if (!useDouble) {
                d = try64bit ? (double)i64 : (double)i;
                useDouble = true;
            }
            s.Take();
 
            bool expMinus = false;
            if (s.Peek() == '+')
                s.Take();
            else if (s.Peek() == '-') {
                s.Take();
                expMinus = true;
            }
 
            if (s.Peek() >= '0' && s.Peek() <= '9') {
                exp = s.Take() - '0';
                while (s.Peek() >= '0' && s.Peek() <= '9') {
                    exp = exp * 10 + (s.Take() - '0');
                    if (exp > 308) {
            // Attempt denormalized construction
            std::stringstream ss;
            ss.precision( std::numeric_limits<double>::max_digits10 );
            ss << d * internal::Pow10(expFrac) << 'e' << (expMinus ? '-' : '+') << exp;
 
            double dd;
            ss >> dd;
 
            if( std::fpclassify( dd ) == FP_SUBNORMAL )
              handler.Double( dd );
            else
                          RAPIDJSON_PARSE_ERROR("Number too big to store in double", stream.Tell());
 
                        return;
                    }
                }
            }
            else {
                RAPIDJSON_PARSE_ERROR("At least one digit in exponent", s.Tell());
                return;
            }
 
            if (expMinus)
                exp = -exp;
        }
 
        // Finish parsing, call event according to the type of number.
        if (useDouble) {
            d *= internal::Pow10(exp + expFrac);
            handler.Double(minus ? -d : d);
        }
        else {
            if (try64bit) {
                if (minus)
                    handler.Int64(-(int64_t)i64);
                else
                    handler.Uint64(i64);
            }
            else {
                if (minus)
                    handler.Int(-(int)i);
                else
                    handler.Uint(i);
            }
        }
 
        stream = s; // restore stream
    }

References mathsFunc::exp(), constants::i, rapidjson::internal::Pow10(), and RAPIDJSON_PARSE_ERROR.

ParseObject()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseObject ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                       {
        RAPIDJSON_ASSERT(stream.Peek() == '{');
        stream.Take();  // Skip '{'
        handler.StartObject();
        SkipWhitespace(stream);
 
        if (stream.Peek() == '}') {
            stream.Take();
            handler.EndObject(0);   // empty object
            return;
        }
 
        for (SizeType memberCount = 0;;) {
            if (stream.Peek() != '"') {
                RAPIDJSON_PARSE_ERROR("Name of an object member must be a string", stream.Tell());
                break;
            }
 
            ParseString<parseFlags>(stream, handler);
            SkipWhitespace(stream);
 
            if (stream.Take() != ':') {
                RAPIDJSON_PARSE_ERROR("There must be a colon after the name of object member", stream.Tell());
                break;
            }
            SkipWhitespace(stream);
 
            ParseValue<parseFlags>(stream, handler);
            SkipWhitespace(stream);
 
            ++memberCount;
 
            switch(stream.Take()) {
                case ',': SkipWhitespace(stream); break;
                case '}': handler.EndObject(memberCount); return;
                default:  RAPIDJSON_PARSE_ERROR("Must be a comma or '}' after an object member", stream.Tell());
            }
        }
    }

References RAPIDJSON_ASSERT, RAPIDJSON_PARSE_ERROR, and rapidjson::SkipWhitespace().

ParseString()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseString ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                       {
#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
        static const Ch escape[256] = {
            Z16, Z16, 0, 0,'\"', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'/',
            Z16, Z16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
            0, 0,'\b', 0, 0, 0,'\f', 0, 0, 0, 0, 0, 0, 0,'\n', 0,
            0, 0,'\r', 0,'\t', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16
        };
#undef Z16
 
        Stream s = stream;  // Use a local copy for optimization
        RAPIDJSON_ASSERT(s.Peek() == '\"');
        s.Take();   // Skip '\"'
        Ch *head;
        SizeType len;
        if (parseFlags & kParseInsituFlag)
            head = s.PutBegin();
        else
            len = 0;
 
#define RAPIDJSON_PUT(x) \
    do { \
        if (parseFlags & kParseInsituFlag) \
            s.Put(x); \
        else { \
            *stack_.template Push<Ch>() = x; \
            ++len; \
        } \
    } while(false)
 
        for (;;) {
            Ch c = s.Take();
            if (c == '\\') {    // Escape
                Ch e = s.Take();
                if ((sizeof(Ch) == 1 || characterOk(e)) && escape[(unsigned char)e])
                    RAPIDJSON_PUT(escape[(unsigned char)e]);
                else if (e == 'u') {    // Unicode
                    unsigned codepoint = ParseHex4(s);
                    if (codepoint >= 0xD800 && codepoint <= 0xDBFF) { // Handle UTF-16 surrogate pair
                        if (s.Take() != '\\' || s.Take() != 'u') {
                            RAPIDJSON_PARSE_ERROR("Missing the second \\u in surrogate pair", s.Tell() - 2);
                            return;
                        }
                        unsigned codepoint2 = ParseHex4(s);
                        if (codepoint2 < 0xDC00 || codepoint2 > 0xDFFF) {
                            RAPIDJSON_PARSE_ERROR("The second \\u in surrogate pair is invalid", s.Tell() - 2);
                            return;
                        }
                        codepoint = (((codepoint - 0xD800) << 10) | (codepoint2 - 0xDC00)) + 0x10000;
                    }
 
                    Ch buffer[4];
                    SizeType count = SizeType(Encoding::Encode(buffer, codepoint) - &buffer[0]);
 
                    if (parseFlags & kParseInsituFlag)
                        for (SizeType i = 0; i < count; i++)
                            s.Put(buffer[i]);
                    else {
                        memcpy(stack_.template Push<Ch>(count), buffer, count * sizeof(Ch));
                        len += count;
                    }
                }
                else {
                    RAPIDJSON_PARSE_ERROR("Unknown escape character", stream.Tell() - 1);
                    return;
                }
            }
            else if (c == '"') {    // Closing double quote
                if (parseFlags & kParseInsituFlag) {
                    size_t length = s.PutEnd(head);
                    RAPIDJSON_ASSERT(length <= 0xFFFFFFFF);
                    RAPIDJSON_PUT('\0');    // null-terminate the string
                    handler.String(head, SizeType(length), false);
                }
                else {
                    RAPIDJSON_PUT('\0');
                    handler.String(stack_.template Pop<Ch>(len), len - 1, true);
                }
                stream = s; // restore stream
                return;
            }
            else if (c == '\0') {
                RAPIDJSON_PARSE_ERROR("lacks ending quotation before the end of string", stream.Tell() - 1);
                return;
            }
            else if ((unsigned)c < 0x20) {  // RFC 4627: unescaped = %x20-21 / %x23-5B / %x5D-10FFFF
                RAPIDJSON_PARSE_ERROR("Incorrect unescaped character in string", stream.Tell() - 1);
                return;
            }
            else
                RAPIDJSON_PUT(c);   // Normal character, just copy
        }
#undef RAPIDJSON_PUT
    }

References rapidjson::GenericReader< Encoding, Allocator >::characterOk(), constants::i, rapidjson::kParseInsituFlag, rapidjson::GenericReader< Encoding, Allocator >::ParseHex4(), RAPIDJSON_ASSERT, RAPIDJSON_PARSE_ERROR, RAPIDJSON_PUT, rapidjson::GenericReader< Encoding, Allocator >::stack_, and Z16.

ParseTrue()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseTrue ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                     {
        RAPIDJSON_ASSERT(stream.Peek() == 't');
        stream.Take();
 
        if (stream.Take() == 'r' && stream.Take() == 'u' && stream.Take() == 'e')
            handler.Bool_(true);
        else
            RAPIDJSON_PARSE_ERROR("Invalid value", stream.Tell());
    }

References RAPIDJSON_ASSERT, and RAPIDJSON_PARSE_ERROR.

ParseValue()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<unsigned parseFlags, typename Stream , typename Handler >

void rapidjson::GenericReader< Encoding, Allocator >::ParseValue ( Stream &  stream, Handler &  handler  )

inlineprivate

                                                      {
        switch (stream.Peek()) {
            case 'n': ParseNaNNull_  <parseFlags>(stream, handler); break;
            case 'i': ParseInfinity  <parseFlags>(stream, handler); break;
            case 't': ParseTrue      <parseFlags>(stream, handler); break;
            case 'f': ParseFalse     <parseFlags>(stream, handler); break;
            case '"': ParseString    <parseFlags>(stream, handler); break;
            case '{': ParseObject    <parseFlags>(stream, handler); break;
            case '[': ParseArray     <parseFlags>(stream, handler); break;
            default : ParseNumber    <parseFlags>(stream, handler);
        }
    }

to_int()

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

template<class T >

static constexpr int rapidjson::GenericReader< Encoding, Allocator >::to_int ( T  t )

inlinestaticconstexprprivate

{ return t; }

Member Data Documentation

errorOffset_

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

size_t rapidjson::GenericReader< Encoding, Allocator >::errorOffset_

private

Referenced by rapidjson::GenericReader< Encoding, Allocator >::GetErrorOffset(), and rapidjson::GenericReader< Encoding, Allocator >::Parse().

jmpbuf_

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

jmp_buf rapidjson::GenericReader< Encoding, Allocator >::jmpbuf_

private

setjmp buffer for fast exit from nested parsing function calls.

Referenced by rapidjson::GenericReader< Encoding, Allocator >::Parse().

kDefaultStackCapacity

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

const size_t rapidjson::GenericReader< Encoding, Allocator >::kDefaultStackCapacity = 256

staticprivate

Default stack capacity in bytes for storing a single decoded string.

parseError_

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

const char* rapidjson::GenericReader< Encoding, Allocator >::parseError_

private

Referenced by rapidjson::GenericReader< Encoding, Allocator >::GetParseError(), rapidjson::GenericReader< Encoding, Allocator >::HasParseError(), and rapidjson::GenericReader< Encoding, Allocator >::Parse().

stack_

template<typename Encoding , typename Allocator = MemoryPoolAllocator<>>

internal::Stack<Allocator> rapidjson::GenericReader< Encoding, Allocator >::stack_

private

A stack for storing decoded string temporarily during non-destructive parsing.

Referenced by rapidjson::GenericReader< Encoding, Allocator >::Parse(), and rapidjson::GenericReader< Encoding, Allocator >::ParseString().

---

The documentation for this class was generated from the following file:

• reader.h