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; }

References calibrate::c.

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 calibrate::c, i, RAPIDJSON_PARSE_ERROR, and s.

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 Eigen::bfloat16_impl::exp(), i, rapidjson::internal::Pow10(), RAPIDJSON_PARSE_ERROR, and s.

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 calibrate::c, rapidjson::GenericReader< Encoding, Allocator >::characterOk(), e(), escape(), i, rapidjson::kParseInsituFlag, rapidjson::GenericReader< Encoding, Allocator >::ParseHex4(), RAPIDJSON_ASSERT, RAPIDJSON_PARSE_ERROR, RAPIDJSON_PUT, s, 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);
            }
        }

References calibrate::default.

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; }

References plotPSD::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