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

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

b

Scalar * b

Definition: benchVecAdd.cpp:17

rapidjson::Writer::WriteBool_

void WriteBool_(bool b)

Definition: writer.h:126

rapidjson::Writer::Prefix

void Prefix(Type type)

Definition: writer.h:298

rapidjson::kTrueType

@ kTrueType

true

Definition: rapidjson.h:516

rapidjson::kFalseType

@ kFalseType

false

Definition: rapidjson.h:515

References b, 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

208 { return c < 256; }

calibrate.c

int c

Definition: calibrate.py:100

References calibrate::c.

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

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

rapidjson::Writer::WriteDouble

void WriteDouble(double d)

Definition: writer.h:212

rapidjson::kNumberType

@ kNumberType

number

Definition: rapidjson.h:520

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

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

i

int i

Definition: BiCGSTAB_step_by_step.cpp:9

rapidjson::Writer::WriteInt

void WriteInt(int i)

Definition: writer.h:135

References 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

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

rapidjson::Writer::WriteInt64

void WriteInt64(int64_t i64)

Definition: writer.h:157

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

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

rapidjson::Writer::WriteLongDouble

void WriteLongDouble(long double d)

Definition: writer.h:224

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

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

rapidjson::Writer::WriteLongLong

void WriteLongLong(long long d)

Definition: writer.h:236

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

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

rapidjson::Writer::WriteNull_

void WriteNull_()

Definition: writer.h:122

rapidjson::kNull_Type

@ kNull_Type

null

Definition: rapidjson.h:514

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_, compute_granudrum_aor::type, and rapidjson::Writer< Stream, Encoding, Allocator >::Level::valueCount.

◆ 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.

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

rapidjson::Writer::String

Writer & String(const Ch *str, SizeType length, bool copy=false)

Definition: writer.h:69

compute_granudrum_aor.str

str

Definition: compute_granudrum_aor.py:141

rapidjson::internal::StrLen

SizeType StrLen(const Ch *s)

Custom strlen() which works on different character types.

Definition: strfunc.h:14

References compute_granudrum_aor::str, 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 copy(), rapidjson::kStringType, rapidjson::Writer< Stream, Encoding, Allocator >::Prefix(), compute_granudrum_aor::str, 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

196 { return t; }

plotPSD.t

t

Definition: plotPSD.py:36

References plotPSD::t.

◆ Uint()

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

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

inline

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

rapidjson::Writer::WriteUint

void WriteUint(unsigned u)

Definition: writer.h:143

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

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

rapidjson::Writer::WriteUint64

void WriteUint64(uint64_t u64)

Definition: writer.h:165

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

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

rapidjson::Writer::WriteULongLong

void WriteULongLong(unsigned long long d)

Definition: writer.h:248

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 b, and 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, i, RAPIDJSON_ASSERT, ret, 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

296 { 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

294 { 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 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 i, rapidjson::Writer< Stream, Encoding, Allocator >::long_double_format, RAPIDJSON_ASSERT, ret, 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 i, RAPIDJSON_ASSERT, ret, 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

295 { 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

293 { 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(), escape(), p, compute_granudrum_aor::str, 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 p, and 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 p, and 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 i, RAPIDJSON_ASSERT, ret, 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

◆ 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

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

writer.h

Classes

Public Types

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

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

Member Typedef Documentation

◆ Ch

Constructor & Destructor Documentation

◆ Writer()

Member Function Documentation

◆ Bool_()

◆ characterOk()

◆ Double()

◆ EndArray()

◆ EndObject()

◆ Int()

◆ Int64()

◆ LongDouble()

◆ LongLong()

◆ Null_()

◆ operator=()

◆ Prefix()

◆ StartArray()

◆ StartObject()

◆ String() [1/2]

◆ String() [2/2]

◆ to_int()

◆ Uint()

◆ Uint64()

◆ ULongLong()

◆ WriteBool_()

◆ WriteDouble()

◆ WriteEndArray()

◆ WriteEndObject()

◆ WriteInt()

◆ WriteInt64()

◆ WriteLongDouble()

◆ WriteLongLong()

◆ WriteNull_()

◆ WriteStartArray()

◆ WriteStartObject()

◆ WriteString()

◆ WriteUint()

◆ WriteUint64()

◆ WriteULongLong()

Member Data Documentation

◆ double_format

◆ kDefaultLevelDepth

◆ level_stack_

◆ long_double_format

◆ stream_

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