| #include <iostream> |
| #include <json/value.h> |
| #include <json/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 "json_batchallocator.h" |
| #endif // #ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR |
| |
| // Disable warnings. We do not fix these warnings, as this is a file imported |
| // into Polly and we do not want to diverge from the original source. |
| #ifdef __clang__ |
| #pragma clang diagnostic ignored "-Wcovered-switch-default" |
| #endif |
| #ifdef __GNUC__ |
| #pragma GCC diagnostic ignored "-Woverflow" |
| #endif |
| |
| #define JSON_ASSERT_UNREACHABLE assert( false ) |
| #define JSON_ASSERT( condition ) assert( condition ); // @todo <= change this into an exception throw |
| // Do not use throw when exception is disable. |
| #if JSON_USE_EXCEPTION |
| # define JSON_ASSERT_MESSAGE( condition, message ) if (!( condition )) throw std::runtime_error( message ); |
| #else |
| # define JSON_ASSERT_MESSAGE( condition, message ) JSON_ASSERT( condition ) // @todo <= provide the message |
| #endif |
| |
| 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: |
| virtual ~DefaultValueAllocator() |
| { |
| } |
| |
| virtual char *makeMemberName( const char *memberName ) |
| { |
| return duplicateStringValue( memberName ); |
| } |
| |
| virtual void releaseMemberName( char *memberName ) |
| { |
| releaseStringValue( memberName ); |
| } |
| |
| virtual char *duplicateStringValue( const char *value, |
| unsigned int length = unknown ) |
| { |
| //@todo 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; |
| } |
| |
| virtual void releaseStringValue( char *value ) |
| { |
| if ( value ) |
| free( value ); |
| } |
| }; |
| |
| static ValueAllocator *&valueAllocator() |
| { |
| static DefaultValueAllocator defaultAllocator; |
| static ValueAllocator *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 "json_internalarray.inl" |
| # include "json_internalmap.inl" |
| #endif // JSON_VALUE_USE_INTERNAL_MAP |
| |
| # include "json_valueiterator.inl" |
| |
| |
| // ////////////////////////////////////////////////////////////////// |
| // ////////////////////////////////////////////////////////////////// |
| // ////////////////////////////////////////////////////////////////// |
| // class Value::CommentInfo |
| // ////////////////////////////////////////////////////////////////// |
| // ////////////////////////////////////////////////////////////////// |
| // ////////////////////////////////////////////////////////////////// |
| |
| |
| Value::CommentInfo::CommentInfo() |
| : comment_( 0 ) |
| { |
| } |
| |
| 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_( 0 ) |
| , 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_ != 0 |
| ? 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_ ) |
| return strcmp( cstr_, other.cstr_ ) < 0; |
| return index_ < other.index_; |
| } |
| |
| bool |
| Value::CZString::operator==( const CZString &other ) const |
| { |
| if ( 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_( 0 ) |
| # 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_ = 0; |
| 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_( 0 ) |
| # ifdef JSON_VALUE_USE_INTERNAL_MAP |
| , itemIsUsed_( 0 ) |
| #endif |
| { |
| value_.int_ = value; |
| } |
| |
| |
| Value::Value( UInt value ) |
| : type_( uintValue ) |
| , comments_( 0 ) |
| # ifdef JSON_VALUE_USE_INTERNAL_MAP |
| , itemIsUsed_( 0 ) |
| #endif |
| { |
| value_.uint_ = value; |
| } |
| |
| Value::Value( double value ) |
| : type_( realValue ) |
| , comments_( 0 ) |
| # ifdef JSON_VALUE_USE_INTERNAL_MAP |
| , itemIsUsed_( 0 ) |
| #endif |
| { |
| value_.real_ = value; |
| } |
| |
| Value::Value( const char *value ) |
| : type_( stringValue ) |
| , allocated_( true ) |
| , comments_( 0 ) |
| # 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_( 0 ) |
| # 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_( 0 ) |
| # 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_( 0 ) |
| # 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_( 0 ) |
| # ifdef JSON_VALUE_USE_INTERNAL_MAP |
| , itemIsUsed_( 0 ) |
| #endif |
| { |
| value_.bool_ = value; |
| } |
| |
| |
| Value::Value( const Value &other ) |
| : type_( other.type_ ) |
| , comments_( 0 ) |
| # 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_ = 0; |
| 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_ == 0 && 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 0; // 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 0; // 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_->size() != 0; |
| 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_->size() == 0 ); |
| case objectValue: |
| return other == objectValue |
| || ( other == nullValue && value_.map_->size() == 0 ); |
| 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_ != 0 && comments_[placement].comment_ != 0; |
| } |
| |
| 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.c_str() ) |
| , 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 |