GenericPointer< ValueType, Allocator > Class Template Reference

Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator. More...

#include <fwd.h>

Classes
class	PercentDecodeStream
	A helper stream for decoding a percent-encoded sequence into code unit. More...
class	PercentEncodeStream
	A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence. More...
struct	Token
	A token is the basic units of internal representation. More...

Public Types
typedef ValueType::EncodingType	EncodingType
	Encoding type from Value. More...
typedef ValueType::Ch	Ch
	Character type from Value. More...

Public Member Functions
Allocator stackAllocator	RAPIDJSON_DISABLEIF_RETURN ((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) GetWithDefault(GenericDocument< EncodingType
bool	Erase (ValueType &root) const
	Erase a value in a subtree. More...
Constructors and destructor.
	GenericPointer (Allocator *allocator=0)
	Default constructor. More...
	GenericPointer (const Ch *source, Allocator *allocator=0)
	Constructor that parses a string or URI fragment representation. More...
	GenericPointer (const Ch *source, size_t length, Allocator *allocator=0)
	Constructor that parses a string or URI fragment representation, with length of the source string. More...
	GenericPointer (const Token *tokens, size_t tokenCount)
	Constructor with user-supplied tokens. More...
	GenericPointer (const GenericPointer &rhs)
	Copy constructor. More...
	GenericPointer (const GenericPointer &rhs, Allocator *allocator)
	Copy constructor. More...
	~GenericPointer ()
	Destructor. More...
GenericPointer &	operator= (const GenericPointer &rhs)
	Assignment operator. More...
Append token
GenericPointer	Append (const Token &token, Allocator *allocator=0) const
	Append a token and return a new Pointer. More...
GenericPointer	Append (const Ch *name, SizeType length, Allocator *allocator=0) const
	Append a name token with length, and return a new Pointer. More...
template<typename T >
	RAPIDJSON_DISABLEIF_RETURN ((internal::NotExpr< internal::IsSame< typename internal::RemoveConst< T >::Type, Ch > >),(GenericPointer)) Append(T *name
	Append a name token without length, and return a new Pointer. More...
Swap a value
ValueType &	Swap (ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const
	Swap a value with a value in a subtree. More...
template<typename stackAllocator >
ValueType &	Swap (GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, ValueType &value) const
	Swap a value with a value in a document. More...

Public Attributes
Allocator *	allocator
Allocator stackAllocator stackAllocator &	document
Allocator stackAllocator stackAllocator T defaultValue	const

Private Member Functions
Ch *	CopyFromRaw (const GenericPointer &rhs, size_t extraToken=0, size_t extraNameBufferSize=0)
	Clone the content from rhs to this. More...
bool	NeedPercentEncode (Ch c) const
	Check whether a character should be percent-encoded. More...
void	Parse (const Ch *source, size_t length)
	Parse a JSON String or its URI fragment representation into tokens. More...
template<bool uriFragment, typename OutputStream >
bool	Stringify (OutputStream &os) const
	Stringify to string or URI fragment representation. More...

Private Attributes
Allocator *	allocator_
	The current allocator. It is either user-supplied or equal to ownAllocator_. More...
Allocator *	ownAllocator_
	Allocator owned by this Pointer. More...
Ch *	nameBuffer_
	A buffer containing all names in tokens. More...
Token *	tokens_
	A list of tokens. More...
size_t	tokenCount_
	Number of tokens in tokens_. More...
size_t	parseErrorOffset_
	Offset in code unit when parsing fail. More...
PointerParseErrorCode	parseErrorCode_
	Parsing error code. More...

Set a value
T	value
T ValueType::AllocatorType &allocator	const
stackAllocator &	document
stackAllocator T value	const
ValueType &	Set (ValueType &root, ValueType &value, typename ValueType::AllocatorType &allocator) const
	Set a value in a subtree, with move semantics. More...
ValueType &	Set (ValueType &root, const ValueType &value, typename ValueType::AllocatorType &allocator) const
	Set a value in a subtree, with copy semantics. More...
ValueType &	Set (ValueType &root, const Ch *value, typename ValueType::AllocatorType &allocator) const
	Set a null-terminated string in a subtree. More...
template<typename T >
	RAPIDJSON_DISABLEIF_RETURN ((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) Set(ValueType &root
	Set a primitive value in a subtree. More...
template<typename stackAllocator >
ValueType &	Set (GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, ValueType &value) const
	Set a value in a document, with move semantics. More...
template<typename stackAllocator >
ValueType &	Set (GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, const ValueType &value) const
	Set a value in a document, with copy semantics. More...
template<typename stackAllocator >
ValueType &	Set (GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &document, const Ch *value) const
	Set a null-terminated string in a document. More...
template<typename T , typename stackAllocator >
	RAPIDJSON_DISABLEIF_RETURN ((internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >),(ValueType &)) Set(GenericDocument< EncodingType
	Set a primitive value in a document. More...

Detailed Description

template<typename ValueType, typename Allocator = CrtAllocator>
class GenericPointer< ValueType, Allocator >

Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator.

This class implements RFC 6901 "JavaScript Object Notation (JSON) Pointer" (https://tools.ietf.org/html/rfc6901).

A JSON pointer is for identifying a specific value in a JSON document (GenericDocument). It can simplify coding of DOM tree manipulation, because it can access multiple-level depth of DOM tree with single API call.

After it parses a string representation (e.g. "/foo/0" or URI fragment representation (e.g. "#/foo/0") into its internal representation (tokens), it can be used to resolve a specific value in multiple documents, or sub-tree of documents.

Contrary to GenericValue, Pointer can be copy constructed and copy assigned. Apart from assignment, a Pointer cannot be modified after construction.

Although Pointer is very convenient, please aware that constructing Pointer involves parsing and dynamic memory allocation. A special constructor with user- supplied tokens eliminates these.

GenericPointer depends on GenericDocument and GenericValue.

Template Parameters

ValueType	The value type of the DOM tree. E.g. GenericValue<UTF8<> >
Allocator	The allocator type for allocating memory for internal representation.

Note

GenericPointer uses same encoding of ValueType. However, Allocator of GenericPointer is independent of Allocator of Value.

Definition at line 126 of file fwd.h.

Member Typedef Documentation

template<typename ValueType, typename Allocator = CrtAllocator>

typedef ValueType::Ch GenericPointer< ValueType, Allocator >::Ch

Character type from Value.

Definition at line 82 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

typedef ValueType::EncodingType GenericPointer< ValueType, Allocator >::EncodingType

Encoding type from Value.

Definition at line 81 of file pointer.h.

Constructor & Destructor Documentation

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::GenericPointer ( Allocator *  allocator = 0 )

inline

Default constructor.

Definition at line 107 of file pointer.h.

: allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::GenericPointer ( const Ch *  source, Allocator *  allocator = 0  )

inlineexplicit

Constructor that parses a string or URI fragment representation.

Parameters

source	A null-terminated, string or URI fragment representation of JSON pointer.
allocator	User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.

Definition at line 114 of file pointer.h.

                                                                        : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        Parse(source, internal::StrLen(source));
    }

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::GenericPointer ( const Ch *  source, size_t  length, Allocator *  allocator = 0  )

inline

Constructor that parses a string or URI fragment representation, with length of the source string.

Parameters

source	A string or URI fragment representation of JSON pointer.
length	Length of source.
allocator	User supplied allocator for this pointer. If no allocator is provided, it creates a self-owned one.

Note

Slightly faster than the overload without length.

Definition at line 137 of file pointer.h.

                                                                              : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        Parse(source, length);
    }

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::GenericPointer ( const Token *  tokens, size_t  tokenCount  )

inline

Constructor with user-supplied tokens.

This constructor let user supplies const array of tokens. This prevents the parsing process and eliminates allocation. This is preferred for memory constrained environments.

Parameters

tokens	An constant array of tokens representing the JSON pointer.
tokenCount	Number of tokens.

Example

#define NAME(s) { s, sizeof(s) / sizeof(s[0]) - 1, kPointerInvalidIndex }
#define INDEX(i) { #i, sizeof(#i) - 1, i }

static const Pointer::Token kTokens[] = { NAME("foo"), INDEX(123) };
static const Pointer p(kTokens, sizeof(kTokens) / sizeof(kTokens[0]));
// Equivalent to static const Pointer p("/foo/123");

#undef NAME
#undef INDEX

Definition at line 163 of file pointer.h.

: allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::GenericPointer ( const GenericPointer< ValueType, Allocator > &  rhs )

inline

Copy constructor.

Definition at line 166 of file pointer.h.

                                              : allocator_(rhs.allocator_), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        *this = rhs;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::GenericPointer ( const GenericPointer< ValueType, Allocator > &  rhs, Allocator *  allocator  )

inline

Copy constructor.

Definition at line 171 of file pointer.h.

                                                                    : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
        *this = rhs;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer< ValueType, Allocator >::~GenericPointer ( )

inline

Destructor.

Definition at line 176 of file pointer.h.

                      {
        if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
            Allocator::Free(tokens_);
        RAPIDJSON_DELETE(ownAllocator_);
    }

Member Function Documentation

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer GenericPointer< ValueType, Allocator >::Append ( const Token &  token, Allocator *  allocator = 0  ) const

inline

Append a token and return a new Pointer.

Parameters

token	Token to be appended.
allocator	Allocator for the newly return Pointer.

Returns

A new Pointer with appended token.

Definition at line 214 of file pointer.h.

                                                                              {
        GenericPointer r;
        r.allocator_ = allocator;
        Ch *p = r.CopyFromRaw(*this, 1, token.length + 1);
        std::memcpy(p, token.name, (token.length + 1) * sizeof(Ch));
        r.tokens_[tokenCount_].name = p;
        r.tokens_[tokenCount_].length = token.length;
        r.tokens_[tokenCount_].index = token.index;
        return r;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer GenericPointer< ValueType, Allocator >::Append ( const Ch *  name, SizeType  length, Allocator *  allocator = 0  ) const

inline

Append a name token with length, and return a new Pointer.

Parameters

name	Name to be appended.
length	Length of name.
allocator	Allocator for the newly return Pointer.

Returns

A new Pointer with appended token.

Definition at line 232 of file pointer.h.

                                                                                           {
        Token token = { name, length, kPointerInvalidIndex };
        return Append(token, allocator);
    }

template<typename ValueType, typename Allocator = CrtAllocator>

Ch* GenericPointer< ValueType, Allocator >::CopyFromRaw ( const GenericPointer< ValueType, Allocator > &  rhs, size_t  extraToken = 0, size_t  extraNameBufferSize = 0  )

inlineprivate

Clone the content from rhs to this.

Parameters

rhs	Source pointer.
extraToken	Extra tokens to be allocated.
extraNameBufferSize	Extra name buffer size (in number of Ch) to be allocated.

Returns

Start of non-occupied name buffer, for storing extra names.

Definition at line 762 of file pointer.h.

                                                                                                      {
        if (!allocator_) // allocator is independently owned.
            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();

        size_t nameBufferSize = rhs.tokenCount_; // null terminators for tokens
        for (Token *t = rhs.tokens_; t != rhs.tokens_ + rhs.tokenCount_; ++t)
            nameBufferSize += t->length;

        tokenCount_ = rhs.tokenCount_ + extraToken;
        tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + (nameBufferSize + extraNameBufferSize) * sizeof(Ch)));
        nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
        if (rhs.tokenCount_ > 0) {
            std::memcpy(tokens_, rhs.tokens_, rhs.tokenCount_ * sizeof(Token));
        }
        if (nameBufferSize > 0) {
            std::memcpy(nameBuffer_, rhs.nameBuffer_, nameBufferSize * sizeof(Ch));
        }

        // Adjust pointers to name buffer
        std::ptrdiff_t diff = nameBuffer_ - rhs.nameBuffer_;
        for (Token *t = tokens_; t != tokens_ + rhs.tokenCount_; ++t)
            t->name += diff;

        return nameBuffer_ + nameBufferSize;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

bool GenericPointer< ValueType, Allocator >::Erase ( ValueType &  root ) const

inline

Erase a value in a subtree.

Parameters

root	Root value of a DOM sub-tree to be resolved. It can be any value other than document root.

Returns

Whether the resolved value is found and erased.

Note

Erasing with an empty pointer Pointer(""), i.e. the root, always fail and return false.

Definition at line 714 of file pointer.h.

                                      {
        RAPIDJSON_ASSERT(IsValid());
        if (tokenCount_ == 0) // Cannot erase the root
            return false;

        ValueType* v = &root;
        const Token* last = tokens_ + (tokenCount_ - 1);
        for (const Token *t = tokens_; t != last; ++t) {
            switch (v->GetType()) {
            case kObjectType:
                {
                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                    if (m == v->MemberEnd())
                        return false;
                    v = &m->value;
                }
                break;
            case kArrayType:
                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
                    return false;
                v = &((*v)[t->index]);
                break;
            default:
                return false;
            }
        }

        switch (v->GetType()) {
        case kObjectType:
            return v->EraseMember(GenericStringRef<Ch>(last->name, last->length));
        case kArrayType:
            if (last->index == kPointerInvalidIndex || last->index >= v->Size())
                return false;
            v->Erase(v->Begin() + last->index);
            return true;
        default:
            return false;
        }
    }

template<typename ValueType, typename Allocator = CrtAllocator>

bool GenericPointer< ValueType, Allocator >::NeedPercentEncode ( Ch  c ) const

inlineprivate

Check whether a character should be percent-encoded.

According to RFC 3986 2.3 Unreserved Characters.

Parameters

c	The character (code unit) to be tested.

Definition at line 793 of file pointer.h.

                                       {
        return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
    }

template<typename ValueType, typename Allocator = CrtAllocator>

GenericPointer& GenericPointer< ValueType, Allocator >::operator= ( const GenericPointer< ValueType, Allocator > &  rhs )

inline

Assignment operator.

Definition at line 183 of file pointer.h.

                                                         {
        if (this != &rhs) {
            // Do not delete ownAllcator
            if (nameBuffer_)
                Allocator::Free(tokens_);

            tokenCount_ = rhs.tokenCount_;
            parseErrorOffset_ = rhs.parseErrorOffset_;
            parseErrorCode_ = rhs.parseErrorCode_;

            if (rhs.nameBuffer_)
                CopyFromRaw(rhs); // Normally parsed tokens.
            else {
                tokens_ = rhs.tokens_; // User supplied const tokens.
                nameBuffer_ = 0;
            }
        }
        return *this;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

void GenericPointer< ValueType, Allocator >::Parse ( const Ch *  source, size_t  length  )

inlineprivate

Parse a JSON String or its URI fragment representation into tokens.

Parameters

source	Either a JSON Pointer string, or its URI fragment representation. Not need to be null terminated.
length	Length of the source string.

Note

Source cannot be JSON String Representation of JSON Pointer, e.g. In "/\u0000", will not be unescaped.

Definition at line 805 of file pointer.h.

                                                {
        RAPIDJSON_ASSERT(source != NULL);
        RAPIDJSON_ASSERT(nameBuffer_ == 0);
        RAPIDJSON_ASSERT(tokens_ == 0);

        // Create own allocator if user did not supply.
        if (!allocator_)
            ownAllocator_ = allocator_ = RAPIDJSON_NEW(Allocator)();

        // Count number of '/' as tokenCount
        tokenCount_ = 0;
        for (const Ch* s = source; s != source + length; s++) 
            if (*s == '/')
                tokenCount_++;

        Token* token = tokens_ = static_cast<Token *>(allocator_->Malloc(tokenCount_ * sizeof(Token) + length * sizeof(Ch)));
        Ch* name = nameBuffer_ = reinterpret_cast<Ch *>(tokens_ + tokenCount_);
        size_t i = 0;

        // Detect if it is a URI fragment
        bool uriFragment = false;
        if (source[i] == '#') {
            uriFragment = true;
            i++;
        }

        if (i != length && source[i] != '/') {
            parseErrorCode_ = kPointerParseErrorTokenMustBeginWithSolidus;
            goto error;
        }

        while (i < length) {
            RAPIDJSON_ASSERT(source[i] == '/');
            i++; // consumes '/'

            token->name = name;
            bool isNumber = true;

            while (i < length && source[i] != '/') {
                Ch c = source[i];
                if (uriFragment) {
                    // Decoding percent-encoding for URI fragment
                    if (c == '%') {
                        PercentDecodeStream is(&source[i], source + length);
                        GenericInsituStringStream<EncodingType> os(name);
                        Ch* begin = os.PutBegin();
                        if (!Transcoder<UTF8<>, EncodingType>().Validate(is, os) || !is.IsValid()) {
                            parseErrorCode_ = kPointerParseErrorInvalidPercentEncoding;
                            goto error;
                        }
                        size_t len = os.PutEnd(begin);
                        i += is.Tell() - 1;
                        if (len == 1)
                            c = *name;
                        else {
                            name += len;
                            isNumber = false;
                            i++;
                            continue;
                        }
                    }
                    else if (NeedPercentEncode(c)) {
                        parseErrorCode_ = kPointerParseErrorCharacterMustPercentEncode;
                        goto error;
                    }
                }

                i++;
                
                // Escaping "~0" -> '~', "~1" -> '/'
                if (c == '~') {
                    if (i < length) {
                        c = source[i];
                        if (c == '0')       c = '~';
                        else if (c == '1')  c = '/';
                        else {
                            parseErrorCode_ = kPointerParseErrorInvalidEscape;
                            goto error;
                        }
                        i++;
                    }
                    else {
                        parseErrorCode_ = kPointerParseErrorInvalidEscape;
                        goto error;
                    }
                }

                // First check for index: all of characters are digit
                if (c < '0' || c > '9')
                    isNumber = false;

                *name++ = c;
            }
            token->length = static_cast<SizeType>(name - token->name);
            if (token->length == 0)
                isNumber = false;
            *name++ = '\0'; // Null terminator

            // Second check for index: more than one digit cannot have leading zero
            if (isNumber && token->length > 1 && token->name[0] == '0')
                isNumber = false;

            // String to SizeType conversion
            SizeType n = 0;
            if (isNumber) {
                for (size_t j = 0; j < token->length; j++) {
                    SizeType m = n * 10 + static_cast<SizeType>(token->name[j] - '0');
                    if (m < n) {   // overflow detection
                        isNumber = false;
                        break;
                    }
                    n = m;
                }
            }

            token->index = isNumber ? n : kPointerInvalidIndex;
            token++;
        }

        RAPIDJSON_ASSERT(name <= nameBuffer_ + length); // Should not overflow buffer
        parseErrorCode_ = kPointerParseErrorNone;
        return;

    error:
        Allocator::Free(tokens_);
        nameBuffer_ = 0;
        tokens_ = 0;
        tokenCount_ = 0;
        parseErrorOffset_ = i;
        return;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename T >

GenericPointer< ValueType, Allocator >::RAPIDJSON_DISABLEIF_RETURN	(	(internal::NotExpr< internal::IsSame< typename internal::RemoveConst< T >::Type, Ch > >)	,
		(GenericPointer< ValueType, Allocator >)
	)

Append a name token without length, and return a new Pointer.

Parameters

name	Name (const Ch*) to be appended.
allocator	Allocator for the newly return Pointer.

Returns

A new Pointer with appended token.

template<typename ValueType, typename Allocator = CrtAllocator>

Allocator stackAllocator GenericPointer< ValueType, Allocator >::RAPIDJSON_DISABLEIF_RETURN	(	(internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >)	,
		(ValueType &)
	)

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename T >

GenericPointer< ValueType, Allocator >::RAPIDJSON_DISABLEIF_RETURN	(	(internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >)	,
		(ValueType &)
	)

Set a primitive value in a subtree.

Template Parameters

T	Either Type, int, unsigned, int64_t, uint64_t, bool

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename T , typename stackAllocator >

GenericPointer< ValueType, Allocator >::RAPIDJSON_DISABLEIF_RETURN	(	(internal::OrExpr< internal::IsPointer< T >, internal::IsGenericValue< T > >)	,
		(ValueType &)
	)

Set a primitive value in a document.

Template Parameters

T	Either Type, int, unsigned, int64_t, uint64_t, bool

template<typename ValueType, typename Allocator = CrtAllocator>

ValueType& GenericPointer< ValueType, Allocator >::Set ( ValueType &  root, ValueType &  value, typename ValueType::AllocatorType &  allocator  ) const

inline

Set a value in a subtree, with move semantics.

It creates all parents if they are not exist or types are different to the tokens. So this function always succeeds but potentially remove existing values.

Parameters

root	Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
value	Value to be set.
allocator	Allocator for creating the values if the specified value or its parents are not exist.

See also

Create()

Definition at line 613 of file pointer.h.

                                                                                                        {
        return Create(root, allocator) = value;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

ValueType& GenericPointer< ValueType, Allocator >::Set ( ValueType &  root, const ValueType &  value, typename ValueType::AllocatorType &  allocator  ) const

inline

Set a value in a subtree, with copy semantics.

Definition at line 618 of file pointer.h.

                                                                                                              {
        return Create(root, allocator).CopyFrom(value, allocator);
    }

template<typename ValueType, typename Allocator = CrtAllocator>

ValueType& GenericPointer< ValueType, Allocator >::Set ( ValueType &  root, const Ch *  value, typename ValueType::AllocatorType &  allocator  ) const

inline

Set a null-terminated string in a subtree.

Definition at line 623 of file pointer.h.

                                                                                                       {
        return Create(root, allocator) = ValueType(value, allocator).Move();
    }

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename stackAllocator >

ValueType& GenericPointer< ValueType, Allocator >::Set ( GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &  document, ValueType &  value  ) const

inline

Set a value in a document, with move semantics.

Definition at line 646 of file pointer.h.

                                                                                                                                     {
        return Create(document) = value;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename stackAllocator >

ValueType& GenericPointer< ValueType, Allocator >::Set ( GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &  document, const ValueType &  value  ) const

inline

Set a value in a document, with copy semantics.

Definition at line 652 of file pointer.h.

                                                                                                                                           {
        return Create(document).CopyFrom(value, document.GetAllocator());
    }

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename stackAllocator >

ValueType& GenericPointer< ValueType, Allocator >::Set ( GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &  document, const Ch *  value  ) const

inline

Set a null-terminated string in a document.

Definition at line 658 of file pointer.h.

                                                                                                                                    {
        return Create(document) = ValueType(value, document.GetAllocator()).Move();
    }

template<typename ValueType, typename Allocator = CrtAllocator>

template<bool uriFragment, typename OutputStream >

bool GenericPointer< ValueType, Allocator >::Stringify ( OutputStream &  os ) const

inlineprivate

Stringify to string or URI fragment representation.

Template Parameters

uriFragment	True for stringifying to URI fragment representation. False for string representation.
OutputStream	type of output stream.

Parameters

os	The output stream.

Definition at line 944 of file pointer.h.

                                           {
        RAPIDJSON_ASSERT(IsValid());

        if (uriFragment)
            os.Put('#');

        for (Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
            os.Put('/');
            for (size_t j = 0; j < t->length; j++) {
                Ch c = t->name[j];
                if (c == '~') {
                    os.Put('~');
                    os.Put('0');
                }
                else if (c == '/') {
                    os.Put('~');
                    os.Put('1');
                }
                else if (uriFragment && NeedPercentEncode(c)) { 
                    // Transcode to UTF8 sequence
                    GenericStringStream<typename ValueType::EncodingType> source(&t->name[j]);
                    PercentEncodeStream<OutputStream> target(os);
                    if (!Transcoder<EncodingType, UTF8<> >().Validate(source, target))
                        return false;
                    j += source.Tell() - 1;
                }
                else
                    os.Put(c);
            }
        }
        return true;
    }

template<typename ValueType, typename Allocator = CrtAllocator>

ValueType& GenericPointer< ValueType, Allocator >::Swap ( ValueType &  root, ValueType &  value, typename ValueType::AllocatorType &  allocator  ) const

inline

Swap a value with a value in a subtree.

It creates all parents if they are not exist or types are different to the tokens. So this function always succeeds but potentially remove existing values.

Parameters

root	Root value of a DOM sub-tree to be resolved. It can be any value other than document root.
value	Value to be swapped.
allocator	Allocator for creating the values if the specified value or its parents are not exist.

See also

Create()

Definition at line 695 of file pointer.h.

                                                                                                         {
        return Create(root, allocator).Swap(value);
    }

template<typename ValueType, typename Allocator = CrtAllocator>

template<typename stackAllocator >

ValueType& GenericPointer< ValueType, Allocator >::Swap ( GenericDocument< EncodingType, typename ValueType::AllocatorType, stackAllocator > &  document, ValueType &  value  ) const

inline

Swap a value with a value in a document.

Definition at line 701 of file pointer.h.

                                                                                                                                      {
        return Create(document).Swap(value);
    }

Member Data Documentation

template<typename ValueType, typename Allocator = CrtAllocator>

Allocator* GenericPointer< ValueType, Allocator >::allocator

Definition at line 245 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

Allocator* GenericPointer< ValueType, Allocator >::allocator_

private

The current allocator. It is either user-supplied or equal to ownAllocator_.

Definition at line 1042 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

Allocator stackAllocator stackAllocator T defaultValue GenericPointer< ValueType, Allocator >::const

Initial value:

{
        return GetWithDefault(document, defaultValue, document.GetAllocator())

Definition at line 594 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

T ValueType::AllocatorType& allocator GenericPointer< ValueType, Allocator >::const

Initial value:

{
        return Create(root, allocator) = ValueType(value).Move()

Definition at line 640 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

stackAllocator T value GenericPointer< ValueType, Allocator >::const

Initial value:

{
            return Create(document) = value

Definition at line 676 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

Allocator stackAllocator stackAllocator& GenericPointer< ValueType, Allocator >::document

Definition at line 594 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

stackAllocator& GenericPointer< ValueType, Allocator >::document

Definition at line 676 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

Ch* GenericPointer< ValueType, Allocator >::nameBuffer_

private

A buffer containing all names in tokens.

Definition at line 1044 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

Allocator* GenericPointer< ValueType, Allocator >::ownAllocator_

private

Allocator owned by this Pointer.

Definition at line 1043 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

PointerParseErrorCode GenericPointer< ValueType, Allocator >::parseErrorCode_

private

Parsing error code.

Definition at line 1048 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

size_t GenericPointer< ValueType, Allocator >::parseErrorOffset_

private

Offset in code unit when parsing fail.

Definition at line 1047 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

size_t GenericPointer< ValueType, Allocator >::tokenCount_

private

Number of tokens in tokens_.

Definition at line 1046 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

Token* GenericPointer< ValueType, Allocator >::tokens_

private

A list of tokens.

Definition at line 1045 of file pointer.h.

template<typename ValueType, typename Allocator = CrtAllocator>

T GenericPointer< ValueType, Allocator >::value

Definition at line 640 of file pointer.h.

---

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

• art/rapidjson/fwd.h
• art/rapidjson/pointer.h