/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/pointer.h Source File

/home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/pointer.h Source File#

Composable Kernel: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-composable-kernel/checkouts/develop/include/rapidjson/pointer.h Source File
Go to the documentation of this file.
 // Tencent is pleased to support the open source community by making RapidJSON available.
 // 
 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
 //
 // Licensed under the MIT License (the "License"); you may not use this file except
 // in compliance with the License. You may obtain a copy of the License at
 //
 // http://opensource.org/licenses/MIT
 //
 // Unless required by applicable law or agreed to in writing, software distributed 
 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 
 // CONDITIONS OF ANY KIND, either express or implied. See the License for the 
 // specific language governing permissions and limitations under the License.
  
 #ifndef RAPIDJSON_POINTER_H_
 #define RAPIDJSON_POINTER_H_
  
 #include "document.h"
 #include "uri.h"
 #include "internal/itoa.h"
 #include "error/error.h" // PointerParseErrorCode
  
 #ifdef __clang__
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(switch-enum)
 #elif defined(_MSC_VER)
 RAPIDJSON_DIAG_PUSH
 RAPIDJSON_DIAG_OFF(4512) // assignment operator could not be generated
 #endif
  
 #if defined(RAPIDJSON_CPLUSPLUS) && RAPIDJSON_CPLUSPLUS >= 201703L
 #define RAPIDJSON_IF_CONSTEXPR if constexpr
 #else
 #define RAPIDJSON_IF_CONSTEXPR if
 #endif
  
 RAPIDJSON_NAMESPACE_BEGIN
  
 static const SizeType kPointerInvalidIndex = ~SizeType(0);  
  
 // GenericPointer
  
  
 template <typename ValueType, typename Allocator = CrtAllocator>
 class GenericPointer {
 public:
     typedef typename ValueType::EncodingType EncodingType;  
     typedef typename ValueType::Ch Ch;                      
     typedef GenericUri<ValueType, Allocator> UriType;
  
  
  
     struct Token {
         const Ch* name;             
         SizeType length;            
         SizeType index;             
     };
  
  
  
     GenericPointer(Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
  
  
     explicit GenericPointer(const Ch* source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
         Parse(source, internal::StrLen(source));
     }
  
 #if RAPIDJSON_HAS_STDSTRING
  
     explicit GenericPointer(const std::basic_string<Ch>& source, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
         Parse(source.c_str(), source.size());
     }
 #endif
  
  
     GenericPointer(const Ch* source, size_t length, Allocator* allocator = 0) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
         Parse(source, length);
     }
  
  
     GenericPointer(const Token* tokens, size_t tokenCount) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(const_cast<Token*>(tokens)), tokenCount_(tokenCount), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {}
  
     GenericPointer(const GenericPointer& rhs) : allocator_(), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
         *this = rhs;
     }
  
     GenericPointer(const GenericPointer& rhs, Allocator* allocator) : allocator_(allocator), ownAllocator_(), nameBuffer_(), tokens_(), tokenCount_(), parseErrorOffset_(), parseErrorCode_(kPointerParseErrorNone) {
         *this = rhs;
     }
  
     ~GenericPointer() {
         if (nameBuffer_)    // If user-supplied tokens constructor is used, nameBuffer_ is nullptr and tokens_ are not deallocated.
             Allocator::Free(tokens_);
         RAPIDJSON_DELETE(ownAllocator_);
     }
  
     GenericPointer& operator=(const GenericPointer& rhs) {
         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;
     }
  
  
     GenericPointer& Swap(GenericPointer& other) RAPIDJSON_NOEXCEPT {
         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;
     }
  
  
     friend inline void swap(GenericPointer& a, GenericPointer& b) RAPIDJSON_NOEXCEPT { a.Swap(b); }
  
  
  
  
  
     GenericPointer Append(const Token& token, Allocator* allocator = 0) const {
         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;
     }
  
  
     GenericPointer Append(const Ch* name, SizeType length, Allocator* allocator = 0) const {
         Token token = { name, length, kPointerInvalidIndex };
         return Append(token, allocator);
     }
  
  
     template <typename T>
     RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >), (GenericPointer))
     Append(T* name, Allocator* allocator = 0) const {
         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';
  
         RAPIDJSON_IF_CONSTEXPR (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(GenericValue<EncodingType>(GenericStringRef<Ch>(t->name, t->length)));
                     if (m == v->MemberEnd()) {
                         v->AddMember(ValueType(t->name, t->length, allocator).Move(), ValueType().Move(), allocator);
                         m = v->MemberEnd();
                         v = &(--m)->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);
     }
  
  
  
  
     //  For use with JSON pointers into JSON schema documents.
     UriType GetUri(ValueType& root, const UriType& rootUri, size_t* unresolvedTokenIndex = 0, Allocator* allocator = 0) const {
         static const Ch kIdString[] = { 'i', 'd', '\0' };
         static const ValueType kIdValue(kIdString, 2);
         UriType base = UriType(rootUri, allocator);
         RAPIDJSON_ASSERT(IsValid());
         ValueType* v = &root;
         for (const Token *t = tokens_; t != tokens_ + tokenCount_; ++t) {
             switch (v->GetType()) {
                 case kObjectType:
                 {
                     // See if we have an id, and if so resolve with the current base
                     typename ValueType::MemberIterator m = v->FindMember(kIdValue);
                     if (m != v->MemberEnd() && (m->value).IsString()) {
                         UriType here = UriType(m->value, allocator).Resolve(base, allocator);
                         base = here;
                     }
                     m = v->FindMember(GenericValue<EncodingType>(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 UriType(allocator);
         }
         return base;
     }
  
     UriType GetUri(const ValueType& root, const UriType& rootUri, size_t* unresolvedTokenIndex = 0, Allocator* allocator = 0) const {
       return GetUri(const_cast<ValueType&>(root), rootUri, unresolvedTokenIndex, allocator);
     }
  
  
  
  
  
     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(GenericValue<EncodingType>(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(GenericValue<EncodingType>(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));
         }
  
         // The names of each token point to a string in the nameBuffer_. The
         // previous memcpy copied over string pointers into the rhs.nameBuffer_,
         // but they should point to the strings in the new nameBuffer_.
         for (size_t i = 0; i < rhs.tokenCount_; ++i) {
           // The offset between the string address and the name buffer should
           // still be constant, so we can just get this offset and set each new
           // token name according the new buffer start + the known offset.
           std::ptrdiff_t name_offset = rhs.tokens_[i].name - rhs.nameBuffer_;
           tokens_[i].name = nameBuffer_ + name_offset;
         }
  
         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_;        
     };
  
     template <typename OutputStream>
     class PercentEncodeStream {
     public:
         PercentEncodeStream(OutputStream& os) : os_(os) {}
         void Put(char c) { // UTF-8 must be byte
             unsigned char u = static_cast<unsigned char>(c);
             static const char hexDigits[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
             os_.Put('%');
             os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u >> 4]));
             os_.Put(static_cast<typename OutputStream::Ch>(hexDigits[u & 15]));
         }
     private:
         OutputStream& os_;
     };
  
     Allocator* allocator_;                  
     Allocator* ownAllocator_;               
     Ch* nameBuffer_;                        
     Token* tokens_;                         
     size_t tokenCount_;                     
     size_t parseErrorOffset_;               
     PointerParseErrorCode parseErrorCode_;  
 };
  
 typedef GenericPointer<Value> Pointer;
  
  
  
  
 template <typename T>
 typename T::ValueType& CreateValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::AllocatorType& a) {
     return pointer.Create(root, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& CreateValueByPointer(T& root, const CharType(&source)[N], typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Create(root, a);
 }
  
 // No allocator parameter
  
 template <typename DocumentType>
 typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer) {
     return pointer.Create(document);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& CreateValueByPointer(DocumentType& document, const CharType(&source)[N]) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Create(document);
 }
  
  
 template <typename T>
 typename T::ValueType* GetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
     return pointer.Get(root, unresolvedTokenIndex);
 }
  
 template <typename T>
 const typename T::ValueType* GetValueByPointer(const T& root, const GenericPointer<typename T::ValueType>& pointer, size_t* unresolvedTokenIndex = 0) {
     return pointer.Get(root, unresolvedTokenIndex);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType* GetValueByPointer(T& root, const CharType (&source)[N], size_t* unresolvedTokenIndex = 0) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
 }
  
 template <typename T, typename CharType, size_t N>
 const typename T::ValueType* GetValueByPointer(const T& root, const CharType(&source)[N], size_t* unresolvedTokenIndex = 0) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Get(root, unresolvedTokenIndex);
 }
  
  
 template <typename T>
 typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
     return pointer.GetWithDefault(root, defaultValue, a);
 }
  
 template <typename T>
 typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
     return pointer.GetWithDefault(root, defaultValue, a);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename T>
 typename T::ValueType& GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
     return pointer.GetWithDefault(root, defaultValue, a);
 }
 #endif
  
 template <typename T, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
 GetValueByPointerWithDefault(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 defaultValue, typename T::AllocatorType& a) {
     return pointer.GetWithDefault(root, defaultValue, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::ValueType& defaultValue, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const typename T::Ch* defaultValue, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& GetValueByPointerWithDefault(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& defaultValue, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
 }
 #endif
  
 template <typename T, typename CharType, size_t N, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
 GetValueByPointerWithDefault(T& root, const CharType(&source)[N], T2 defaultValue, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).GetWithDefault(root, defaultValue, a);
 }
  
 // No allocator parameter
  
 template <typename DocumentType>
 typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& defaultValue) {
     return pointer.GetWithDefault(document, defaultValue);
 }
  
 template <typename DocumentType>
 typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* defaultValue) {
     return pointer.GetWithDefault(document, defaultValue);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename DocumentType>
 typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& defaultValue) {
     return pointer.GetWithDefault(document, defaultValue);
 }
 #endif
  
 template <typename DocumentType, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
 GetValueByPointerWithDefault(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 defaultValue) {
     return pointer.GetWithDefault(document, defaultValue);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& defaultValue) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* defaultValue) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& defaultValue) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
 }
 #endif
  
 template <typename DocumentType, typename CharType, size_t N, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
 GetValueByPointerWithDefault(DocumentType& document, const CharType(&source)[N], T2 defaultValue) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).GetWithDefault(document, defaultValue);
 }
  
  
 template <typename T>
 typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
     return pointer.Set(root, value, a);
 }
  
 template <typename T>
 typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::ValueType& value, typename T::AllocatorType& a) {
     return pointer.Set(root, value, a);
 }
  
 template <typename T>
 typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const typename T::Ch* value, typename T::AllocatorType& a) {
     return pointer.Set(root, value, a);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename T>
 typename T::ValueType& SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
     return pointer.Set(root, value, a);
 }
 #endif
  
 template <typename T, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
 SetValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, T2 value, typename T::AllocatorType& a) {
     return pointer.Set(root, value, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::ValueType& value, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const typename T::Ch* value, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& SetValueByPointer(T& root, const CharType(&source)[N], const std::basic_string<typename T::Ch>& value, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
 }
 #endif
  
 template <typename T, typename CharType, size_t N, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename T::ValueType&))
 SetValueByPointer(T& root, const CharType(&source)[N], T2 value, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Set(root, value, a);
 }
  
 // No allocator parameter
  
 template <typename DocumentType>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
     return pointer.Set(document, value);
 }
  
 template <typename DocumentType>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::ValueType& value) {
     return pointer.Set(document, value);
 }
  
 template <typename DocumentType>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const typename DocumentType::Ch* value) {
     return pointer.Set(document, value);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename DocumentType>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, const std::basic_string<typename DocumentType::Ch>& value) {
     return pointer.Set(document, value);
 }
 #endif
  
 template <typename DocumentType, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
 SetValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, T2 value) {
     return pointer.Set(document, value);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::ValueType& value) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const typename DocumentType::Ch* value) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
 }
  
 #if RAPIDJSON_HAS_STDSTRING
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& SetValueByPointer(DocumentType& document, const CharType(&source)[N], const std::basic_string<typename DocumentType::Ch>& value) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
 }
 #endif
  
 template <typename DocumentType, typename CharType, size_t N, typename T2>
 RAPIDJSON_DISABLEIF_RETURN((internal::OrExpr<internal::IsPointer<T2>, internal::IsGenericValue<T2> >), (typename DocumentType::ValueType&))
 SetValueByPointer(DocumentType& document, const CharType(&source)[N], T2 value) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Set(document, value);
 }
  
  
 template <typename T>
 typename T::ValueType& SwapValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer, typename T::ValueType& value, typename T::AllocatorType& a) {
     return pointer.Swap(root, value, a);
 }
  
 template <typename T, typename CharType, size_t N>
 typename T::ValueType& SwapValueByPointer(T& root, const CharType(&source)[N], typename T::ValueType& value, typename T::AllocatorType& a) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Swap(root, value, a);
 }
  
 template <typename DocumentType>
 typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const GenericPointer<typename DocumentType::ValueType>& pointer, typename DocumentType::ValueType& value) {
     return pointer.Swap(document, value);
 }
  
 template <typename DocumentType, typename CharType, size_t N>
 typename DocumentType::ValueType& SwapValueByPointer(DocumentType& document, const CharType(&source)[N], typename DocumentType::ValueType& value) {
     return GenericPointer<typename DocumentType::ValueType>(source, N - 1).Swap(document, value);
 }
  
  
 template <typename T>
 bool EraseValueByPointer(T& root, const GenericPointer<typename T::ValueType>& pointer) {
     return pointer.Erase(root);
 }
  
 template <typename T, typename CharType, size_t N>
 bool EraseValueByPointer(T& root, const CharType(&source)[N]) {
     return GenericPointer<typename T::ValueType>(source, N - 1).Erase(root);
 }
  
  
 RAPIDJSON_NAMESPACE_END
  
 #if defined(__clang__) || defined(_MSC_VER)
 RAPIDJSON_DIAG_POP
 #endif
  
 #endif // RAPIDJSON_POINTER_H_