GenericPointer< ValueType, Allocator > Class Template Reference

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

#include <pointer.h>

Collaboration diagram for GenericPointer< ValueType, Allocator >:

Classes
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.
typedef ValueType::Ch	Ch
	Character type from Value.

Append token
Allocator *	allocator
Allocator *	allocator_
	The current allocator. It is either user-supplied or equal to ownAllocator_.
Allocator *	ownAllocator_
	Allocator owned by this Pointer.
Ch *	nameBuffer_
	A buffer containing all names in tokens.
Token *	tokens_
	A list of tokens.
size_t	tokenCount_
	Number of tokens in tokens_.
size_t	parseErrorOffset_
	Offset in code unit when parsing fail.
PointerParseErrorCode	parseErrorCode_
	Parsing error code.
GenericPointer	Append (const Token &token, Allocator *allocator=0) const
	Append a token and return a new Pointer.
GenericPointer	Append (const Ch *name, SizeType length, Allocator *allocator=0) const
	Append a name token with length, and return a new Pointer.
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.

Constructors and destructor.
	GenericPointer (Allocator *allocator=0)
	Default constructor.
	GenericPointer (const Ch *source, Allocator *allocator=0)
	Constructor that parses a string or URI fragment representation.
	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.
	GenericPointer (const Token *tokens, size_t tokenCount)
	Constructor with user-supplied tokens.
	GenericPointer (const GenericPointer &rhs)
	Copy constructor.
	GenericPointer (const GenericPointer &rhs, Allocator *allocator)
	Copy constructor.
	~GenericPointer ()
	Destructor.
GenericPointer &	operator= (const GenericPointer &rhs)
	Assignment operator.
GenericPointer &	Swap (GenericPointer &other) RAPIDJSON_NOEXCEPT
	Swap the content of this pointer with an other.
void	swap (GenericPointer &a, GenericPointer &b) RAPIDJSON_NOEXCEPT
	free-standing swap function helper

Detailed Description

template<typename ValueType, typename Allocator = CrtAllocator>
class GenericPointer< ValueType, 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 79 of file pointer.h.

Member Typedef Documentation

Ch

template<typename ValueType , typename Allocator = CrtAllocator>

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

Definition at line 82 of file pointer.h.

EncodingType

template<typename ValueType , typename Allocator = CrtAllocator>

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

Definition at line 81 of file pointer.h.

Constructor & Destructor Documentation

GenericPointer() [1/6]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

Definition at line 107 of file pointer.h.

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

GenericPointer() [2/6]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inlineexplicit

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

Here is the call graph for this function:

GenericPointer() [3/6]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

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

GenericPointer() [4/6]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

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) {}

GenericPointer() [5/6]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

Definition at line 166 of file pointer.h.

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

GenericPointer() [6/6]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

Definition at line 171 of file pointer.h.

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

~GenericPointer()

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

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

Append() [1/2]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

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 262 of file pointer.h.

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

Here is the call graph for this function:

Append() [2/2]

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

Parameters

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

Returns

A new Pointer with appended token.

Definition at line 244 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;
    }

Here is the caller graph for this function:

operator=()

template<typename ValueType , typename Allocator = CrtAllocator>

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

inline

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

RAPIDJSON_DISABLEIF_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 >)	)

Parameters

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

Returns

A new Pointer with appended token.

Swap()

template<typename ValueType , typename Allocator = CrtAllocator>

GenericPointer & GenericPointer< ValueType, Allocator >::Swap ( GenericPointer< ValueType, Allocator > & other )

inline

Parameters

other

The pointer to swap with.

Note

Constant complexity.

Definition at line 208 of file pointer.h.

                                                                   {
        internal::Swap(allocator_, other.allocator_);
        internal::Swap(ownAllocator_, other.ownAllocator_);
        internal::Swap(nameBuffer_, other.nameBuffer_);
        internal::Swap(tokens_, other.tokens_);
        internal::Swap(tokenCount_, other.tokenCount_);
        internal::Swap(parseErrorOffset_, other.parseErrorOffset_);
        internal::Swap(parseErrorCode_, other.parseErrorCode_);
        return *this;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

swap

template<typename ValueType , typename Allocator = CrtAllocator>

void swap ( GenericPointer< ValueType, Allocator > & a, GenericPointer< ValueType, Allocator > & b )

friend

Helper function to enable support for common swap implementation pattern based on std::swap:

void swap(MyClass& a, MyClass& b) {
    using std::swap;
    swap(a.pointer, b.pointer);
    // ...
}

See also

Swap()

Definition at line 231 of file pointer.h.

{ a.Swap(b); }

Member Data Documentation

allocator

template<typename ValueType , typename Allocator = CrtAllocator>

Allocator* GenericPointer< ValueType, Allocator >::allocator

Definition at line 275 of file pointer.h.

                                                    {
        return Append(name, internal::StrLen(name), allocator);
    }
 
#if RAPIDJSON_HAS_STDSTRING
 
    GenericPointer Append(const std::basic_string<Ch>& name, Allocator* allocator = 0) const {
        return Append(name.c_str(), static_cast<SizeType>(name.size()), allocator);
    }
#endif
 
 
    GenericPointer Append(SizeType index, Allocator* allocator = 0) const {
        char buffer[21];
        char* end = sizeof(SizeType) == 4 ? internal::u32toa(index, buffer) : internal::u64toa(index, buffer);
        SizeType length = static_cast<SizeType>(end - buffer);
        buffer[length] = '\0';
 
        if (sizeof(Ch) == 1) {
            Token token = { reinterpret_cast<Ch*>(buffer), length, index };
            return Append(token, allocator);
        }
        else {
            Ch name[21];
            for (size_t i = 0; i <= length; i++)
                name[i] = static_cast<Ch>(buffer[i]);
            Token token = { name, length, index };
            return Append(token, allocator);
        }
    }
 
 
    GenericPointer Append(const ValueType& token, Allocator* allocator = 0) const {
        if (token.IsString())
            return Append(token.GetString(), token.GetStringLength(), allocator);
        else {
            RAPIDJSON_ASSERT(token.IsUint64());
            RAPIDJSON_ASSERT(token.GetUint64() <= SizeType(~0));
            return Append(static_cast<SizeType>(token.GetUint64()), allocator);
        }
    }
 
 
 
    bool IsValid() const { return parseErrorCode_ == kPointerParseErrorNone; }
 
    size_t GetParseErrorOffset() const { return parseErrorOffset_; }
 
    PointerParseErrorCode GetParseErrorCode() const { return parseErrorCode_; }
 
 
    Allocator& GetAllocator() { return *allocator_; }
 
 
 
    const Token* GetTokens() const { return tokens_; }
 
    size_t GetTokenCount() const { return tokenCount_; }
 
 
 
 
 
    bool operator==(const GenericPointer& rhs) const {
        if (!IsValid() || !rhs.IsValid() || tokenCount_ != rhs.tokenCount_)
            return false;
 
        for (size_t i = 0; i < tokenCount_; i++) {
            if (tokens_[i].index != rhs.tokens_[i].index ||
                tokens_[i].length != rhs.tokens_[i].length || 
                (tokens_[i].length != 0 && std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch)* tokens_[i].length) != 0))
            {
                return false;
            }
        }
 
        return true;
    }
 
 
    bool operator!=(const GenericPointer& rhs) const { return !(*this == rhs); }
 
 
    bool operator<(const GenericPointer& rhs) const {
        if (!IsValid())
            return false;
        if (!rhs.IsValid())
            return true;
 
        if (tokenCount_ != rhs.tokenCount_)
            return tokenCount_ < rhs.tokenCount_;
 
        for (size_t i = 0; i < tokenCount_; i++) {
            if (tokens_[i].index != rhs.tokens_[i].index)
                return tokens_[i].index < rhs.tokens_[i].index;
 
            if (tokens_[i].length != rhs.tokens_[i].length)
                return tokens_[i].length < rhs.tokens_[i].length;
 
            if (int cmp = std::memcmp(tokens_[i].name, rhs.tokens_[i].name, sizeof(Ch) * tokens_[i].length))
                return cmp < 0;
        }
 
        return false;
    }
 
 
 
 
 
    template<typename OutputStream>
    bool Stringify(OutputStream& os) const {
        return Stringify<false, OutputStream>(os);
    }
 
 
    template<typename OutputStream>
    bool StringifyUriFragment(OutputStream& os) const {
        return Stringify<true, OutputStream>(os);
    }
 
 
 
 
 
    ValueType& Create(ValueType& root, typename ValueType::AllocatorType& allocator, bool* alreadyExist = 0) const {
        RAPIDJSON_ASSERT(IsValid());
        ValueType* v = &root;
        bool exist = true;
        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
            if (v->IsArray() && t->name[0] == '-' && t->length == 1) {
                v->PushBack(ValueType().Move(), allocator);
                v = &((*v)[v->Size() - 1]);
                exist = false;
            }
            else {
                if (t->index == kPointerInvalidIndex) { // must be object name
                    if (!v->IsObject())
                        v->SetObject(); // Change to Object
                }
                else { // object name or array index
                    if (!v->IsArray() && !v->IsObject())
                        v->SetArray(); // Change to Array
                }
 
                if (v->IsArray()) {
                    if (t->index >= v->Size()) {
                        v->Reserve(t->index + 1, allocator);
                        while (t->index >= v->Size())
                            v->PushBack(ValueType().Move(), allocator);
                        exist = false;
                    }
                    v = &((*v)[t->index]);
                }
                else {
                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                    if (m == v->MemberEnd()) {
                        v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
                        v = &(--v->MemberEnd())->value; // Assumes AddMember() appends at the end
                        exist = false;
                    }
                    else
                        v = &m->value;
                }
            }
        }
 
        if (alreadyExist)
            *alreadyExist = exist;
 
        return *v;
    }
 
 
    template <typename stackAllocator>
    ValueType& Create(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, bool* alreadyExist = 0) const {
        return Create(document, document.GetAllocator(), alreadyExist);
    }
 
 
 
 
 
    ValueType* Get(ValueType& root, size_t* unresolvedTokenIndex = 0) const {
        RAPIDJSON_ASSERT(IsValid());
        ValueType* v = &root;
        for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
            switch (v->GetType()) {
            case kObjectType:
                {
                    typename ValueType::MemberIterator m = v->FindMember(GenericStringRef<Ch>(t->name, t->length));
                    if (m == v->MemberEnd())
                        break;
                    v = &m->value;
                }
                continue;
            case kArrayType:
                if (t->index == kPointerInvalidIndex || t->index >= v->Size())
                    break;
                v = &((*v)[t->index]);
                continue;
            default:
                break;
            }
 
            // Error: unresolved token
            if (unresolvedTokenIndex)
                *unresolvedTokenIndex = static_cast<size_t>(t - tokens_);
            return 0;
        }
        return v;
    }
 
 
    const ValueType* Get(const ValueType& root, size_t* unresolvedTokenIndex = 0) const { 
        return Get(const_cast<ValueType&>(root), unresolvedTokenIndex);
    }
 
 
 
 
 
    ValueType& GetWithDefault(ValueType& root, const ValueType& defaultValue, typename ValueType::AllocatorType& allocator) const {
        bool alreadyExist;
        ValueType& v = Create(root, allocator, &alreadyExist);
        return alreadyExist ? v : v.CopyFrom(defaultValue, allocator);
    }
 
    ValueType& GetWithDefault(ValueType& root, const Ch* defaultValue, typename ValueType::AllocatorType& allocator) const {
        bool alreadyExist;
        ValueType& v = Create(root, allocator, &alreadyExist);
        return alreadyExist ? v : v.SetString(defaultValue, allocator);
    }
 
#if RAPIDJSON_HAS_STDSTRING
    ValueType& GetWithDefault(ValueType& root, const std::basic_string<Ch>& defaultValue, typename ValueType::AllocatorType& allocator) const {
        bool alreadyExist;
        ValueType& v = Create(root, allocator, &alreadyExist);
        return alreadyExist ? v : v.SetString(defaultValue, allocator);
    }
#endif
 
 
    template <typename T>
    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
    GetWithDefault(ValueType& root, T defaultValue, typename ValueType::AllocatorType& allocator) const {
        return GetWithDefault(root, ValueType(defaultValue).Move(), allocator);
    }
 
    template <typename stackAllocator>
    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }
 
    template <typename stackAllocator>
    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }
    
#if RAPIDJSON_HAS_STDSTRING
    template <typename stackAllocator>
    ValueType& GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }
#endif
 
 
    template <typename T, typename stackAllocator>
    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
    GetWithDefault(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T defaultValue) const {
        return GetWithDefault(document, defaultValue, document.GetAllocator());
    }
 
 
 
 
 
    ValueType& Set(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = value;
    }
 
    ValueType& Set(ValueType& root, const ValueType& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator).CopyFrom(value, allocator);
    }
 
    ValueType& Set(ValueType& root, const Ch* value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = ValueType(value, allocator).Move();
    }
 
#if RAPIDJSON_HAS_STDSTRING
    ValueType& Set(ValueType& root, const std::basic_string<Ch>& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = ValueType(value, allocator).Move();
    }
#endif
 
 
    template <typename T>
    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
    Set(ValueType& root, T value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator) = ValueType(value).Move();
    }
 
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
        return Create(document) = value;
    }
 
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const ValueType& value) const {
        return Create(document).CopyFrom(value, document.GetAllocator());
    }
 
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const Ch* value) const {
        return Create(document) = ValueType(value, document.GetAllocator()).Move();
    }
 
#if RAPIDJSON_HAS_STDSTRING
    template <typename stackAllocator>
    ValueType& Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, const std::basic_string<Ch>& value) const {
        return Create(document) = ValueType(value, document.GetAllocator()).Move();
    }
#endif
 
 
    template <typename T, typename stackAllocator>
    RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T>, internal::IsGenericValue<T> >), (ValueType&))
        Set(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, T value) const {
            return Create(document) = value;
    }
 
 
 
 
 
    ValueType& Swap(ValueType& root, ValueType& value, typename ValueType::AllocatorType& allocator) const {
        return Create(root, allocator).Swap(value);
    }
 
    template <typename stackAllocator>
    ValueType& Swap(GenericDocument<EncodingType, typename ValueType::AllocatorType, stackAllocator>& document, ValueType& value) const {
        return Create(document).Swap(value);
    }
 
 
 
    bool Erase(ValueType& root) const {
        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;
        }
    }
 
private:
 
    Ch* CopyFromRaw(const GenericPointer& rhs, size_t extraToken = 0, size_t extraNameBufferSize = 0) {
        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;
    }
 
 
    bool NeedPercentEncode(Ch c) const {
        return !((c >= '0' && c <= '9') || (c >= 'A' && c <='Z') || (c >= 'a' && c <= 'z') || c == '-' || c == '.' || c == '_' || c =='~');
    }
 
#ifndef __clang__ // -Wdocumentation
#endif
    void Parse(const Ch* source, size_t length) {
        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<bool uriFragment, typename OutputStream>
    bool Stringify(OutputStream& os) const {
        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;
    }
 
 
    class PercentDecodeStream {
    public:
        typedef typename ValueType::Ch Ch;
 
 
        PercentDecodeStream(const Ch* source, const Ch* end) : src_(source), head_(source), end_(end), valid_(true) {}
 
        Ch Take() {
            if (*src_ != '%' || src_ + 3 > end_) { // %XY triplet
                valid_ = false;
                return 0;
            }
            src_++;
            Ch c = 0;
            for (int j = 0; j < 2; j++) {
                c = static_cast<Ch>(c << 4);
                Ch h = *src_;
                if      (h >= '0' && h <= '9') c = static_cast<Ch>(c + h - '0');
                else if (h >= 'A' && h <= 'F') c = static_cast<Ch>(c + h - 'A' + 10);
                else if (h >= 'a' && h <= 'f') c = static_cast<Ch>(c + h - 'a' + 10);
                else {
                    valid_ = false;
                    return 0;
                }
                src_++;
            }
            return c;
        }
 
        size_t Tell() const { return static_cast<size_t>(src_ - head_); }
        bool IsValid() const { return valid_; }
 
    private:
        const Ch* src_;     
        const Ch* head_;    
        const Ch* end_;     
        bool valid_;        
    };

allocator_

template<typename ValueType , typename Allocator = CrtAllocator>

Allocator* GenericPointer< ValueType, Allocator >::allocator_

Definition at line 1099 of file pointer.h.

nameBuffer_

template<typename ValueType , typename Allocator = CrtAllocator>

Ch* GenericPointer< ValueType, Allocator >::nameBuffer_

Definition at line 1101 of file pointer.h.

ownAllocator_

template<typename ValueType , typename Allocator = CrtAllocator>

Allocator* GenericPointer< ValueType, Allocator >::ownAllocator_

Definition at line 1100 of file pointer.h.

parseErrorCode_

template<typename ValueType , typename Allocator = CrtAllocator>

PointerParseErrorCode GenericPointer< ValueType, Allocator >::parseErrorCode_

Definition at line 1105 of file pointer.h.

parseErrorOffset_

template<typename ValueType , typename Allocator = CrtAllocator>

size_t GenericPointer< ValueType, Allocator >::parseErrorOffset_

Definition at line 1104 of file pointer.h.

tokenCount_

template<typename ValueType , typename Allocator = CrtAllocator>

size_t GenericPointer< ValueType, Allocator >::tokenCount_

Definition at line 1103 of file pointer.h.

tokens_

template<typename ValueType , typename Allocator = CrtAllocator>

Token* GenericPointer< ValueType, Allocator >::tokens_

Definition at line 1102 of file pointer.h.

---

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

• libraries/fc/include/fc/crypto/webauthn_json/include/rapidjson/fwd.h
• libraries/fc/include/fc/crypto/webauthn_json/include/rapidjson/pointer.h