Project CMSSW displayed by LXR CMSSW_12_5_X_2022-07-03-2300/​EventFilter/​Utilities/​src/​json_value.cpp	Source navigation Diff markup Identifier search General search
	Version: CMSSW_12_5_X_2022-07-03-2300 CMSSW_12_5_X_2022-07-01-2300 CMSSW_12_5_X_2022-06-30-2300 CMSSW_12_5_X_2022-06-29-2300 CMSSW_12_5_X_2022-06-28-2300 CMSSW_12_5_X_2022-06-27-2300 CMSSW_11_2_1 CMSSW_11_1_7 CMSSW_11_0_3 CMSSW_10_6_20 Revert   Change

File indexing completed on 2021-02-14 13:26:31

 #include <iostream>
 #include "EventFilter/Utilities/interface/value.h"
 #include "EventFilter/Utilities/interface/writer.h"
 #include <utility>
 #include <stdexcept>
 #include <cstring>
 #include <cassert>
 #ifdef JSON_USE_CPPTL
 #include <cpptl/conststring.h>
 #endif
 #include <cstddef>  // size_t
 #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
 #include "EventFilter/Utilities/interface/json_batchallocator.h"
 #endif  // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR
 
 #define JSON_ASSERT_UNREACHABLE assert(false)
 #define JSON_ASSERT(condition) assert(condition);  //  <= change this into an exception throw
 #define JSON_ASSERT_MESSAGE(condition, message) \
   if (!(condition))                             \
     throw std::runtime_error(message);
 
 namespace Json {
 
   const Value Value::null;
   const Int Value::minInt = Int(~(UInt(-1) / 2));
   const Int Value::maxInt = Int(UInt(-1) / 2);
   const UInt Value::maxUInt = UInt(-1);
 
   // A "safe" implementation of strdup. Allow null pointer to be passed.
   // Also avoid warning on msvc80.
   //
   //inline char *safeStringDup( const char *czstring )
   //{
   //   if ( czstring )
   //   {
   //      const size_t length = (unsigned int)( strlen(czstring) + 1 );
   //      char *newString = static_cast<char *>( malloc( length ) );
   //      memcpy( newString, czstring, length );
   //      return newString;
   //   }
   //   return 0;
   //}
   //
   //inline char *safeStringDup( const std::string &str )
   //{
   //   if ( !str.empty() )
   //   {
   //      const size_t length = str.length();
   //      char *newString = static_cast<char *>( malloc( length + 1 ) );
   //      memcpy( newString, str.c_str(), length );
   //      newString[length] = 0;
   //      return newString;
   //   }
   //   return 0;
   //}
 
   ValueAllocator::~ValueAllocator() {}
 
   class DefaultValueAllocator : public ValueAllocator {
   public:
     DefaultValueAllocator() {}
 
     ~DefaultValueAllocator() override {}
 
     char *makeMemberName(const char *memberName) const override { return duplicateStringValue(memberName); }
 
     void releaseMemberName(char *memberName) const override { releaseStringValue(memberName); }
 
     char *duplicateStringValue(const char *value, unsigned int length = unknown) const override {
       // invesgate this old optimization
       //if ( !value  ||  value[0] == 0 )
       //   return 0;
 
       if (length == unknown)
         length = (unsigned int)strlen(value);
       char *newString = static_cast<char *>(malloc(length + 1));
       memcpy(newString, value, length);
       newString[length] = 0;
       return newString;
     }
 
     void releaseStringValue(char *value) const override {
       if (value)
         free(value);
     }
   };
 
   static ValueAllocator const *valueAllocator() {
     static const DefaultValueAllocator defaultAllocator;
     static ValueAllocator const *valueAllocator = &defaultAllocator;
     return valueAllocator;
   }
 
   static struct DummyValueAllocatorInitializer {
     DummyValueAllocatorInitializer() {
       valueAllocator();  // ensure valueAllocator() statics are initialized before main().
     }
   } dummyValueAllocatorInitializer;
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // ValueInternals...
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
 #include "EventFilter/Utilities/interface/json_internalarray.inl"
 #include "EventFilter/Utilities/interface/json_internalmap.inl"
 #endif  // JSON_VALUE_USE_INTERNAL_MAP
 
 #include "EventFilter/Utilities/interface/json_valueiterator.inl"
 
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
   // class Value::CommentInfo
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
 
   Value::CommentInfo::CommentInfo() : comment_(nullptr) {}
 
   Value::CommentInfo::~CommentInfo() {
     if (comment_)
       valueAllocator()->releaseStringValue(comment_);
   }
 
   void Value::CommentInfo::setComment(const char *text) {
     if (comment_)
       valueAllocator()->releaseStringValue(comment_);
     JSON_ASSERT(text);
     JSON_ASSERT_MESSAGE(text[0] == '\0' || text[0] == '/', "Comments must start with /");
     // It seems that /**/ style comments are acceptable as well.
     comment_ = valueAllocator()->duplicateStringValue(text);
   }
 
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // class Value::CZString
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 // //////////////////////////////////////////////////////////////////
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
 
   // Notes: index_ indicates if the string was allocated when
   // a string is stored.
 
   Value::CZString::CZString(int index) : cstr_(nullptr), index_(index) {}
 
   Value::CZString::CZString(const char *cstr, DuplicationPolicy allocate)
       : cstr_(allocate == duplicate ? valueAllocator()->makeMemberName(cstr) : cstr), index_(allocate) {}
 
   Value::CZString::CZString(const CZString &other)
       : cstr_(other.index_ != noDuplication && other.cstr_ != nullptr ? valueAllocator()->makeMemberName(other.cstr_)
                                                                       : other.cstr_),
         index_(other.cstr_ ? (other.index_ == noDuplication ? noDuplication : duplicate) : other.index_) {}
 
   Value::CZString::~CZString() {
     if (cstr_ && index_ == duplicate)
       valueAllocator()->releaseMemberName(const_cast<char *>(cstr_));
   }
 
   void Value::CZString::swap(CZString &other) {
     std::swap(cstr_, other.cstr_);
     std::swap(index_, other.index_);
   }
 
   Value::CZString &Value::CZString::operator=(const CZString &other) {
     CZString temp(other);
     swap(temp);
     return *this;
   }
 
   bool Value::CZString::operator<(const CZString &other) const {
     if (cstr_ and other.cstr_)
       return strcmp(cstr_, other.cstr_) < 0;
     return index_ < other.index_;
   }
 
   bool Value::CZString::operator==(const CZString &other) const {
     if (cstr_ and other.cstr_)
       return strcmp(cstr_, other.cstr_) == 0;
     return index_ == other.index_;
   }
 
   int Value::CZString::index() const { return index_; }
 
   const char *Value::CZString::c_str() const { return cstr_; }
 
   bool Value::CZString::isStaticString() const { return index_ == noDuplication; }
 
 #endif  // ifndef JSON_VALUE_USE_INTERNAL_MAP
 
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
   // class Value::Value
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
   // //////////////////////////////////////////////////////////////////
 
   /*! \internal Default constructor initialization must be equivalent to:
  * memset( this, 0, sizeof(Value) )
  * This optimization is used in ValueInternalMap fast allocator.
  */
   Value::Value(ValueType type)
       : type_(type),
         allocated_(0),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     switch (type) {
       case nullValue:
         break;
       case intValue:
       case uintValue:
         value_.int_ = 0;
         break;
       case realValue:
         value_.real_ = 0.0;
         break;
       case stringValue:
         value_.string_ = nullptr;
         break;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
       case objectValue:
         value_.map_ = new ObjectValues();
         break;
 #else
       case arrayValue:
         value_.array_ = arrayAllocator()->newArray();
         break;
       case objectValue:
         value_.map_ = mapAllocator()->newMap();
         break;
 #endif
       case booleanValue:
         value_.bool_ = false;
         break;
       default:
         JSON_ASSERT_UNREACHABLE;
     }
   }
 
   Value::Value(Int value)
       : type_(intValue),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.int_ = value;
   }
 
   Value::Value(UInt value)
       : type_(uintValue),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.uint_ = value;
   }
 
   Value::Value(double value)
       : type_(realValue),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.real_ = value;
   }
 
   Value::Value(const char *value)
       : type_(stringValue),
         allocated_(true),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.string_ = valueAllocator()->duplicateStringValue(value);
   }
 
   Value::Value(const char *beginValue, const char *endValue)
       : type_(stringValue),
         allocated_(true),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.string_ = valueAllocator()->duplicateStringValue(beginValue, UInt(endValue - beginValue));
   }
 
   Value::Value(const std::string &value)
       : type_(stringValue),
         allocated_(true),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.string_ = valueAllocator()->duplicateStringValue(value.c_str(), (unsigned int)value.length());
   }
 
   Value::Value(const StaticString &value)
       : type_(stringValue),
         allocated_(false),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.string_ = const_cast<char *>(value.c_str());
   }
 
 #ifdef JSON_USE_CPPTL
   Value::Value(const CppTL::ConstString &value)
       : type_(stringValue),
         allocated_(true),
         comments_(0)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.string_ = valueAllocator()->duplicateStringValue(value, value.length());
   }
 #endif
 
   Value::Value(bool value)
       : type_(booleanValue),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     value_.bool_ = value;
   }
 
   Value::Value(const Value &other)
       : type_(other.type_),
         comments_(nullptr)
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
         ,
         itemIsUsed_(0)
 #endif
   {
     switch (type_) {
       case nullValue:
       case intValue:
       case uintValue:
       case realValue:
       case booleanValue:
         value_ = other.value_;
         break;
       case stringValue:
         if (other.value_.string_) {
           value_.string_ = valueAllocator()->duplicateStringValue(other.value_.string_);
           allocated_ = true;
         } else
           value_.string_ = nullptr;
         break;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
       case objectValue:
         value_.map_ = new ObjectValues(*other.value_.map_);
         break;
 #else
       case arrayValue:
         value_.array_ = arrayAllocator()->newArrayCopy(*other.value_.array_);
         break;
       case objectValue:
         value_.map_ = mapAllocator()->newMapCopy(*other.value_.map_);
         break;
 #endif
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     if (other.comments_) {
       comments_ = new CommentInfo[numberOfCommentPlacement];
       for (int comment = 0; comment < numberOfCommentPlacement; ++comment) {
         const CommentInfo &otherComment = other.comments_[comment];
         if (otherComment.comment_)
           comments_[comment].setComment(otherComment.comment_);
       }
     }
   }
 
   Value::~Value() {
     switch (type_) {
       case nullValue:
       case intValue:
       case uintValue:
       case realValue:
       case booleanValue:
         break;
       case stringValue:
         if (allocated_)
           valueAllocator()->releaseStringValue(value_.string_);
         break;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
       case objectValue:
         delete value_.map_;
         break;
 #else
       case arrayValue:
         arrayAllocator()->destructArray(value_.array_);
         break;
       case objectValue:
         mapAllocator()->destructMap(value_.map_);
         break;
 #endif
       default:
         JSON_ASSERT_UNREACHABLE;
     }
 
     if (comments_)
       delete[] comments_;
   }
 
   Value &Value::operator=(const Value &other) {
     Value temp(other);
     swap(temp);
     return *this;
   }
 
   void Value::swap(Value &other) {
     ValueType temp = type_;
     type_ = other.type_;
     other.type_ = temp;
     std::swap(value_, other.value_);
     int temp2 = allocated_;
     allocated_ = other.allocated_;
     other.allocated_ = temp2;
   }
 
   ValueType Value::type() const { return type_; }
 
   int Value::compare(const Value &other) {
     /*
    int typeDelta = other.type_ - type_;
    switch ( type_ )
    {
    case nullValue:
 
       return other.type_ == type_;
    case intValue:
       if ( other.type_.isNumeric()
    case uintValue:
    case realValue:
    case booleanValue:
       break;
    case stringValue,
       break;
    case arrayValue:
       delete value_.array_;
       break;
    case objectValue:
       delete value_.map_;
    default:
       JSON_ASSERT_UNREACHABLE;
    }
    */
     return 0;  // unreachable
   }
 
   bool Value::operator<(const Value &other) const {
     int typeDelta = type_ - other.type_;
     if (typeDelta)
       return typeDelta < 0 ? true : false;
     switch (type_) {
       case nullValue:
         return false;
       case intValue:
         return value_.int_ < other.value_.int_;
       case uintValue:
         return value_.uint_ < other.value_.uint_;
       case realValue:
         return value_.real_ < other.value_.real_;
       case booleanValue:
         return value_.bool_ < other.value_.bool_;
       case stringValue:
         return (value_.string_ == nullptr && other.value_.string_) ||
                (other.value_.string_ && value_.string_ && strcmp(value_.string_, other.value_.string_) < 0);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
       case objectValue: {
         int delta = int(value_.map_->size() - other.value_.map_->size());
         if (delta)
           return delta < 0;
         return (*value_.map_) < (*other.value_.map_);
       }
 #else
       case arrayValue:
         return value_.array_->compare(*(other.value_.array_)) < 0;
       case objectValue:
         return value_.map_->compare(*(other.value_.map_)) < 0;
 #endif
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return false;  // unreachable
   }
 
   bool Value::operator<=(const Value &other) const { return !(other > *this); }
 
   bool Value::operator>=(const Value &other) const { return !(*this < other); }
 
   bool Value::operator>(const Value &other) const { return other < *this; }
 
   bool Value::operator==(const Value &other) const {
     //if ( type_ != other.type_ )
     // GCC 2.95.3 says:
     // attempt to take address of bit-field structure member `Json::Value::type_'
     // Beats me, but a temp solves the problem.
     int temp = other.type_;
     if (type_ != temp)
       return false;
     switch (type_) {
       case nullValue:
         return true;
       case intValue:
         return value_.int_ == other.value_.int_;
       case uintValue:
         return value_.uint_ == other.value_.uint_;
       case realValue:
         return value_.real_ == other.value_.real_;
       case booleanValue:
         return value_.bool_ == other.value_.bool_;
       case stringValue:
         return (value_.string_ == other.value_.string_) ||
                (other.value_.string_ && value_.string_ && strcmp(value_.string_, other.value_.string_) == 0);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
       case objectValue:
         return value_.map_->size() == other.value_.map_->size() && (*value_.map_) == (*other.value_.map_);
 #else
       case arrayValue:
         return value_.array_->compare(*(other.value_.array_)) == 0;
       case objectValue:
         return value_.map_->compare(*(other.value_.map_)) == 0;
 #endif
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return false;  // unreachable
   }
 
   bool Value::operator!=(const Value &other) const { return !(*this == other); }
 
   const char *Value::asCString() const {
     JSON_ASSERT(type_ == stringValue);
     return value_.string_;
   }
 
   std::string Value::asString() const {
     switch (type_) {
       case nullValue:
         return "";
       case stringValue:
         return value_.string_ ? value_.string_ : "";
       case booleanValue:
         return value_.bool_ ? "true" : "false";
       case intValue:
       case uintValue:
       case realValue:
       case arrayValue:
       case objectValue:
         JSON_ASSERT_MESSAGE(false, "Type is not convertible to string");
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return "";  // unreachable
   }
 
 #ifdef JSON_USE_CPPTL
   CppTL::ConstString Value::asConstString() const { return CppTL::ConstString(asString().c_str()); }
 #endif
 
   Value::Int Value::asInt() const {
     switch (type_) {
       case nullValue:
         return 0;
       case intValue:
         return value_.int_;
       case uintValue:
         JSON_ASSERT_MESSAGE(value_.uint_ < (unsigned)maxInt, "integer out of signed integer range");
         return value_.uint_;
       case realValue:
         JSON_ASSERT_MESSAGE(value_.real_ >= minInt && value_.real_ <= maxInt, "Real out of signed integer range");
         return Int(value_.real_);
       case booleanValue:
         return value_.bool_ ? 1 : 0;
       case stringValue:
       case arrayValue:
       case objectValue:
         JSON_ASSERT_MESSAGE(false, "Type is not convertible to int");
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return 0;  // unreachable;
   }
 
   Value::UInt Value::asUInt() const {
     switch (type_) {
       case nullValue:
         return 0;
       case intValue:
         JSON_ASSERT_MESSAGE(value_.int_ >= 0, "Negative integer can not be converted to unsigned integer");
         return value_.int_;
       case uintValue:
         return value_.uint_;
       case realValue:
         JSON_ASSERT_MESSAGE(value_.real_ >= 0 && value_.real_ <= maxUInt, "Real out of unsigned integer range");
         return UInt(value_.real_);
       case booleanValue:
         return value_.bool_ ? 1 : 0;
       case stringValue:
       case arrayValue:
       case objectValue:
         JSON_ASSERT_MESSAGE(false, "Type is not convertible to uint");
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return 0;  // unreachable;
   }
 
   double Value::asDouble() const {
     switch (type_) {
       case nullValue:
         return 0.0;
       case intValue:
         return value_.int_;
       case uintValue:
         return value_.uint_;
       case realValue:
         return value_.real_;
       case booleanValue:
         return value_.bool_ ? 1.0 : 0.0;
       case stringValue:
       case arrayValue:
       case objectValue:
         JSON_ASSERT_MESSAGE(false, "Type is not convertible to double");
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return 0;  // unreachable;
   }
 
   bool Value::asBool() const {
     switch (type_) {
       case nullValue:
         return false;
       case intValue:
       case uintValue:
         return value_.int_ != 0;
       case realValue:
         return value_.real_ != 0.0;
       case booleanValue:
         return value_.bool_;
       case stringValue:
         return value_.string_ && value_.string_[0] != 0;
       case arrayValue:
       case objectValue:
         return !value_.map_->empty();
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return false;  // unreachable;
   }
 
   bool Value::isConvertibleTo(ValueType other) const {
     switch (type_) {
       case nullValue:
         return true;
       case intValue:
         return (other == nullValue && value_.int_ == 0) || other == intValue ||
                (other == uintValue && value_.int_ >= 0) || other == realValue || other == stringValue ||
                other == booleanValue;
       case uintValue:
         return (other == nullValue && value_.uint_ == 0) || (other == intValue && value_.uint_ <= (unsigned)maxInt) ||
                other == uintValue || other == realValue || other == stringValue || other == booleanValue;
       case realValue:
         return (other == nullValue && value_.real_ == 0.0) ||
                (other == intValue && value_.real_ >= minInt && value_.real_ <= maxInt) ||
                (other == uintValue && value_.real_ >= 0 && value_.real_ <= maxUInt) || other == realValue ||
                other == stringValue || other == booleanValue;
       case booleanValue:
         return (other == nullValue && value_.bool_ == false) || other == intValue || other == uintValue ||
                other == realValue || other == stringValue || other == booleanValue;
       case stringValue:
         return other == stringValue || (other == nullValue && (!value_.string_ || value_.string_[0] == 0));
       case arrayValue:
         return other == arrayValue || (other == nullValue && value_.map_->empty());
       case objectValue:
         return other == objectValue || (other == nullValue && value_.map_->empty());
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return false;  // unreachable;
   }
 
   /// Number of values in array or object
   Value::UInt Value::size() const {
     switch (type_) {
       case nullValue:
       case intValue:
       case uintValue:
       case realValue:
       case booleanValue:
       case stringValue:
         return 0;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:  // size of the array is highest index + 1
         if (!value_.map_->empty()) {
           ObjectValues::const_iterator itLast = value_.map_->end();
           --itLast;
           return (*itLast).first.index() + 1;
         }
         return 0;
       case objectValue:
         return Int(value_.map_->size());
 #else
       case arrayValue:
         return Int(value_.array_->size());
       case objectValue:
         return Int(value_.map_->size());
 #endif
       default:
         JSON_ASSERT_UNREACHABLE;
     }
     return 0;  // unreachable;
   }
 
   bool Value::empty() const {
     if (isNull() || isArray() || isObject())
       return size() == 0u;
     else
       return false;
   }
 
   bool Value::operator!() const { return isNull(); }
 
   void Value::clear() {
     JSON_ASSERT(type_ == nullValue || type_ == arrayValue || type_ == objectValue);
 
     switch (type_) {
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
       case objectValue:
         value_.map_->clear();
         break;
 #else
       case arrayValue:
         value_.array_->clear();
         break;
       case objectValue:
         value_.map_->clear();
         break;
 #endif
       default:
         break;
     }
   }
 
   void Value::resize(UInt newSize) {
     JSON_ASSERT(type_ == nullValue || type_ == arrayValue);
     if (type_ == nullValue)
       *this = Value(arrayValue);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     UInt oldSize = size();
     if (newSize == 0)
       clear();
     else if (newSize > oldSize)
       (*this)[newSize - 1];
     else {
       for (UInt index = newSize; index < oldSize; ++index)
         value_.map_->erase(index);
       assert(size() == newSize);
     }
 #else
     value_.array_->resize(newSize);
 #endif
   }
 
   Value &Value::operator[](UInt index) {
     JSON_ASSERT(type_ == nullValue || type_ == arrayValue);
     if (type_ == nullValue)
       *this = Value(arrayValue);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     CZString key(index);
     ObjectValues::iterator it = value_.map_->lower_bound(key);
     if (it != value_.map_->end() && (*it).first == key)
       return (*it).second;
 
     ObjectValues::value_type defaultValue(key, null);
     it = value_.map_->insert(it, defaultValue);
     return (*it).second;
 #else
     return value_.array_->resolveReference(index);
 #endif
   }
 
   const Value &Value::operator[](UInt index) const {
     JSON_ASSERT(type_ == nullValue || type_ == arrayValue);
     if (type_ == nullValue)
       return null;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     CZString key(index);
     ObjectValues::const_iterator it = value_.map_->find(key);
     if (it == value_.map_->end())
       return null;
     return (*it).second;
 #else
     Value *value = value_.array_->find(index);
     return value ? *value : null;
 #endif
   }
 
   Value &Value::operator[](const char *key) { return resolveReference(key, false); }
 
   Value &Value::resolveReference(const char *key, bool isStatic) {
     JSON_ASSERT(type_ == nullValue || type_ == objectValue);
     if (type_ == nullValue)
       *this = Value(objectValue);
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     CZString actualKey(key, isStatic ? CZString::noDuplication : CZString::duplicateOnCopy);
     ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
     if (it != value_.map_->end() && (*it).first == actualKey)
       return (*it).second;
 
     ObjectValues::value_type defaultValue(actualKey, null);
     it = value_.map_->insert(it, defaultValue);
     Value &value = (*it).second;
     return value;
 #else
     return value_.map_->resolveReference(key, isStatic);
 #endif
   }
 
   Value Value::get(UInt index, const Value &defaultValue) const {
     const Value *value = &((*this)[index]);
     return value == &null ? defaultValue : *value;
   }
 
   bool Value::isValidIndex(UInt index) const { return index < size(); }
 
   const Value &Value::operator[](const char *key) const {
     JSON_ASSERT(type_ == nullValue || type_ == objectValue);
     if (type_ == nullValue)
       return null;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     CZString actualKey(key, CZString::noDuplication);
     ObjectValues::const_iterator it = value_.map_->find(actualKey);
     if (it == value_.map_->end())
       return null;
     return (*it).second;
 #else
     const Value *value = value_.map_->find(key);
     return value ? *value : null;
 #endif
   }
 
   Value &Value::operator[](const std::string &key) { return (*this)[key.c_str()]; }
 
   const Value &Value::operator[](const std::string &key) const { return (*this)[key.c_str()]; }
 
   Value &Value::operator[](const StaticString &key) { return resolveReference(key, true); }
 
 #ifdef JSON_USE_CPPTL
   Value &Value::operator[](const CppTL::ConstString &key) { return (*this)[key.c_str()]; }
 
   const Value &Value::operator[](const CppTL::ConstString &key) const { return (*this)[key.c_str()]; }
 #endif
 
   Value &Value::append(const Value &value) { return (*this)[size()] = value; }
 
   Value Value::get(const char *key, const Value &defaultValue) const {
     const Value *value = &((*this)[key]);
     return value == &null ? defaultValue : *value;
   }
 
   Value Value::get(const std::string &key, const Value &defaultValue) const { return get(key.c_str(), defaultValue); }
 
   Value Value::removeMember(const char *key) {
     JSON_ASSERT(type_ == nullValue || type_ == objectValue);
     if (type_ == nullValue)
       return null;
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     CZString actualKey(key, CZString::noDuplication);
     ObjectValues::iterator it = value_.map_->find(actualKey);
     if (it == value_.map_->end())
       return null;
     Value old(it->second);
     value_.map_->erase(it);
     return old;
 #else
     Value *value = value_.map_->find(key);
     if (value) {
       Value old(*value);
       value_.map_.remove(key);
       return old;
     } else {
       return null;
     }
 #endif
   }
 
   Value Value::removeMember(const std::string &key) { return removeMember(key.c_str()); }
 
 #ifdef JSON_USE_CPPTL
   Value Value::get(const CppTL::ConstString &key, const Value &defaultValue) const {
     return get(key.c_str(), defaultValue);
   }
 #endif
 
   bool Value::isMember(const char *key) const {
     const Value *value = &((*this)[key]);
     return value != &null;
   }
 
   bool Value::isMember(const std::string &key) const { return isMember(key.c_str()); }
 
 #ifdef JSON_USE_CPPTL
   bool Value::isMember(const CppTL::ConstString &key) const { return isMember(key.c_str()); }
 #endif
 
   Value::Members Value::getMemberNames() const {
     JSON_ASSERT(type_ == nullValue || type_ == objectValue);
     if (type_ == nullValue)
       return Value::Members();
     Members members;
     members.reserve(value_.map_->size());
 #ifndef JSON_VALUE_USE_INTERNAL_MAP
     ObjectValues::const_iterator it = value_.map_->begin();
     ObjectValues::const_iterator itEnd = value_.map_->end();
     for (; it != itEnd; ++it)
       members.push_back(std::string((*it).first.c_str()));
 #else
     ValueInternalMap::IteratorState it;
     ValueInternalMap::IteratorState itEnd;
     value_.map_->makeBeginIterator(it);
     value_.map_->makeEndIterator(itEnd);
     for (; !ValueInternalMap::equals(it, itEnd); ValueInternalMap::increment(it))
       members.push_back(std::string(ValueInternalMap::key(it)));
 #endif
     return members;
   }
   //
   //# ifdef JSON_USE_CPPTL
   //EnumMemberNames
   //Value::enumMemberNames() const
   //{
   //   if ( type_ == objectValue )
   //   {
   //      return CppTL::Enum::any(  CppTL::Enum::transform(
   //         CppTL::Enum::keys( *(value_.map_), CppTL::Type<const CZString &>() ),
   //         MemberNamesTransform() ) );
   //   }
   //   return EnumMemberNames();
   //}
   //
   //
   //EnumValues
   //Value::enumValues() const
   //{
   //   if ( type_ == objectValue  ||  type_ == arrayValue )
   //      return CppTL::Enum::anyValues( *(value_.map_),
   //                                     CppTL::Type<const Value &>() );
   //   return EnumValues();
   //}
   //
   //# endif
 
   bool Value::isNull() const { return type_ == nullValue; }
 
   bool Value::isBool() const { return type_ == booleanValue; }
 
   bool Value::isInt() const { return type_ == intValue; }
 
   bool Value::isUInt() const { return type_ == uintValue; }
 
   bool Value::isIntegral() const { return type_ == intValue || type_ == uintValue || type_ == booleanValue; }
 
   bool Value::isDouble() const { return type_ == realValue; }
 
   bool Value::isNumeric() const { return isIntegral() || isDouble(); }
 
   bool Value::isString() const { return type_ == stringValue; }
 
   bool Value::isArray() const { return type_ == nullValue || type_ == arrayValue; }
 
   bool Value::isObject() const { return type_ == nullValue || type_ == objectValue; }
 
   void Value::setComment(const char *comment, CommentPlacement placement) {
     if (!comments_)
       comments_ = new CommentInfo[numberOfCommentPlacement];
     comments_[placement].setComment(comment);
   }
 
   void Value::setComment(const std::string &comment, CommentPlacement placement) {
     setComment(comment.c_str(), placement);
   }
 
   bool Value::hasComment(CommentPlacement placement) const {
     return comments_ != nullptr && comments_[placement].comment_ != nullptr;
   }
 
   std::string Value::getComment(CommentPlacement placement) const {
     if (hasComment(placement))
       return comments_[placement].comment_;
     return "";
   }
 
   std::string Value::toStyledString() const {
     StyledWriter writer;
     return writer.write(*this);
   }
 
   Value::const_iterator Value::begin() const {
     switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
         if (value_.array_) {
           ValueInternalArray::IteratorState it;
           value_.array_->makeBeginIterator(it);
           return const_iterator(it);
         }
         break;
       case objectValue:
         if (value_.map_) {
           ValueInternalMap::IteratorState it;
           value_.map_->makeBeginIterator(it);
           return const_iterator(it);
         }
         break;
 #else
       case arrayValue:
       case objectValue:
         if (value_.map_)
           return const_iterator(value_.map_->begin());
         break;
 #endif
       default:
         break;
     }
     return const_iterator();
   }
 
   Value::const_iterator Value::end() const {
     switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
         if (value_.array_) {
           ValueInternalArray::IteratorState it;
           value_.array_->makeEndIterator(it);
           return const_iterator(it);
         }
         break;
       case objectValue:
         if (value_.map_) {
           ValueInternalMap::IteratorState it;
           value_.map_->makeEndIterator(it);
           return const_iterator(it);
         }
         break;
 #else
       case arrayValue:
       case objectValue:
         if (value_.map_)
           return const_iterator(value_.map_->end());
         break;
 #endif
       default:
         break;
     }
     return const_iterator();
   }
 
   Value::iterator Value::begin() {
     switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
         if (value_.array_) {
           ValueInternalArray::IteratorState it;
           value_.array_->makeBeginIterator(it);
           return iterator(it);
         }
         break;
       case objectValue:
         if (value_.map_) {
           ValueInternalMap::IteratorState it;
           value_.map_->makeBeginIterator(it);
           return iterator(it);
         }
         break;
 #else
       case arrayValue:
       case objectValue:
         if (value_.map_)
           return iterator(value_.map_->begin());
         break;
 #endif
       default:
         break;
     }
     return iterator();
   }
 
   Value::iterator Value::end() {
     switch (type_) {
 #ifdef JSON_VALUE_USE_INTERNAL_MAP
       case arrayValue:
         if (value_.array_) {
           ValueInternalArray::IteratorState it;
           value_.array_->makeEndIterator(it);
           return iterator(it);
         }
         break;
       case objectValue:
         if (value_.map_) {
           ValueInternalMap::IteratorState it;
           value_.map_->makeEndIterator(it);
           return iterator(it);
         }
         break;
 #else
       case arrayValue:
       case objectValue:
         if (value_.map_)
           return iterator(value_.map_->end());
         break;
 #endif
       default:
         break;
     }
     return iterator();
   }
 
   // class PathArgument
   // //////////////////////////////////////////////////////////////////
 
   PathArgument::PathArgument() : kind_(kindNone) {}
 
   PathArgument::PathArgument(Value::UInt index) : index_(index), kind_(kindIndex) {}
 
   PathArgument::PathArgument(const char *key) : key_(key), kind_(kindKey) {}
 
   PathArgument::PathArgument(const std::string &key) : key_(key), kind_(kindKey) {}
 
   // class Path
   // //////////////////////////////////////////////////////////////////
 
   Path::Path(const std::string &path,
              const PathArgument &a1,
              const PathArgument &a2,
              const PathArgument &a3,
              const PathArgument &a4,
              const PathArgument &a5) {
     InArgs in;
     in.push_back(&a1);
     in.push_back(&a2);
     in.push_back(&a3);
     in.push_back(&a4);
     in.push_back(&a5);
     makePath(path, in);
   }
 
   void Path::makePath(const std::string &path, const InArgs &in) {
     const char *current = path.c_str();
     const char *end = current + path.length();
     InArgs::const_iterator itInArg = in.begin();
     while (current != end) {
       if (*current == '[') {
         ++current;
         if (*current == '%')
           addPathInArg(path, in, itInArg, PathArgument::kindIndex);
         else {
           Value::UInt index = 0;
           for (; current != end && *current >= '0' && *current <= '9'; ++current)
             index = index * 10 + Value::UInt(*current - '0');
           args_.push_back(index);
         }
         if (current == end || *current++ != ']')
           invalidPath(path, int(current - path.c_str()));
       } else if (*current == '%') {
         addPathInArg(path, in, itInArg, PathArgument::kindKey);
         ++current;
       } else if (*current == '.') {
         ++current;
       } else {
         const char *beginName = current;
         while (current != end && !strchr("[.", *current))
           ++current;
         args_.push_back(std::string(beginName, current));
       }
     }
   }
 
   void Path::addPathInArg(const std::string &path,
                           const InArgs &in,
                           InArgs::const_iterator &itInArg,
                           PathArgument::Kind kind) {
     if (itInArg == in.end()) {
       // Error: missing argument %d
     } else if ((*itInArg)->kind_ != kind) {
       // Error: bad argument type
     } else {
       args_.push_back(**itInArg);
     }
   }
 
   void Path::invalidPath(const std::string &path, int location) {
     // Error: invalid path.
   }
 
   const Value &Path::resolve(const Value &root) const {
     const Value *node = &root;
     for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
       const PathArgument &arg = *it;
       if (arg.kind_ == PathArgument::kindIndex) {
         if (!node->isArray() || node->isValidIndex(arg.index_)) {
           // Error: unable to resolve path (array value expected at position...
         }
         node = &((*node)[arg.index_]);
       } else if (arg.kind_ == PathArgument::kindKey) {
         if (!node->isObject()) {
           // Error: unable to resolve path (object value expected at position...)
         }
         node = &((*node)[arg.key_]);
         if (node == &Value::null) {
           // Error: unable to resolve path (object has no member named '' at position...)
         }
       }
     }
     return *node;
   }
 
   Value Path::resolve(const Value &root, const Value &defaultValue) const {
     const Value *node = &root;
     for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
       const PathArgument &arg = *it;
       if (arg.kind_ == PathArgument::kindIndex) {
         if (!node->isArray() || node->isValidIndex(arg.index_))
           return defaultValue;
         node = &((*node)[arg.index_]);
       } else if (arg.kind_ == PathArgument::kindKey) {
         if (!node->isObject())
           return defaultValue;
         node = &((*node)[arg.key_]);
         if (node == &Value::null)
           return defaultValue;
       }
     }
     return *node;
   }
 
   Value &Path::make(Value &root) const {
     Value *node = &root;
     for (Args::const_iterator it = args_.begin(); it != args_.end(); ++it) {
       const PathArgument &arg = *it;
       if (arg.kind_ == PathArgument::kindIndex) {
         if (!node->isArray()) {
           // Error: node is not an array at position ...
         }
         node = &((*node)[arg.index_]);
       } else if (arg.kind_ == PathArgument::kindKey) {
         if (!node->isObject()) {
           // Error: node is not an object at position...
         }
         node = &((*node)[arg.key_]);
       }
     }
     return *node;
   }
 
 }  // namespace Json

This page was automatically generated by the 2.2.1 LXR engine. The LXR team