rapidjson::Writer< Stream, Encoding, Allocator > Class Template Reference

JSON writer. More...

#include <writer.h>

Inheritance diagram for rapidjson::Writer< Stream, Encoding, Allocator >:

Classes
struct	Level
	Information for each nested level. More...

Public Types
typedef Encoding::Ch	Ch

Public Member Functions
	Writer (Stream &stream, int precision=20, Allocator *allocator=0, size_t levelDepth=kDefaultLevelDepth)
Writer &	Null_ ()
Writer &	Bool_ (bool b)
Writer &	Int (int i)
Writer &	Uint (unsigned u)
Writer &	Int64 (int64_t i64)
Writer &	Uint64 (uint64_t u64)
Writer &	Double (double d)
Writer &	LongDouble (long double d)
Writer &	LongLong (long long d)
Writer &	ULongLong (unsigned long long d)
Writer &	String (const Ch *str, SizeType length, bool copy=false)
Writer &	StartObject ()
Writer &	EndObject (SizeType memberCount=0)
Writer &	StartArray ()
Writer &	EndArray (SizeType elementCount=0)
Writer &	String (const Ch *str)
	Simpler but slower overload. More...

Protected Member Functions
void	WriteNull_ ()
void	WriteBool_ (bool b)
void	WriteInt (int i)
void	WriteUint (unsigned u)
void	WriteInt64 (int64_t i64)
void	WriteUint64 (uint64_t u64)
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)
void	WriteDouble (double d)
void	WriteLongDouble (long double d)
void	WriteLongLong (long long d)
void	WriteULongLong (unsigned long long d)
void	WriteString (const Ch *str, SizeType length)
void	WriteStartObject ()
void	WriteEndObject ()
void	WriteStartArray ()
void	WriteEndArray ()
void	Prefix (Type type)

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

Protected Attributes
char	double_format [32]
char	long_double_format [32]
Stream &	stream_
internal::Stack< Allocator >	level_stack_

Static Protected Attributes
static const size_t	kDefaultLevelDepth = 32

Private Member Functions
Writer &	operator= (const Writer &w)

Detailed Description

template<typename Stream, typename Encoding = UTF8<>, typename Allocator = MemoryPoolAllocator<>>
class rapidjson::Writer< Stream, Encoding, Allocator >

JSON writer.

Writer implements the concept Handler. It generates JSON text by events to an output stream.

User may programmatically calls the functions of a writer to generate JSON text.

On the other side, a writer can also be passed to objects that generates events,

for example Reader::Parse() and Document::Accept().

Template Parameters

Stream	Type of ouptut stream.
Encoding	Encoding of both source strings and output.

Member Typedef Documentation

Ch

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

typedef Encoding::Ch rapidjson::Writer< Stream, Encoding, Allocator >::Ch

Constructor & Destructor Documentation

Writer()

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

rapidjson::Writer< Stream, Encoding, Allocator >::Writer ( Stream &  stream, int  precision = 20, Allocator *  allocator = 0, size_t  levelDepth = kDefaultLevelDepth  )

inline

                                                                                                                 :
        stream_(stream), level_stack_(allocator, levelDepth * sizeof(Level))
  {
#if _MSC_VER
    (void) sprintf_s(double_format, sizeof(double_format), "%%0.%dg", precision);
    (void) sprintf_s( long_double_format, sizeof( long_double_format ), "%%0.%dLg", precision );
#else
    (void) snprintf(double_format, sizeof(double_format), "%%0.%dg", precision);
    (void) snprintf( long_double_format, sizeof( long_double_format ), "%%0.%dLg", precision );
#endif
 
  }

References rapidjson::Writer< Stream, Encoding, Allocator >::double_format, and rapidjson::Writer< Stream, Encoding, Allocator >::long_double_format.

Member Function Documentation

Bool_()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Bool_ ( bool  b )

inline

{ Prefix(b ? kTrueType : kFalseType); WriteBool_(b); return *this; }

References rapidjson::kFalseType, rapidjson::kTrueType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteBool_().

characterOk()

template<typename Stream , typename Encoding = UTF8<>, 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::Writer< Stream, Encoding, Allocator >::characterOk ( Ch  c )

inlineprotected

  { return c < 256; }

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::WriteString().

Double()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Double ( double  d )

inline

{ Prefix(kNumberType); WriteDouble(d);      return *this;           }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteDouble().

EndArray()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::EndArray ( SizeType  elementCount = 0 )

inline

                                                {
        (void)elementCount;
        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
        RAPIDJSON_ASSERT(level_stack_.template Top<Level>()->inArray);
        level_stack_.template Pop<Level>(1);
        WriteEndArray();
        return *this;
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::level_stack_, RAPIDJSON_ASSERT, and rapidjson::Writer< Stream, Encoding, Allocator >::WriteEndArray().

EndObject()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::EndObject ( SizeType  memberCount = 0 )

inline

                                                {
        (void)memberCount;
        RAPIDJSON_ASSERT(level_stack_.GetSize() >= sizeof(Level));
        RAPIDJSON_ASSERT(!level_stack_.template Top<Level>()->inArray);
        level_stack_.template Pop<Level>(1);
        WriteEndObject();
        return *this;
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::level_stack_, RAPIDJSON_ASSERT, and rapidjson::Writer< Stream, Encoding, Allocator >::WriteEndObject().

Int()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Int ( int  i )

inline

{ Prefix(kNumberType); WriteInt(i);         return *this;             }

References constants::i, rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt().

Int64()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Int64 ( int64_t  i64 )

inline

{ Prefix(kNumberType); WriteInt64(i64);     return *this;           }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt64().

LongDouble()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::LongDouble ( long double  d )

inline

{ Prefix(kNumberType); WriteLongDouble(d);      return *this;       }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongDouble().

LongLong()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::LongLong ( long long  d )

inline

{ Prefix(kNumberType); WriteLongLong(d);        return *this;         }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongLong().

Null_()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Null_ ( )

inline

{ Prefix(kNull_Type);   WriteNull_();           return *this;             }

References rapidjson::kNull_Type, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteNull_().

operator=()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::operator= ( const Writer< Stream, Encoding, Allocator > &  w )

private

Prefix()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::Prefix ( Type  type )

inlineprotected

                           {
        (void)type;
        if (level_stack_.GetSize() != 0) { // this value is not at root
            Level* level = level_stack_.template Top<Level>();
            if (level->valueCount > 0) {
                if (level->inArray)
                    stream_.Put(','); // add comma if it is not the first element in array
                else  // in object
                    stream_.Put((level->valueCount % 2 == 0) ? ',' : ':');
            }
            if (!level->inArray && level->valueCount % 2 == 0)
                RAPIDJSON_ASSERT(type == kStringType);  // if it's in object, then even number should be a name
            level->valueCount++;
        }
        else
            RAPIDJSON_ASSERT(type == kObjectType || type == kArrayType);
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::Level::inArray, rapidjson::kArrayType, rapidjson::kObjectType, rapidjson::kStringType, rapidjson::Writer< Stream, Encoding, Allocator >::level_stack_, RAPIDJSON_ASSERT, rapidjson::Writer< Stream, Encoding, Allocator >::stream_, and rapidjson::Writer< Stream, Encoding, Allocator >::Level::valueCount.

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::Bool_(), rapidjson::Writer< Stream, Encoding, Allocator >::Double(), rapidjson::Writer< Stream, Encoding, Allocator >::Int(), rapidjson::Writer< Stream, Encoding, Allocator >::Int64(), rapidjson::Writer< Stream, Encoding, Allocator >::LongDouble(), rapidjson::Writer< Stream, Encoding, Allocator >::LongLong(), rapidjson::Writer< Stream, Encoding, Allocator >::Null_(), rapidjson::Writer< Stream, Encoding, Allocator >::StartArray(), rapidjson::Writer< Stream, Encoding, Allocator >::StartObject(), rapidjson::Writer< Stream, Encoding, Allocator >::String(), rapidjson::Writer< Stream, Encoding, Allocator >::Uint(), rapidjson::Writer< Stream, Encoding, Allocator >::Uint64(), and rapidjson::Writer< Stream, Encoding, Allocator >::ULongLong().

StartArray()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::StartArray ( )

inline

                         {
        Prefix(kArrayType);
        new (level_stack_.template Push<Level>()) Level(true);
        WriteStartArray();
        return *this;
    }

References rapidjson::kArrayType, rapidjson::Writer< Stream, Encoding, Allocator >::level_stack_, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteStartArray().

StartObject()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::StartObject ( )

inline

                          {
        Prefix(kObjectType);
        new (level_stack_.template Push<Level>()) Level(false);
        WriteStartObject();
        return *this;
    }

References rapidjson::kObjectType, rapidjson::Writer< Stream, Encoding, Allocator >::level_stack_, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteStartObject().

String() [1/2]

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::String ( const Ch *  str )

inline

Simpler but slower overload.

{ return String(str, internal::StrLen(str)); }

References rapidjson::Writer< Stream, Encoding, Allocator >::String(), and rapidjson::internal::StrLen().

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::String().

String() [2/2]

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::String ( const Ch *  str, SizeType  length, bool  copy = false  )

inline

                                                                      {
        (void)copy;
        Prefix(kStringType);
        WriteString(str, length);
        return *this;
    }

References rapidjson::kStringType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteString().

to_int()

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

template<class T >

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

inlinestaticconstexprprotected

{ return t; }

Uint()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Uint ( unsigned  u )

inline

{ Prefix(kNumberType); WriteUint(u);        return *this;             }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint().

Uint64()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::Uint64 ( uint64_t  u64 )

inline

{ Prefix(kNumberType); WriteUint64(u64);    return *this;           }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint64().

ULongLong()

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

Writer& rapidjson::Writer< Stream, Encoding, Allocator >::ULongLong ( unsigned long long  d )

inline

{ Prefix(kNumberType); WriteULongLong(d);       return *this;         }

References rapidjson::kNumberType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteULongLong().

WriteBool_()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteBool_ ( bool  b )

inlineprotected

                             {
        if (b) {
            stream_.Put('t'); stream_.Put('r'); stream_.Put('u'); stream_.Put('e');
        }
        else {
            stream_.Put('f'); stream_.Put('a'); stream_.Put('l'); stream_.Put('s'); stream_.Put('e');
        }
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Bool_(), and rapidjson::Writer< Stream, Encoding, Allocator >::Bool_().

WriteDouble()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteDouble ( double  d )

inlineprotected

Todo:

Optimization with custom double-to-string converter.

                               {
        char buffer[100];
#if _MSC_VER
        int ret = sprintf_s(buffer, sizeof(buffer), double_format, d);
#else
        int ret = snprintf(buffer, sizeof(buffer), double_format, d);
#endif
        RAPIDJSON_ASSERT(ret >= 1);
        for (int i = 0; i < ret; i++)
            stream_.Put(buffer[i]);
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::double_format, constants::i, RAPIDJSON_ASSERT, and rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Double(), and rapidjson::Writer< Stream, Encoding, Allocator >::Double().

WriteEndArray()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteEndArray ( )

inlineprotected

{ stream_.Put(']'); }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::EndArray(), and rapidjson::PrettyWriter< Stream, Encoding, Allocator >::EndArray().

WriteEndObject()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteEndObject ( )

inlineprotected

{ stream_.Put('}'); }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::EndObject(), and rapidjson::Writer< Stream, Encoding, Allocator >::EndObject().

WriteInt()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt ( int  i )

inlineprotected

                         {
        if (i < 0) {
            stream_.Put('-');
            i = -i;
        }
        WriteUint((unsigned)i);
    }

References constants::i, rapidjson::Writer< Stream, Encoding, Allocator >::stream_, and rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint().

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Int(), and rapidjson::Writer< Stream, Encoding, Allocator >::Int().

WriteInt64()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt64 ( int64_t  i64 )

inlineprotected

                                 {
        if (i64 < 0) {
            stream_.Put('-');
            i64 = -i64;
        }
        WriteUint64((uint64_t)i64);
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_, and rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint64().

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Int64(), and rapidjson::Writer< Stream, Encoding, Allocator >::Int64().

WriteLongDouble()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongDouble ( long double  d )

inlineprotected

                                        {
        char buffer[256];
#if _MSC_VER
        int ret = sprintf_s(buffer, sizeof(buffer), long_double_format, d);
#else
        int ret = snprintf(buffer, sizeof(buffer), long_double_format, d);
#endif
        RAPIDJSON_ASSERT(ret >= 1);
        for (int i = 0; i < ret; i++)
            stream_.Put(buffer[i]);
    }

References constants::i, rapidjson::Writer< Stream, Encoding, Allocator >::long_double_format, RAPIDJSON_ASSERT, and rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::LongDouble().

WriteLongLong()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongLong ( long long  d )

inlineprotected

                                    {
        char buffer[256];
#if _MSC_VER
        int ret = sprintf_s(buffer, sizeof(buffer), "%lld", d);
#else
        int ret = snprintf(buffer, sizeof(buffer), "%lld", d);
#endif
        RAPIDJSON_ASSERT(ret >= 1);
        for (int i = 0; i < ret; i++)
            stream_.Put(buffer[i]);
    }

References constants::i, RAPIDJSON_ASSERT, and rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::LongLong().

WriteNull_()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteNull_ ( )

inlineprotected

                       {
        stream_.Put('n'); stream_.Put('u'); stream_.Put('l'); stream_.Put('l');
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Null_(), and rapidjson::Writer< Stream, Encoding, Allocator >::Null_().

WriteStartArray()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteStartArray ( )

inlineprotected

{ stream_.Put('['); }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::StartArray(), and rapidjson::Writer< Stream, Encoding, Allocator >::StartArray().

WriteStartObject()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteStartObject ( )

inlineprotected

{ stream_.Put('{'); }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::StartObject(), and rapidjson::Writer< Stream, Encoding, Allocator >::StartObject().

WriteString()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteString ( const Ch *  str, SizeType  length  )

inlineprotected

                                                      {
        static const char hexDigits[] = "0123456789ABCDEF";
        static const char escape[256] = {
#define Z16 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
            //0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r', 'u', 'u', // 00
            'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', // 10
              0,   0, '"',   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, // 20
            Z16, Z16,                                                                       // 30~4F
              0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,'\\',   0,   0,   0, // 50
            Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16, Z16                                // 60~FF
#undef Z16
        };
 
        stream_.Put('\"');
        for (const Ch* p = str; p != str + length; ++p) {
            if ((sizeof(Ch) == 1 || characterOk(*p)) && escape[(unsigned char)*p])  {
            //if ((sizeof(Ch) == 1 || *p < 256) && escape[(unsigned char)*p])  {
                stream_.Put('\\');
                stream_.Put(escape[(unsigned char)*p]);
                if (escape[(unsigned char)*p] == 'u') {
                    stream_.Put('0');
                    stream_.Put('0');
                    stream_.Put(hexDigits[(*p) >> 4]);
                    stream_.Put(hexDigits[(*p) & 0xF]);
                }
            }
            else
                stream_.Put(*p);
        }
        stream_.Put('\"');
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::characterOk(), rapidjson::Writer< Stream, Encoding, Allocator >::stream_, and Z16.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::String(), and rapidjson::Writer< Stream, Encoding, Allocator >::String().

WriteUint()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint ( unsigned  u )

inlineprotected

                               {
        char buffer[10];
        char *p = buffer;
        do {
            *p++ = (u % 10) + '0';
            u /= 10;
        } while (u > 0);
 
        do {
            --p;
            stream_.Put(*p);
        } while (p != buffer);
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Uint(), rapidjson::Writer< Stream, Encoding, Allocator >::Uint(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt().

WriteUint64()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint64 ( uint64_t  u64 )

inlineprotected

                                   {
        char buffer[20];
        char *p = buffer;
        do {
            *p++ = char(u64 % 10) + '0';
            u64 /= 10;
        } while (u64 > 0);
 
        do {
            --p;
            stream_.Put(*p);
        } while (p != buffer);
    }

References rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::Uint64(), rapidjson::Writer< Stream, Encoding, Allocator >::Uint64(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt64().

WriteULongLong()

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

void rapidjson::Writer< Stream, Encoding, Allocator >::WriteULongLong ( unsigned long long  d )

inlineprotected

                                              {
        char buffer[256];
#if _MSC_VER
        int ret = sprintf_s(buffer, sizeof(buffer), "%llu", d);
#else
        int ret = snprintf(buffer, sizeof(buffer), "%llu", d);
#endif
        RAPIDJSON_ASSERT(ret >= 1);
        for (int i = 0; i < ret; i++)
            stream_.Put(buffer[i]);
    }

References constants::i, RAPIDJSON_ASSERT, and rapidjson::Writer< Stream, Encoding, Allocator >::stream_.

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::ULongLong().

Member Data Documentation

double_format

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

char rapidjson::Writer< Stream, Encoding, Allocator >::double_format[32]

protected

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::WriteDouble(), and rapidjson::Writer< Stream, Encoding, Allocator >::Writer().

kDefaultLevelDepth

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

const size_t rapidjson::Writer< Stream, Encoding, Allocator >::kDefaultLevelDepth = 32

staticprotected

level_stack_

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

internal::Stack<Allocator> rapidjson::Writer< Stream, Encoding, Allocator >::level_stack_

protected

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::EndArray(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::EndArray(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::EndObject(), rapidjson::Writer< Stream, Encoding, Allocator >::EndObject(), rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::PrettyPrefix(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::StartArray(), rapidjson::Writer< Stream, Encoding, Allocator >::StartArray(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::StartObject(), rapidjson::Writer< Stream, Encoding, Allocator >::StartObject(), and rapidjson::PrettyWriter< Stream, Encoding, Allocator >::WriteIndent().

long_double_format

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

char rapidjson::Writer< Stream, Encoding, Allocator >::long_double_format[32]

protected

Referenced by rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongDouble(), and rapidjson::Writer< Stream, Encoding, Allocator >::Writer().

stream_

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

Stream& rapidjson::Writer< Stream, Encoding, Allocator >::stream_

protected

Referenced by rapidjson::PrettyWriter< Stream, Encoding, Allocator >::EndArray(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::EndObject(), rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::PrettyPrefix(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteBool_(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteDouble(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteEndArray(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteEndObject(), rapidjson::PrettyWriter< Stream, Encoding, Allocator >::WriteIndent(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteInt64(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongDouble(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteLongLong(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteNull_(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteStartArray(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteStartObject(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteString(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint(), rapidjson::Writer< Stream, Encoding, Allocator >::WriteUint64(), and rapidjson::Writer< Stream, Encoding, Allocator >::WriteULongLong().

---

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

• writer.h