PrettyWriter< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags >

Writer with indentation and spacing. More...

#include <fwd.h>

Inheritance diagram for PrettyWriter< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags >:

Collaboration diagram for PrettyWriter< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags >:

Public Types
typedef Writer< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags >	Base
typedef Base::Ch	Ch

Public Member Functions
	PrettyWriter (OutputStream &os, StackAllocator *allocator=0, size_t levelDepth=Base::kDefaultLevelDepth)
	Constructor. More...
	PrettyWriter (StackAllocator *allocator=0, size_t levelDepth=Base::kDefaultLevelDepth)
PrettyWriter &	SetIndent (Ch indentChar, unsigned indentCharCount)
	Set custom indentation. More...
PrettyWriter &	SetFormatOptions (PrettyFormatOptions options)
	Set pretty writer formatting options. More...
bool	RawValue (const Ch *json, size_t length, Type type)
	Write a raw JSON value. More...
void	Reset (OutputStream &os)
	Reset the writer with a new stream. More...
bool	IsComplete () const
	Checks whether the output is a complete JSON. More...
int	GetMaxDecimalPlaces () const
void	SetMaxDecimalPlaces (int maxDecimalPlaces)
	Sets the maximum number of decimal places for double output. More...
void	Flush ()
	Flush the output stream. More...
Implementation of Handler
See also Handler
bool	Null ()
bool	Bool (bool b)
bool	Int (int i)
bool	Uint (unsigned u)
bool	Int64 (int64_t i64)
bool	Uint64 (uint64_t u64)
bool	Double (double d)
bool	RawNumber (const Ch *str, SizeType length, bool copy=false)
bool	String (const Ch *str, SizeType length, bool copy=false)
bool	StartObject ()
bool	Key (const Ch *str, SizeType length, bool copy=false)
bool	EndObject (SizeType memberCount=0)
bool	StartArray ()
bool	EndArray (SizeType memberCount=0)
Convenience extensions
bool	String (const Ch *str)
	Simpler but slower overload. More...
bool	Key (const Ch *str)
Convenience extensions
bool	String (const Ch *const &str)
	Simpler but slower overload. More...
bool	Key (const Ch *const &str)

Static Public Attributes
static const int	kDefaultMaxDecimalPlaces = 324

Protected Member Functions
void	PrettyPrefix (Type type)
void	WriteIndent ()
bool	WriteNull ()
bool	WriteBool (bool b)
bool	WriteInt (int i)
template<>
bool	WriteInt (int i)
bool	WriteUint (unsigned u)
template<>
bool	WriteUint (unsigned u)
bool	WriteInt64 (int64_t i64)
template<>
bool	WriteInt64 (int64_t i64)
bool	WriteUint64 (uint64_t u64)
template<>
bool	WriteUint64 (uint64_t u)
bool	WriteDouble (double d)
template<>
bool	WriteDouble (double d)
bool	WriteString (const Ch *str, SizeType length)
bool	ScanWriteUnescapedString (GenericStringStream< SourceEncoding > &is, size_t length)
bool	WriteStartObject ()
bool	WriteEndObject ()
bool	WriteStartArray ()
bool	WriteEndArray ()
bool	WriteRawValue (const Ch *json, size_t length)
void	Prefix (Type type)
bool	EndValue (bool ret)

Protected Attributes
Ch	indentChar_
unsigned	indentCharCount_
PrettyFormatOptions	formatOptions_
OutputStream *	os_
internal::Stack< StackAllocator >	level_stack_
int	maxDecimalPlaces_
bool	hasRoot_

Static Protected Attributes
static const size_t	kDefaultLevelDepth = 32

Private Member Functions
	PrettyWriter (const PrettyWriter &)
PrettyWriter &	operator= (const PrettyWriter &)

Detailed Description

template<typename OutputStream, typename SourceEncoding = UTF8<>, typename TargetEncoding = UTF8<>, typename StackAllocator = CrtAllocator, unsigned writeFlags = kWriteDefaultFlags>
class PrettyWriter< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags >

Writer with indentation and spacing.

Template Parameters

OutputStream	Type of output os.
SourceEncoding	Encoding of source string.
TargetEncoding	Encoding of output stream.
StackAllocator	Type of allocator for allocating memory of stack.

Definition at line 100 of file fwd.h.

Member Typedef Documentation

Base

typedef Writer<OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags> Base

Definition at line 50 of file prettywriter.h.

Ch

typedef Base::Ch Ch

Definition at line 51 of file prettywriter.h.

Constructor & Destructor Documentation

PrettyWriter() [1/3]

PrettyWriter ( OutputStream &  os, StackAllocator *  allocator = 0, size_t  levelDepth = Base::kDefaultLevelDepth  )

inlineexplicit

Constructor.

Parameters

os	Output stream.
allocator	User supplied allocator. If it is null, it will create a private one.
levelDepth	Initial capacity of stack.

Definition at line 58 of file prettywriter.h.

                                                                                                                       : 
        Base(os, allocator, levelDepth), indentChar_(' '), indentCharCount_(4), formatOptions_(kFormatDefault) {}

Here is the caller graph for this function:

PrettyWriter() [2/3]

PrettyWriter ( StackAllocator *  allocator = 0, size_t  levelDepth = Base::kDefaultLevelDepth  )

inlineexplicit

Definition at line 62 of file prettywriter.h.

                                                                                                     : 
        Base(allocator, levelDepth), indentChar_(' '), indentCharCount_(4) {}

Here is the call graph for this function:

PrettyWriter() [3/3]

PrettyWriter ( const PrettyWriter< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags > &  )

private

Member Function Documentation

Bool()

bool Bool ( bool  b )

inline

Definition at line 96 of file prettywriter.h.

{ PrettyPrefix(b ? kTrueType : kFalseType); return Base::EndValue(Base::WriteBool(b)); }

Here is the call graph for this function:

Double()

bool Double ( double  d )

inline

Definition at line 101 of file prettywriter.h.

{ PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteDouble(d)); }

Here is the call graph for this function:

EndArray()

bool EndArray ( SizeType  memberCount = 0 )

inline

Definition at line 163 of file prettywriter.h.

                                            {
        (void)memberCount;
        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level));
        RAPIDJSON_ASSERT(Base::level_stack_.template Top<typename Base::Level>()->inArray);
        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;

        if (!empty && !(formatOptions_ & kFormatSingleLineArray)) {
            Base::os_->Put('\n');
            WriteIndent();
        }
        bool ret = Base::EndValue(Base::WriteEndArray());
        (void)ret;
        RAPIDJSON_ASSERT(ret == true);
        if (Base::level_stack_.Empty()) // end of json text
            Base::Flush();
        return true;
    }

Here is the call graph for this function:

EndObject()

bool EndObject ( SizeType  memberCount = 0 )

inline

Definition at line 137 of file prettywriter.h.

                                             {
        (void)memberCount;
        RAPIDJSON_ASSERT(Base::level_stack_.GetSize() >= sizeof(typename Base::Level)); // not inside an Object
        RAPIDJSON_ASSERT(!Base::level_stack_.template Top<typename Base::Level>()->inArray); // currently inside an Array, not Object
        RAPIDJSON_ASSERT(0 == Base::level_stack_.template Top<typename Base::Level>()->valueCount % 2); // Object has a Key without a Value
       
        bool empty = Base::level_stack_.template Pop<typename Base::Level>(1)->valueCount == 0;

        if (!empty) {
            Base::os_->Put('\n');
            WriteIndent();
        }
        bool ret = Base::EndValue(Base::WriteEndObject());
        (void)ret;
        RAPIDJSON_ASSERT(ret == true);
        if (Base::level_stack_.Empty()) // end of json text
            Base::Flush();
        return true;
    }

Here is the call graph for this function:

EndValue()

bool EndValue ( bool  ret )

inlineprotectedinherited

Definition at line 493 of file writer.h.

                            {
        if (RAPIDJSON_UNLIKELY(level_stack_.Empty()))   // end of json text
            Flush();
        return ret;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Flush()

void Flush ( )

inlineinherited

Flush the output stream.

Allows the user to flush the output stream immediately.

Definition at line 281 of file writer.h.

                 {
        os_->Flush();
    }

Here is the caller graph for this function:

GetMaxDecimalPlaces()

int GetMaxDecimalPlaces ( ) const

inlineinherited

Definition at line 147 of file writer.h.

                                    {
        return maxDecimalPlaces_;
    }

Int()

bool Int ( int  i )

inline

Definition at line 97 of file prettywriter.h.

{ PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt(i)); }

Here is the call graph for this function:

Int64()

bool Int64 ( int64_t  i64 )

inline

Definition at line 99 of file prettywriter.h.

{ PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteInt64(i64)); }

Here is the call graph for this function:

IsComplete()

bool IsComplete ( ) const

inlineinherited

Checks whether the output is a complete JSON.

A complete JSON has a complete root object or array.

Definition at line 143 of file writer.h.

                            {
        return hasRoot_ && level_stack_.Empty();
    }

Here is the call graph for this function:

Key() [1/3]

bool Key ( const Ch *  str, SizeType  length, bool  copy = false  )

inline

Definition at line 129 of file prettywriter.h.

{ return String(str, length, copy); }

Here is the call graph for this function:

Key() [2/3]

bool Key ( const Ch *  str )

inline

Definition at line 188 of file prettywriter.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Key() [3/3]

bool Key ( const Ch *const &  str )

inlineinherited

Definition at line 259 of file writer.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Null()

bool Null ( )

inline

Definition at line 95 of file prettywriter.h.

{ PrettyPrefix(kNullType);   return Base::EndValue(Base::WriteNull()); }

Here is the call graph for this function:

operator=()

PrettyWriter& operator= ( const PrettyWriter< OutputStream, SourceEncoding, TargetEncoding, StackAllocator, writeFlags > &  )

private

Prefix()

void Prefix ( Type  type )

inlineprotectedinherited

Definition at line 472 of file writer.h.

                           {
        (void)type;
        if (RAPIDJSON_LIKELY(level_stack_.GetSize() != 0)) { // this value is not at root
            Level* level = level_stack_.template Top<Level>();
            if (level->valueCount > 0) {
                if (level->inArray) 
                    os_->Put(','); // add comma if it is not the first element in array
                else  // in object
                    os_->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(!hasRoot_);    // Should only has one and only one root.
            hasRoot_ = true;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

PrettyPrefix()

void PrettyPrefix ( Type  type )

inlineprotected

Definition at line 208 of file prettywriter.h.

                                 {
        (void)type;
        if (Base::level_stack_.GetSize() != 0) { // this value is not at root
            typename Base::Level* level = Base::level_stack_.template Top<typename Base::Level>();

            if (level->inArray) {
                if (level->valueCount > 0) {
                    Base::os_->Put(','); // add comma if it is not the first element in array
                    if (formatOptions_ & kFormatSingleLineArray)
                        Base::os_->Put(' ');
                }

                if (!(formatOptions_ & kFormatSingleLineArray)) {
                    Base::os_->Put('\n');
                    WriteIndent();
                }
            }
            else {  // in object
                if (level->valueCount > 0) {
                    if (level->valueCount % 2 == 0) {
                        Base::os_->Put(',');
                        Base::os_->Put('\n');
                    }
                    else {
                        Base::os_->Put(':');
                        Base::os_->Put(' ');
                    }
                }
                else
                    Base::os_->Put('\n');

                if (level->valueCount % 2 == 0)
                    WriteIndent();
            }
            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(!Base::hasRoot_);  // Should only has one and only one root.
            Base::hasRoot_ = true;
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

RawNumber()

bool RawNumber ( const Ch *  str, SizeType  length, bool  copy = false  )

inline

Definition at line 103 of file prettywriter.h.

                                                                      {
        RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        PrettyPrefix(kNumberType);
        return Base::EndValue(Base::WriteString(str, length));
    }

Here is the call graph for this function:

RawValue()

bool RawValue ( const Ch *  json, size_t  length, Type  type  )

inline

Write a raw JSON value.

For user to write a stringified JSON as a value.

Parameters

json	A well-formed JSON value. It should not contain null character within [0, length - 1] range.
length	Length of the json.
type	Type of the root of json.

Note

When using PrettyWriter::RawValue(), the result json may not be indented correctly.

Definition at line 201 of file prettywriter.h.

                                                            {
        RAPIDJSON_ASSERT(json != 0);
        PrettyPrefix(type);
        return Base::EndValue(Base::WriteRawValue(json, length));
    }

Here is the call graph for this function:

Reset()

void Reset ( OutputStream &  os )

inlineinherited

Reset the writer with a new stream.

This function reset the writer with a new stream and default settings, in order to make a Writer object reusable for output multiple JSONs.

Parameters

os	New output stream. Writer<OutputStream> writer(os1); writer.StartObject(); // ... writer.EndObject(); writer.Reset(os2); writer.StartObject(); // ... writer.EndObject();

Definition at line 133 of file writer.h.

                                 {
        os_ = &os;
        hasRoot_ = false;
        level_stack_.Clear();
    }

Here is the call graph for this function:

ScanWriteUnescapedString()

bool ScanWriteUnescapedString ( GenericStringStream< SourceEncoding > &  is, size_t  length  )

inlineprotectedinherited

Definition at line 450 of file writer.h.

                                                                                          {
        return RAPIDJSON_LIKELY(is.Tell() < length);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

SetFormatOptions()

PrettyWriter& SetFormatOptions ( PrettyFormatOptions  options )

inline

Set pretty writer formatting options.

Parameters

options

Formatting options.

Definition at line 85 of file prettywriter.h.

                                                                {
        formatOptions_ = options;
        return *this;
    }

SetIndent()

PrettyWriter& SetIndent ( Ch  indentChar, unsigned  indentCharCount  )

inline

Set custom indentation.

Parameters

indentChar	Character for indentation. Must be whitespace character (' ', '\t', '\n', '\r').
indentCharCount	Number of indent characters for each indentation level.

Note

The default indentation is 4 spaces.

Definition at line 75 of file prettywriter.h.

                                                                     {
        RAPIDJSON_ASSERT(indentChar == ' ' || indentChar == '\t' || indentChar == '\n' || indentChar == '\r');
        indentChar_ = indentChar;
        indentCharCount_ = indentCharCount;
        return *this;
    }

SetMaxDecimalPlaces()

void SetMaxDecimalPlaces ( int  maxDecimalPlaces )

inlineinherited

Sets the maximum number of decimal places for double output.

This setting truncates the output with specified number of decimal places.

For example,

writer.SetMaxDecimalPlaces(3);
writer.StartArray();
writer.Double(0.12345);                 // "0.123"
writer.Double(0.0001);                  // "0.0"
writer.Double(1.234567890123456e30);    // "1.234567890123456e30" (do not truncate significand for positive exponent)
writer.Double(1.23e-4);                 // "0.0"                  (do truncate significand for negative exponent)
writer.EndArray();

The default setting does not truncate any decimal places. You can restore to this setting by calling

writer.SetMaxDecimalPlaces(Writer::kDefaultMaxDecimalPlaces);

Definition at line 172 of file writer.h.

                                                   {
        maxDecimalPlaces_ = maxDecimalPlaces;
    }

StartArray()

bool StartArray ( )

inline

Definition at line 157 of file prettywriter.h.

                      {
        PrettyPrefix(kArrayType);
        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(true);
        return Base::WriteStartArray();
    }

Here is the call graph for this function:

StartObject()

bool StartObject ( )

inline

Definition at line 123 of file prettywriter.h.

                       {
        PrettyPrefix(kObjectType);
        new (Base::level_stack_.template Push<typename Base::Level>()) typename Base::Level(false);
        return Base::WriteStartObject();
    }

Here is the call graph for this function:

String() [1/3]

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

inline

Definition at line 110 of file prettywriter.h.

                                                                   {
        RAPIDJSON_ASSERT(str != 0);
        (void)copy;
        PrettyPrefix(kStringType);
        return Base::EndValue(Base::WriteString(str, length));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

String() [2/3]

bool String ( const Ch *  str )

inline

Simpler but slower overload.

Definition at line 187 of file prettywriter.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

String() [3/3]

bool String ( const Ch *const &  str )

inlineinherited

Simpler but slower overload.

Definition at line 258 of file writer.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Uint()

bool Uint ( unsigned  u )

inline

Definition at line 98 of file prettywriter.h.

{ PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint(u)); }

Here is the call graph for this function:

Uint64()

bool Uint64 ( uint64_t  u64 )

inline

Definition at line 100 of file prettywriter.h.

{ PrettyPrefix(kNumberType); return Base::EndValue(Base::WriteUint64(u64));  }

Here is the call graph for this function:

WriteBool()

bool WriteBool ( bool  b )

inlineprotectedinherited

Definition at line 300 of file writer.h.

                            {
        if (b) {
            PutReserve(*os_, 4);
            PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'r'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'e');
        }
        else {
            PutReserve(*os_, 5);
            PutUnsafe(*os_, 'f'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 's'); PutUnsafe(*os_, 'e');
        }
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteDouble() [1/2]

bool WriteDouble ( double  d )

inlineprotectedinherited

Definition at line 348 of file writer.h.

                               {
        if (internal::Double(d).IsNanOrInf()) {
            if (!(writeFlags & kWriteNanAndInfFlag))
                return false;
            if (internal::Double(d).IsNan()) {
                PutReserve(*os_, 3);
                PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
                return true;
            }
            if (internal::Double(d).Sign()) {
                PutReserve(*os_, 9);
                PutUnsafe(*os_, '-');
            }
            else
                PutReserve(*os_, 8);
            PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
            PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
            return true;
        }

        char buffer[25];
        char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteDouble() [2/2]

bool WriteDouble ( double  d )

inlineprotectedinherited

Definition at line 545 of file writer.h.

                                                      {
    if (internal::Double(d).IsNanOrInf()) {
        // Note: This code path can only be reached if (RAPIDJSON_WRITE_DEFAULT_FLAGS & kWriteNanAndInfFlag).
        if (!(kWriteDefaultFlags & kWriteNanAndInfFlag))
            return false;
        if (internal::Double(d).IsNan()) {
            PutReserve(*os_, 3);
            PutUnsafe(*os_, 'N'); PutUnsafe(*os_, 'a'); PutUnsafe(*os_, 'N');
            return true;
        }
        if (internal::Double(d).Sign()) {
            PutReserve(*os_, 9);
            PutUnsafe(*os_, '-');
        }
        else
            PutReserve(*os_, 8);
        PutUnsafe(*os_, 'I'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'f');
        PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'i'); PutUnsafe(*os_, 't'); PutUnsafe(*os_, 'y');
        return true;
    }
    
    char *buffer = os_->Push(25);
    char* end = internal::dtoa(d, buffer, maxDecimalPlaces_);
    os_->Pop(static_cast<size_t>(25 - (end - buffer)));
    return true;
}

Here is the call graph for this function:

WriteEndArray()

bool WriteEndArray ( )

inlineprotectedinherited

Definition at line 457 of file writer.h.

{ os_->Put(']'); return true; }

Here is the caller graph for this function:

WriteEndObject()

bool WriteEndObject ( )

inlineprotectedinherited

Definition at line 455 of file writer.h.

{ os_->Put('}'); return true; }

Here is the caller graph for this function:

WriteIndent()

void WriteIndent ( )

inlineprotected

Definition at line 252 of file prettywriter.h.

                        {
        size_t count = (Base::level_stack_.GetSize() / sizeof(typename Base::Level)) * indentCharCount_;
        PutN(*Base::os_, static_cast<typename OutputStream::Ch>(indentChar_), count);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteInt() [1/2]

bool WriteInt ( int  i )

inlineprotectedinherited

Definition at line 312 of file writer.h.

                         {
        char buffer[11];
        const char* end = internal::i32toa(i, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (const char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteInt() [2/2]

bool WriteInt ( int  i )

inlineprotectedinherited

Definition at line 513 of file writer.h.

                                                {
    char *buffer = os_->Push(11);
    const char* end = internal::i32toa(i, buffer);
    os_->Pop(static_cast<size_t>(11 - (end - buffer)));
    return true;
}

Here is the call graph for this function:

WriteInt64() [1/2]

bool WriteInt64 ( int64_t  i64 )

inlineprotectedinherited

Definition at line 330 of file writer.h.

                                 {
        char buffer[21];
        const char* end = internal::i64toa(i64, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (const char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteInt64() [2/2]

bool WriteInt64 ( int64_t  i64 )

inlineprotectedinherited

Definition at line 529 of file writer.h.

                                                        {
    char *buffer = os_->Push(21);
    const char* end = internal::i64toa(i64, buffer);
    os_->Pop(static_cast<size_t>(21 - (end - buffer)));
    return true;
}

Here is the call graph for this function:

WriteNull()

bool WriteNull ( )

inlineprotectedinherited

Definition at line 295 of file writer.h.

                      {
        PutReserve(*os_, 4);
        PutUnsafe(*os_, 'n'); PutUnsafe(*os_, 'u'); PutUnsafe(*os_, 'l'); PutUnsafe(*os_, 'l'); return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteRawValue()

bool WriteRawValue ( const Ch *  json, size_t  length  )

inlineprotectedinherited

Definition at line 459 of file writer.h.

                                                      {
        PutReserve(*os_, length);
        GenericStringStream<SourceEncoding> is(json);
        while (RAPIDJSON_LIKELY(is.Tell() < length)) {
            RAPIDJSON_ASSERT(is.Peek() != '\0');
            if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
                return false;
        }
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteStartArray()

bool WriteStartArray ( )

inlineprotectedinherited

Definition at line 456 of file writer.h.

{ os_->Put('['); return true; }

Here is the caller graph for this function:

WriteStartObject()

bool WriteStartObject ( )

inlineprotectedinherited

Definition at line 454 of file writer.h.

{ os_->Put('{'); return true; }

Here is the caller graph for this function:

WriteString()

bool WriteString ( const Ch *  str, SizeType  length  )

inlineprotectedinherited

Definition at line 376 of file writer.h.

                                                      {
        static const typename OutputStream::Ch hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        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
        };

        if (TargetEncoding::supportUnicode)
            PutReserve(*os_, 2 + length * 6); // "\uxxxx..."
        else
            PutReserve(*os_, 2 + length * 12);  // "\uxxxx\uyyyy..."

        PutUnsafe(*os_, '\"');
        GenericStringStream<SourceEncoding> is(str);
        while (ScanWriteUnescapedString(is, length)) {
            const Ch c = is.Peek();
            if (!TargetEncoding::supportUnicode && static_cast<unsigned>(c) >= 0x80) {
                // Unicode escaping
                unsigned codepoint;
                if (RAPIDJSON_UNLIKELY(!SourceEncoding::Decode(is, &codepoint)))
                    return false;
                PutUnsafe(*os_, '\\');
                PutUnsafe(*os_, 'u');
                if (codepoint <= 0xD7FF || (codepoint >= 0xE000 && codepoint <= 0xFFFF)) {
                    PutUnsafe(*os_, hexDigits[(codepoint >> 12) & 15]);
                    PutUnsafe(*os_, hexDigits[(codepoint >>  8) & 15]);
                    PutUnsafe(*os_, hexDigits[(codepoint >>  4) & 15]);
                    PutUnsafe(*os_, hexDigits[(codepoint      ) & 15]);
                }
                else {
                    RAPIDJSON_ASSERT(codepoint >= 0x010000 && codepoint <= 0x10FFFF);
                    // Surrogate pair
                    unsigned s = codepoint - 0x010000;
                    unsigned lead = (s >> 10) + 0xD800;
                    unsigned trail = (s & 0x3FF) + 0xDC00;
                    PutUnsafe(*os_, hexDigits[(lead >> 12) & 15]);
                    PutUnsafe(*os_, hexDigits[(lead >>  8) & 15]);
                    PutUnsafe(*os_, hexDigits[(lead >>  4) & 15]);
                    PutUnsafe(*os_, hexDigits[(lead      ) & 15]);
                    PutUnsafe(*os_, '\\');
                    PutUnsafe(*os_, 'u');
                    PutUnsafe(*os_, hexDigits[(trail >> 12) & 15]);
                    PutUnsafe(*os_, hexDigits[(trail >>  8) & 15]);
                    PutUnsafe(*os_, hexDigits[(trail >>  4) & 15]);
                    PutUnsafe(*os_, hexDigits[(trail      ) & 15]);                    
                }
            }
            else if ((sizeof(Ch) == 1 || static_cast<unsigned>(c) < 256) && RAPIDJSON_UNLIKELY(escape[static_cast<unsigned char>(c)]))  {
                is.Take();
                PutUnsafe(*os_, '\\');
                PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(escape[static_cast<unsigned char>(c)]));
                if (escape[static_cast<unsigned char>(c)] == 'u') {
                    PutUnsafe(*os_, '0');
                    PutUnsafe(*os_, '0');
                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) >> 4]);
                    PutUnsafe(*os_, hexDigits[static_cast<unsigned char>(c) & 0xF]);
                }
            }
            else if (RAPIDJSON_UNLIKELY(!(writeFlags & kWriteValidateEncodingFlag ? 
                Transcoder<SourceEncoding, TargetEncoding>::Validate(is, *os_) :
                Transcoder<SourceEncoding, TargetEncoding>::TranscodeUnsafe(is, *os_))))
                return false;
        }
        PutUnsafe(*os_, '\"');
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteUint() [1/2]

bool WriteUint ( unsigned  u )

inlineprotectedinherited

Definition at line 321 of file writer.h.

                               {
        char buffer[10];
        const char* end = internal::u32toa(u, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (const char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteUint() [2/2]

bool WriteUint ( unsigned  u )

inlineprotectedinherited

Definition at line 521 of file writer.h.

                                                      {
    char *buffer = os_->Push(10);
    const char* end = internal::u32toa(u, buffer);
    os_->Pop(static_cast<size_t>(10 - (end - buffer)));
    return true;
}

Here is the call graph for this function:

WriteUint64() [1/2]

bool WriteUint64 ( uint64_t  u64 )

inlineprotectedinherited

Definition at line 339 of file writer.h.

                                   {
        char buffer[20];
        char* end = internal::u64toa(u64, buffer);
        PutReserve(*os_, static_cast<size_t>(end - buffer));
        for (char* p = buffer; p != end; ++p)
            PutUnsafe(*os_, static_cast<typename OutputStream::Ch>(*p));
        return true;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

WriteUint64() [2/2]

bool WriteUint64 ( uint64_t  u )

inlineprotectedinherited

Definition at line 537 of file writer.h.

                                                        {
    char *buffer = os_->Push(20);
    const char* end = internal::u64toa(u, buffer);
    os_->Pop(static_cast<size_t>(20 - (end - buffer)));
    return true;
}

Here is the call graph for this function:

Member Data Documentation

formatOptions_

PrettyFormatOptions formatOptions_

protected

Definition at line 259 of file prettywriter.h.

hasRoot_

bool hasRoot_

protectedinherited

Definition at line 502 of file writer.h.

indentChar_

Ch indentChar_

protected

Definition at line 257 of file prettywriter.h.

indentCharCount_

unsigned indentCharCount_

protected

Definition at line 258 of file prettywriter.h.

kDefaultLevelDepth

const size_t kDefaultLevelDepth = 32

staticprotectedinherited

Definition at line 293 of file writer.h.

kDefaultMaxDecimalPlaces

const int kDefaultMaxDecimalPlaces = 324

staticinherited

Definition at line 93 of file writer.h.

level_stack_

internal::Stack<StackAllocator> level_stack_

protectedinherited

Definition at line 500 of file writer.h.

maxDecimalPlaces_

int maxDecimalPlaces_

protectedinherited

Definition at line 501 of file writer.h.

os_

OutputStream* os_

protectedinherited

Definition at line 499 of file writer.h.

---

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

• rapidjson/fwd.h
• rapidjson/prettywriter.h