diff --git a/Builds/VisualStudio2013/RippleD.vcxproj b/Builds/VisualStudio2013/RippleD.vcxproj index 5785290a26..88dd3b4f71 100644 --- a/Builds/VisualStudio2013/RippleD.vcxproj +++ b/Builds/VisualStudio2013/RippleD.vcxproj @@ -2012,12 +2012,6 @@ - - - - - - True @@ -2034,10 +2028,6 @@ - - - - diff --git a/Builds/VisualStudio2013/RippleD.vcxproj.filters b/Builds/VisualStudio2013/RippleD.vcxproj.filters index 2117a5a2a7..d9d9d23bd6 100644 --- a/Builds/VisualStudio2013/RippleD.vcxproj.filters +++ b/Builds/VisualStudio2013/RippleD.vcxproj.filters @@ -2952,15 +2952,6 @@ ripple\json\impl - - ripple\json\impl - - - ripple\json\impl - - - ripple\json\impl - ripple\json\impl @@ -2979,12 +2970,6 @@ ripple\json - - ripple\json - - - ripple\json - ripple\json diff --git a/src/ripple/app/main/Application.cpp b/src/ripple/app/main/Application.cpp index 09d70f8b28..7634fc823f 100644 --- a/src/ripple/app/main/Application.cpp +++ b/src/ripple/app/main/Application.cpp @@ -1074,7 +1074,7 @@ bool ApplicationImp::loadOldLedger ( { Json::Reader reader; Json::Value jLedger; - if (!reader.parse (ledgerFile, jLedger, false)) + if (!reader.parse (ledgerFile, jLedger)) m_journal.fatal << "Unable to parse ledger JSON"; else { diff --git a/src/ripple/json/JsonPropertyStream.h b/src/ripple/json/JsonPropertyStream.h index 9b8dfb1e17..31a2921374 100644 --- a/src/ripple/json/JsonPropertyStream.h +++ b/src/ripple/json/JsonPropertyStream.h @@ -20,7 +20,6 @@ #ifndef RIPPLE_JSON_JSONPROPERTYSTREAM_H_INCLUDED #define RIPPLE_JSON_JSONPROPERTYSTREAM_H_INCLUDED -#include #include namespace ripple { diff --git a/src/ripple/json/impl/json_autolink.h b/src/ripple/json/impl/json_autolink.h deleted file mode 100644 index b614d2821f..0000000000 --- a/src/ripple/json/impl/json_autolink.h +++ /dev/null @@ -1,41 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of rippled: https://github.com/ripple/rippled - Copyright (c) 2012, 2013 Ripple Labs Inc. - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -#ifndef RIPPLE_JSON_JSON_AUTOLINK_H_INCLUDED -#define RIPPLE_JSON_JSON_AUTOLINK_H_INCLUDED - -// VFALCO TODO remove this file -#error This file is deprecated! - -# include "config.h" - -# ifdef JSON_IN_CPPTL -# include -# endif - -# if !defined(JSON_NO_AUTOLINK) && !defined(JSON_DLL_BUILD) && !defined(JSON_IN_CPPTL) -# define CPPTL_AUTOLINK_NAME "json" -# undef CPPTL_AUTOLINK_DLL -# ifdef JSON_DLL -# define CPPTL_AUTOLINK_DLL -# endif -# include "autolink.h" -# endif - -#endif // JSON_AUTOLINK_H_INCLUDED diff --git a/src/ripple/json/impl/json_batchallocator.h b/src/ripple/json/impl/json_batchallocator.h index 4f2d1c99c0..517e592126 100644 --- a/src/ripple/json/impl/json_batchallocator.h +++ b/src/ripple/json/impl/json_batchallocator.h @@ -20,8 +20,6 @@ #ifndef RIPPLE_JSON_JSON_BATCHALLOCATOR_H_INCLUDED #define RIPPLE_JSON_JSON_BATCHALLOCATOR_H_INCLUDED -#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - namespace Json { @@ -139,7 +137,5 @@ private: } // namespace Json -# endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION - #endif // JSONCPP_BATCHALLOCATOR_H_INCLUDED diff --git a/src/ripple/json/impl/json_internalarray.inl b/src/ripple/json/impl/json_internalarray.inl deleted file mode 100644 index 21625c43b5..0000000000 --- a/src/ripple/json/impl/json_internalarray.inl +++ /dev/null @@ -1,497 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of rippled: https://github.com/ripple/rippled - Copyright (c) 2012, 2013 Ripple Labs Inc. - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -// included by json_value.cpp -// everything is within Json namespace - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueInternalArray -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -ValueArrayAllocator::~ValueArrayAllocator () -{ -} - -// ////////////////////////////////////////////////////////////////// -// class DefaultValueArrayAllocator -// ////////////////////////////////////////////////////////////////// -#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -class DefaultValueArrayAllocator : public ValueArrayAllocator -{ -public: // overridden from ValueArrayAllocator - virtual ~DefaultValueArrayAllocator () - { - } - - virtual ValueInternalArray* newArray () - { - return new ValueInternalArray (); - } - - virtual ValueInternalArray* newArrayCopy ( const ValueInternalArray& other ) - { - return new ValueInternalArray ( other ); - } - - virtual void destructArray ( ValueInternalArray* array ) - { - delete array; - } - - virtual void reallocateArrayPageIndex ( Value**& indexes, - ValueInternalArray::PageIndex& indexCount, - ValueInternalArray::PageIndex minNewIndexCount ) - { - ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1; - - if ( minNewIndexCount > newIndexCount ) - newIndexCount = minNewIndexCount; - - void* newIndexes = realloc ( indexes, sizeof (Value*) * newIndexCount ); - - if ( !newIndexes ) - throw std::bad_alloc (); - - indexCount = newIndexCount; - indexes = static_cast ( newIndexes ); - } - virtual void releaseArrayPageIndex ( Value** indexes, - ValueInternalArray::PageIndex indexCount ) - { - if ( indexes ) - free ( indexes ); - } - - virtual Value* allocateArrayPage () - { - return static_cast ( malloc ( sizeof (Value) * ValueInternalArray::itemsPerPage ) ); - } - - virtual void releaseArrayPage ( Value* value ) - { - if ( value ) - free ( value ); - } -}; - -#else // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -/// @todo make this thread-safe (lock when accessign batch allocator) -class DefaultValueArrayAllocator : public ValueArrayAllocator -{ -public: // overridden from ValueArrayAllocator - virtual ~DefaultValueArrayAllocator () - { - } - - virtual ValueInternalArray* newArray () - { - ValueInternalArray* array = arraysAllocator_.allocate (); - new (array) ValueInternalArray (); // placement new - return array; - } - - virtual ValueInternalArray* newArrayCopy ( const ValueInternalArray& other ) - { - ValueInternalArray* array = arraysAllocator_.allocate (); - new (array) ValueInternalArray ( other ); // placement new - return array; - } - - virtual void destructArray ( ValueInternalArray* array ) - { - if ( array ) - { - array->~ValueInternalArray (); - arraysAllocator_.release ( array ); - } - } - - virtual void reallocateArrayPageIndex ( Value**& indexes, - ValueInternalArray::PageIndex& indexCount, - ValueInternalArray::PageIndex minNewIndexCount ) - { - ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1; - - if ( minNewIndexCount > newIndexCount ) - newIndexCount = minNewIndexCount; - - void* newIndexes = realloc ( indexes, sizeof (Value*) * newIndexCount ); - - if ( !newIndexes ) - throw std::bad_alloc (); - - indexCount = newIndexCount; - indexes = static_cast ( newIndexes ); - } - virtual void releaseArrayPageIndex ( Value** indexes, - ValueInternalArray::PageIndex indexCount ) - { - if ( indexes ) - free ( indexes ); - } - - virtual Value* allocateArrayPage () - { - return static_cast ( pagesAllocator_.allocate () ); - } - - virtual void releaseArrayPage ( Value* value ) - { - if ( value ) - pagesAllocator_.release ( value ); - } -private: - BatchAllocator arraysAllocator_; - BatchAllocator pagesAllocator_; -}; -#endif // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR - -static ValueArrayAllocator*& arrayAllocator () -{ - static DefaultValueArrayAllocator defaultAllocator; - static ValueArrayAllocator* arrayAllocator = &defaultAllocator; - return arrayAllocator; -} - -static struct DummyArrayAllocatorInitializer -{ - DummyArrayAllocatorInitializer () - { - arrayAllocator (); // ensure arrayAllocator() statics are initialized before main(). - } -} dummyArrayAllocatorInitializer; - -// ////////////////////////////////////////////////////////////////// -// class ValueInternalArray -// ////////////////////////////////////////////////////////////////// -bool -ValueInternalArray::equals ( const IteratorState& x, - const IteratorState& other ) -{ - return x.array_ == other.array_ - && x.currentItemIndex_ == other.currentItemIndex_ - && x.currentPageIndex_ == other.currentPageIndex_; -} - - -void -ValueInternalArray::increment ( IteratorState& it ) -{ - JSON_ASSERT_MESSAGE ( it.array_ && - (it.currentPageIndex_ - it.array_->pages_)*itemsPerPage + it.currentItemIndex_ - != it.array_->size_, - "ValueInternalArray::increment(): moving iterator beyond end" ); - ++ (it.currentItemIndex_); - - if ( it.currentItemIndex_ == itemsPerPage ) - { - it.currentItemIndex_ = 0; - ++ (it.currentPageIndex_); - } -} - - -void -ValueInternalArray::decrement ( IteratorState& it ) -{ - JSON_ASSERT_MESSAGE ( it.array_ && it.currentPageIndex_ == it.array_->pages_ - && it.currentItemIndex_ == 0, - "ValueInternalArray::decrement(): moving iterator beyond end" ); - - if ( it.currentItemIndex_ == 0 ) - { - it.currentItemIndex_ = itemsPerPage - 1; - -- (it.currentPageIndex_); - } - else - { - -- (it.currentItemIndex_); - } -} - - -Value& -ValueInternalArray::unsafeDereference ( const IteratorState& it ) -{ - return (* (it.currentPageIndex_))[it.currentItemIndex_]; -} - - -Value& -ValueInternalArray::dereference ( const IteratorState& it ) -{ - JSON_ASSERT_MESSAGE ( it.array_ && - (it.currentPageIndex_ - it.array_->pages_)*itemsPerPage + it.currentItemIndex_ - < it.array_->size_, - "ValueInternalArray::dereference(): dereferencing invalid iterator" ); - return unsafeDereference ( it ); -} - -void -ValueInternalArray::makeBeginIterator ( IteratorState& it ) const -{ - it.array_ = const_cast ( this ); - it.currentItemIndex_ = 0; - it.currentPageIndex_ = pages_; -} - - -void -ValueInternalArray::makeIterator ( IteratorState& it, ArrayIndex index ) const -{ - it.array_ = const_cast ( this ); - it.currentItemIndex_ = index % itemsPerPage; - it.currentPageIndex_ = pages_ + index / itemsPerPage; -} - - -void -ValueInternalArray::makeEndIterator ( IteratorState& it ) const -{ - makeIterator ( it, size_ ); -} - - -ValueInternalArray::ValueInternalArray () - : pages_ ( 0 ) - , size_ ( 0 ) - , pageCount_ ( 0 ) -{ -} - - -ValueInternalArray::ValueInternalArray ( const ValueInternalArray& other ) - : pages_ ( 0 ) - , pageCount_ ( 0 ) - , size_ ( other.size_ ) -{ - PageIndex minNewPages = other.size_ / itemsPerPage; - arrayAllocator ()->reallocateArrayPageIndex ( pages_, pageCount_, minNewPages ); - JSON_ASSERT_MESSAGE ( pageCount_ >= minNewPages, - "ValueInternalArray::reserve(): bad reallocation" ); - IteratorState itOther; - other.makeBeginIterator ( itOther ); - Value* value; - - for ( ArrayIndex index = 0; index < size_; ++index, increment (itOther) ) - { - if ( index % itemsPerPage == 0 ) - { - PageIndex pageIndex = index / itemsPerPage; - value = arrayAllocator ()->allocateArrayPage (); - pages_[pageIndex] = value; - } - - new (value) Value ( dereference ( itOther ) ); - } -} - - -ValueInternalArray& -ValueInternalArray::operator = ( const ValueInternalArray& other ) -{ - ValueInternalArray temp ( other ); - swap ( temp ); - return *this; -} - - -ValueInternalArray::~ValueInternalArray () -{ - // destroy all constructed items - IteratorState it; - IteratorState itEnd; - makeBeginIterator ( it); - makeEndIterator ( itEnd ); - - for ( ; !equals (it, itEnd); increment (it) ) - { - Value* value = &dereference (it); - value->~Value (); - } - - // release all pages - PageIndex lastPageIndex = size_ / itemsPerPage; - - for ( PageIndex pageIndex = 0; pageIndex < lastPageIndex; ++pageIndex ) - arrayAllocator ()->releaseArrayPage ( pages_[pageIndex] ); - - // release pages index - arrayAllocator ()->releaseArrayPageIndex ( pages_, pageCount_ ); -} - - -void -ValueInternalArray::swap ( ValueInternalArray& other ) -{ - Value** tempPages = pages_; - pages_ = other.pages_; - other.pages_ = tempPages; - ArrayIndex tempSize = size_; - size_ = other.size_; - other.size_ = tempSize; - PageIndex tempPageCount = pageCount_; - pageCount_ = other.pageCount_; - other.pageCount_ = tempPageCount; -} - -void -ValueInternalArray::clear () -{ - ValueInternalArray dummy; - swap ( dummy ); -} - - -void -ValueInternalArray::resize ( ArrayIndex newSize ) -{ - if ( newSize == 0 ) - clear (); - else if ( newSize < size_ ) - { - IteratorState it; - IteratorState itEnd; - makeIterator ( it, newSize ); - makeIterator ( itEnd, size_ ); - - for ( ; !equals (it, itEnd); increment (it) ) - { - Value* value = &dereference (it); - value->~Value (); - } - - PageIndex pageIndex = (newSize + itemsPerPage - 1) / itemsPerPage; - PageIndex lastPageIndex = size_ / itemsPerPage; - - for ( ; pageIndex < lastPageIndex; ++pageIndex ) - arrayAllocator ()->releaseArrayPage ( pages_[pageIndex] ); - - size_ = newSize; - } - else if ( newSize > size_ ) - resolveReference ( newSize ); -} - - -void -ValueInternalArray::makeIndexValid ( ArrayIndex index ) -{ - // Need to enlarge page index ? - if ( index >= pageCount_ * itemsPerPage ) - { - PageIndex minNewPages = (index + 1) / itemsPerPage; - arrayAllocator ()->reallocateArrayPageIndex ( pages_, pageCount_, minNewPages ); - JSON_ASSERT_MESSAGE ( pageCount_ >= minNewPages, "ValueInternalArray::reserve(): bad reallocation" ); - } - - // Need to allocate new pages ? - ArrayIndex nextPageIndex = - (size_ % itemsPerPage) != 0 ? size_ - (size_ % itemsPerPage) + itemsPerPage - : size_; - - if ( nextPageIndex <= index ) - { - PageIndex pageIndex = nextPageIndex / itemsPerPage; - PageIndex pageToAllocate = (index - nextPageIndex) / itemsPerPage + 1; - - for ( ; pageToAllocate-- > 0; ++pageIndex ) - pages_[pageIndex] = arrayAllocator ()->allocateArrayPage (); - } - - // Initialize all new entries - IteratorState it; - IteratorState itEnd; - makeIterator ( it, size_ ); - size_ = index + 1; - makeIterator ( itEnd, size_ ); - - for ( ; !equals (it, itEnd); increment (it) ) - { - Value* value = &dereference (it); - new (value) Value (); // Construct a default value using placement new - } -} - -Value& -ValueInternalArray::resolveReference ( ArrayIndex index ) -{ - if ( index >= size_ ) - makeIndexValid ( index ); - - return pages_[index / itemsPerPage][index % itemsPerPage]; -} - -Value* -ValueInternalArray::find ( ArrayIndex index ) const -{ - if ( index >= size_ ) - return 0; - - return & (pages_[index / itemsPerPage][index % itemsPerPage]); -} - -ValueInternalArray::ArrayIndex -ValueInternalArray::size () const -{ - return size_; -} - -int -ValueInternalArray::distance ( const IteratorState& x, const IteratorState& y ) -{ - return indexOf (y) - indexOf (x); -} - - -ValueInternalArray::ArrayIndex -ValueInternalArray::indexOf ( const IteratorState& iterator ) -{ - if ( !iterator.array_ ) - return ArrayIndex (-1); - - return ArrayIndex ( - (iterator.currentPageIndex_ - iterator.array_->pages_) * itemsPerPage - + iterator.currentItemIndex_ ); -} - - -int -ValueInternalArray::compare ( const ValueInternalArray& other ) const -{ - int sizeDiff ( size_ - other.size_ ); - - if ( sizeDiff != 0 ) - return sizeDiff; - - for ( ArrayIndex index = 0; index < size_; ++index ) - { - int diff = pages_[index / itemsPerPage][index % itemsPerPage].compare ( - other.pages_[index / itemsPerPage][index % itemsPerPage] ); - - if ( diff != 0 ) - return diff; - } - - return 0; -} diff --git a/src/ripple/json/impl/json_internalmap.inl b/src/ripple/json/impl/json_internalmap.inl deleted file mode 100644 index 94b693dd3b..0000000000 --- a/src/ripple/json/impl/json_internalmap.inl +++ /dev/null @@ -1,671 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of rippled: https://github.com/ripple/rippled - Copyright (c) 2012, 2013 Ripple Labs Inc. - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -// included by json_value.cpp -// everything is within Json namespace - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueInternalMap -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -/** \internal MUST be safely initialized using memset( this, 0, sizeof(ValueInternalLink) ); - * This optimization is used by the fast allocator. - */ -ValueInternalLink::ValueInternalLink () - : previous_ ( 0 ) - , next_ ( 0 ) -{ -} - -ValueInternalLink::~ValueInternalLink () -{ - for ( int index = 0; index < itemPerLink; ++index ) - { - if ( !items_[index].isItemAvailable () ) - { - if ( !items_[index].isMemberNameStatic () ) - free ( keys_[index] ); - } - else - break; - } -} - - - -ValueMapAllocator::~ValueMapAllocator () -{ -} - -#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -class DefaultValueMapAllocator : public ValueMapAllocator -{ -public: // overridden from ValueMapAllocator - virtual ValueInternalMap* newMap () - { - return new ValueInternalMap (); - } - - virtual ValueInternalMap* newMapCopy ( const ValueInternalMap& other ) - { - return new ValueInternalMap ( other ); - } - - virtual void destructMap ( ValueInternalMap* map ) - { - delete map; - } - - virtual ValueInternalLink* allocateMapBuckets ( unsigned int size ) - { - return new ValueInternalLink[size]; - } - - virtual void releaseMapBuckets ( ValueInternalLink* links ) - { - delete [] links; - } - - virtual ValueInternalLink* allocateMapLink () - { - return new ValueInternalLink (); - } - - virtual void releaseMapLink ( ValueInternalLink* link ) - { - delete link; - } -}; -#else -/// @todo make this thread-safe (lock when accessign batch allocator) -class DefaultValueMapAllocator : public ValueMapAllocator -{ -public: // overridden from ValueMapAllocator - virtual ValueInternalMap* newMap () - { - ValueInternalMap* map = mapsAllocator_.allocate (); - new (map) ValueInternalMap (); // placement new - return map; - } - - virtual ValueInternalMap* newMapCopy ( const ValueInternalMap& other ) - { - ValueInternalMap* map = mapsAllocator_.allocate (); - new (map) ValueInternalMap ( other ); // placement new - return map; - } - - virtual void destructMap ( ValueInternalMap* map ) - { - if ( map ) - { - map->~ValueInternalMap (); - mapsAllocator_.release ( map ); - } - } - - virtual ValueInternalLink* allocateMapBuckets ( unsigned int size ) - { - return new ValueInternalLink[size]; - } - - virtual void releaseMapBuckets ( ValueInternalLink* links ) - { - delete [] links; - } - - virtual ValueInternalLink* allocateMapLink () - { - ValueInternalLink* link = linksAllocator_.allocate (); - memset ( link, 0, sizeof (ValueInternalLink) ); - return link; - } - - virtual void releaseMapLink ( ValueInternalLink* link ) - { - link->~ValueInternalLink (); - linksAllocator_.release ( link ); - } -private: - BatchAllocator mapsAllocator_; - BatchAllocator linksAllocator_; -}; -#endif - -static ValueMapAllocator*& mapAllocator () -{ - static DefaultValueMapAllocator defaultAllocator; - static ValueMapAllocator* mapAllocator = &defaultAllocator; - return mapAllocator; -} - -static struct DummyMapAllocatorInitializer -{ - DummyMapAllocatorInitializer () - { - mapAllocator (); // ensure mapAllocator() statics are initialized before main(). - } -} dummyMapAllocatorInitializer; - - - -// h(K) = value * K >> w ; with w = 32 & K prime w.r.t. 2^32. - -/* -use linked list hash map. -buckets array is a container. -linked list element contains 6 key/values. (memory = (16+4) * 6 + 4 = 124) -value have extra state: valid, available, deleted -*/ - - -ValueInternalMap::ValueInternalMap () - : buckets_ ( 0 ) - , tailLink_ ( 0 ) - , bucketsSize_ ( 0 ) - , itemCount_ ( 0 ) -{ -} - - -ValueInternalMap::ValueInternalMap ( const ValueInternalMap& other ) - : buckets_ ( 0 ) - , tailLink_ ( 0 ) - , bucketsSize_ ( 0 ) - , itemCount_ ( 0 ) -{ - reserve ( other.itemCount_ ); - IteratorState it; - IteratorState itEnd; - other.makeBeginIterator ( it ); - other.makeEndIterator ( itEnd ); - - for ( ; !equals (it, itEnd); increment (it) ) - { - bool isStatic; - const char* memberName = key ( it, isStatic ); - const Value& aValue = value ( it ); - resolveReference (memberName, isStatic) = aValue; - } -} - - -ValueInternalMap& -ValueInternalMap::operator = ( const ValueInternalMap& other ) -{ - ValueInternalMap dummy ( other ); - swap ( dummy ); - return *this; -} - - -ValueInternalMap::~ValueInternalMap () -{ - if ( buckets_ ) - { - for ( BucketIndex bucketIndex = 0; bucketIndex < bucketsSize_; ++bucketIndex ) - { - ValueInternalLink* link = buckets_[bucketIndex].next_; - - while ( link ) - { - ValueInternalLink* linkToRelease = link; - link = link->next_; - mapAllocator ()->releaseMapLink ( linkToRelease ); - } - } - - mapAllocator ()->releaseMapBuckets ( buckets_ ); - } -} - - -void -ValueInternalMap::swap ( ValueInternalMap& other ) noexcept -{ - ValueInternalLink* tempBuckets = buckets_; - buckets_ = other.buckets_; - other.buckets_ = tempBuckets; - ValueInternalLink* tempTailLink = tailLink_; - tailLink_ = other.tailLink_; - other.tailLink_ = tempTailLink; - BucketIndex tempBucketsSize = bucketsSize_; - bucketsSize_ = other.bucketsSize_; - other.bucketsSize_ = tempBucketsSize; - BucketIndex tempItemCount = itemCount_; - itemCount_ = other.itemCount_; - other.itemCount_ = tempItemCount; -} - - -void -ValueInternalMap::clear () -{ - ValueInternalMap dummy; - swap ( dummy ); -} - - -ValueInternalMap::BucketIndex -ValueInternalMap::size () const -{ - return itemCount_; -} - -bool -ValueInternalMap::reserveDelta ( BucketIndex growth ) -{ - return reserve ( itemCount_ + growth ); -} - -bool -ValueInternalMap::reserve ( BucketIndex newItemCount ) -{ - if ( !buckets_ && newItemCount > 0 ) - { - buckets_ = mapAllocator ()->allocateMapBuckets ( 1 ); - bucketsSize_ = 1; - tailLink_ = &buckets_[0]; - } - - // BucketIndex idealBucketCount = (newItemCount + ValueInternalLink::itemPerLink) / ValueInternalLink::itemPerLink; - return true; -} - - -const Value* -ValueInternalMap::find ( const char* key ) const -{ - if ( !bucketsSize_ ) - return 0; - - HashKey hashedKey = hash ( key ); - BucketIndex bucketIndex = hashedKey % bucketsSize_; - - for ( const ValueInternalLink* current = &buckets_[bucketIndex]; - current != 0; - current = current->next_ ) - { - for ( BucketIndex index = 0; index < ValueInternalLink::itemPerLink; ++index ) - { - if ( current->items_[index].isItemAvailable () ) - return 0; - - if ( strcmp ( key, current->keys_[index] ) == 0 ) - return ¤t->items_[index]; - } - } - - return 0; -} - - -Value* -ValueInternalMap::find ( const char* key ) -{ - const ValueInternalMap* constThis = this; - return const_cast ( constThis->find ( key ) ); -} - - -Value& -ValueInternalMap::resolveReference ( const char* key, - bool isStatic ) -{ - HashKey hashedKey = hash ( key ); - - if ( bucketsSize_ ) - { - BucketIndex bucketIndex = hashedKey % bucketsSize_; - ValueInternalLink** previous = 0; - BucketIndex index; - - for ( ValueInternalLink* current = &buckets_[bucketIndex]; - current != 0; - previous = ¤t->next_, current = current->next_ ) - { - for ( index = 0; index < ValueInternalLink::itemPerLink; ++index ) - { - if ( current->items_[index].isItemAvailable () ) - return setNewItem ( key, isStatic, current, index ); - - if ( strcmp ( key, current->keys_[index] ) == 0 ) - return current->items_[index]; - } - } - } - - reserveDelta ( 1 ); - return unsafeAdd ( key, isStatic, hashedKey ); -} - - -void -ValueInternalMap::remove ( const char* key ) -{ - HashKey hashedKey = hash ( key ); - - if ( !bucketsSize_ ) - return; - - BucketIndex bucketIndex = hashedKey % bucketsSize_; - - for ( ValueInternalLink* link = &buckets_[bucketIndex]; - link != 0; - link = link->next_ ) - { - BucketIndex index; - - for ( index = 0; index < ValueInternalLink::itemPerLink; ++index ) - { - if ( link->items_[index].isItemAvailable () ) - return; - - if ( strcmp ( key, link->keys_[index] ) == 0 ) - { - doActualRemove ( link, index, bucketIndex ); - return; - } - } - } -} - -void -ValueInternalMap::doActualRemove ( ValueInternalLink* link, - BucketIndex index, - BucketIndex bucketIndex ) -{ - // find last item of the bucket and swap it with the 'removed' one. - // set removed items flags to 'available'. - // if last page only contains 'available' items, then desallocate it (it's empty) - ValueInternalLink*& lastLink = getLastLinkInBucket ( index ); - BucketIndex lastItemIndex = 1; // a link can never be empty, so start at 1 - - for ( ; - lastItemIndex < ValueInternalLink::itemPerLink; - ++lastItemIndex ) // may be optimized with dicotomic search - { - if ( lastLink->items_[lastItemIndex].isItemAvailable () ) - break; - } - - BucketIndex lastUsedIndex = lastItemIndex - 1; - Value* valueToDelete = &link->items_[index]; - Value* valueToPreserve = &lastLink->items_[lastUsedIndex]; - - if ( valueToDelete != valueToPreserve ) - valueToDelete->swap ( *valueToPreserve ); - - if ( lastUsedIndex == 0 ) // page is now empty - { - // remove it from bucket linked list and delete it. - ValueInternalLink* linkPreviousToLast = lastLink->previous_; - - if ( linkPreviousToLast != 0 ) // can not deleted bucket link. - { - mapAllocator ()->releaseMapLink ( lastLink ); - linkPreviousToLast->next_ = 0; - lastLink = linkPreviousToLast; - } - } - else - { - Value dummy; - valueToPreserve->swap ( dummy ); // restore deleted to default Value. - valueToPreserve->setItemUsed ( false ); - } - - --itemCount_; -} - - -ValueInternalLink*& -ValueInternalMap::getLastLinkInBucket ( BucketIndex bucketIndex ) -{ - if ( bucketIndex == bucketsSize_ - 1 ) - return tailLink_; - - ValueInternalLink*& previous = buckets_[bucketIndex + 1].previous_; - - if ( !previous ) - previous = &buckets_[bucketIndex]; - - return previous; -} - - -Value& -ValueInternalMap::setNewItem ( const char* key, - bool isStatic, - ValueInternalLink* link, - BucketIndex index ) -{ - char* duplicatedKey = valueAllocator ()->makeMemberName ( key ); - ++itemCount_; - link->keys_[index] = duplicatedKey; - link->items_[index].setItemUsed (); - link->items_[index].setMemberNameIsStatic ( isStatic ); - return link->items_[index]; // items already default constructed. -} - - -Value& -ValueInternalMap::unsafeAdd ( const char* key, - bool isStatic, - HashKey hashedKey ) -{ - JSON_ASSERT_MESSAGE ( bucketsSize_ > 0, "ValueInternalMap::unsafeAdd(): internal logic error." ); - BucketIndex bucketIndex = hashedKey % bucketsSize_; - ValueInternalLink*& previousLink = getLastLinkInBucket ( bucketIndex ); - ValueInternalLink* link = previousLink; - BucketIndex index; - - for ( index = 0; index < ValueInternalLink::itemPerLink; ++index ) - { - if ( link->items_[index].isItemAvailable () ) - break; - } - - if ( index == ValueInternalLink::itemPerLink ) // need to add a new page - { - ValueInternalLink* newLink = mapAllocator ()->allocateMapLink (); - index = 0; - link->next_ = newLink; - previousLink = newLink; - link = newLink; - } - - return setNewItem ( key, isStatic, link, index ); -} - - -ValueInternalMap::HashKey -ValueInternalMap::hash ( const char* key ) const -{ - HashKey hash = 0; - - while ( *key ) - hash += *key++ * 37; - - return hash; -} - - -int -ValueInternalMap::compare ( const ValueInternalMap& other ) const -{ - int sizeDiff ( itemCount_ - other.itemCount_ ); - - if ( sizeDiff != 0 ) - return sizeDiff; - - // Strict order guaranty is required. Compare all keys FIRST, then compare values. - IteratorState it; - IteratorState itEnd; - makeBeginIterator ( it ); - makeEndIterator ( itEnd ); - - for ( ; !equals (it, itEnd); increment (it) ) - { - if ( !other.find ( key ( it ) ) ) - return 1; - } - - // All keys are equals, let's compare values - makeBeginIterator ( it ); - - for ( ; !equals (it, itEnd); increment (it) ) - { - const Value* otherValue = other.find ( key ( it ) ); - int valueDiff = value (it).compare ( *otherValue ); - - if ( valueDiff != 0 ) - return valueDiff; - } - - return 0; -} - - -void -ValueInternalMap::makeBeginIterator ( IteratorState& it ) const -{ - it.map_ = const_cast ( this ); - it.bucketIndex_ = 0; - it.itemIndex_ = 0; - it.link_ = buckets_; -} - - -void -ValueInternalMap::makeEndIterator ( IteratorState& it ) const -{ - it.map_ = const_cast ( this ); - it.bucketIndex_ = bucketsSize_; - it.itemIndex_ = 0; - it.link_ = 0; -} - - -bool -ValueInternalMap::equals ( const IteratorState& x, const IteratorState& other ) -{ - return x.map_ == other.map_ - && x.bucketIndex_ == other.bucketIndex_ - && x.link_ == other.link_ - && x.itemIndex_ == other.itemIndex_; -} - - -void -ValueInternalMap::incrementBucket ( IteratorState& iterator ) -{ - ++iterator.bucketIndex_; - JSON_ASSERT_MESSAGE ( iterator.bucketIndex_ <= iterator.map_->bucketsSize_, - "ValueInternalMap::increment(): attempting to iterate beyond end." ); - - if ( iterator.bucketIndex_ == iterator.map_->bucketsSize_ ) - iterator.link_ = 0; - else - iterator.link_ = & (iterator.map_->buckets_[iterator.bucketIndex_]); - - iterator.itemIndex_ = 0; -} - - -void -ValueInternalMap::increment ( IteratorState& iterator ) -{ - JSON_ASSERT_MESSAGE ( iterator.map_, "Attempting to iterator using invalid iterator." ); - ++iterator.itemIndex_; - - if ( iterator.itemIndex_ == ValueInternalLink::itemPerLink ) - { - JSON_ASSERT_MESSAGE ( iterator.link_ != 0, - "ValueInternalMap::increment(): attempting to iterate beyond end." ); - iterator.link_ = iterator.link_->next_; - - if ( iterator.link_ == 0 ) - incrementBucket ( iterator ); - } - else if ( iterator.link_->items_[iterator.itemIndex_].isItemAvailable () ) - { - incrementBucket ( iterator ); - } -} - - -void -ValueInternalMap::decrement ( IteratorState& iterator ) -{ - if ( iterator.itemIndex_ == 0 ) - { - JSON_ASSERT_MESSAGE ( iterator.map_, "Attempting to iterate using invalid iterator." ); - - if ( iterator.link_ == &iterator.map_->buckets_[iterator.bucketIndex_] ) - { - JSON_ASSERT_MESSAGE ( iterator.bucketIndex_ > 0, "Attempting to iterate beyond beginning." ); - -- (iterator.bucketIndex_); - } - - iterator.link_ = iterator.link_->previous_; - iterator.itemIndex_ = ValueInternalLink::itemPerLink - 1; - } -} - - -const char* -ValueInternalMap::key ( const IteratorState& iterator ) -{ - JSON_ASSERT_MESSAGE ( iterator.link_, "Attempting to iterate using invalid iterator." ); - return iterator.link_->keys_[iterator.itemIndex_]; -} - -const char* -ValueInternalMap::key ( const IteratorState& iterator, bool& isStatic ) -{ - JSON_ASSERT_MESSAGE ( iterator.link_, "Attempting to iterate using invalid iterator." ); - isStatic = iterator.link_->items_[iterator.itemIndex_].isMemberNameStatic (); - return iterator.link_->keys_[iterator.itemIndex_]; -} - - -Value& -ValueInternalMap::value ( const IteratorState& iterator ) -{ - JSON_ASSERT_MESSAGE ( iterator.link_, "Attempting to iterate using invalid iterator." ); - return iterator.link_->items_[iterator.itemIndex_]; -} - - -int -ValueInternalMap::distance ( const IteratorState& x, const IteratorState& y ) -{ - int offset = 0; - IteratorState it = x; - - while ( !equals ( it, y ) ) - increment ( it ); - - return offset; -} diff --git a/src/ripple/json/impl/json_reader.cpp b/src/ripple/json/impl/json_reader.cpp index 5c789e2bc0..d7cd759956 100644 --- a/src/ripple/json/impl/json_reader.cpp +++ b/src/ripple/json/impl/json_reader.cpp @@ -20,65 +20,16 @@ #include #include #include +#include namespace Json { - -// Implementation of class Features -// //////////////////////////////// - -Features::Features () - : allowComments_ ( true ) - , strictRoot_ ( false ) -{ -} - - -Features -Features::all () -{ - return Features (); -} - - -Features -Features::strictMode () -{ - Features features; - features.allowComments_ = false; - features.strictRoot_ = true; - return features; -} - // Implementation of class Reader // //////////////////////////////// - -static inline bool -in ( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4 ) -{ - return c == c1 || c == c2 || c == c3 || c == c4; -} - -static inline bool -in ( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4, Reader::Char c5 ) -{ - return c == c1 || c == c2 || c == c3 || c == c4 || c == c5; -} - - -static bool -containsNewLine ( Reader::Location begin, - Reader::Location end ) -{ - for ( ; begin < end; ++begin ) - if ( *begin == '\n' || *begin == '\r' ) - return true; - - return false; -} - -static std::string codePointToUTF8 (unsigned int cp) +static +std::string +codePointToUTF8 (unsigned int cp) { std::string result; @@ -119,33 +70,24 @@ static std::string codePointToUTF8 (unsigned int cp) // ////////////////////////////////////////////////////////////////// Reader::Reader () - : features_ ( Features::all () ) -{ -} - - -Reader::Reader ( const Features& features ) - : features_ ( features ) { } bool Reader::parse ( std::string const& document, - Value& root, - bool collectComments ) + Value& root) { document_ = document; const char* begin = document_.c_str (); const char* end = begin + document_.length (); - return parse ( begin, end, root, collectComments ); + return parse ( begin, end, root ); } bool Reader::parse ( std::istream& sin, - Value& root, - bool collectComments ) + Value& root) { //std::istream_iterator begin(sin); //std::istream_iterator end; @@ -156,26 +98,18 @@ Reader::parse ( std::istream& sin, // create an extra copy. std::string doc; std::getline (sin, doc, (char)EOF); - return parse ( doc, root, collectComments ); + return parse ( doc, root ); } bool Reader::parse ( const char* beginDoc, const char* endDoc, - Value& root, - bool collectComments ) + Value& root) { - if ( !features_.allowComments_ ) - { - collectComments = false; - } - begin_ = beginDoc; end_ = endDoc; - collectComments_ = collectComments; current_ = begin_; lastValueEnd_ = 0; lastValue_ = 0; - commentsBefore_ = ""; errors_.clear (); while ( !nodes_.empty () ) @@ -187,27 +121,20 @@ Reader::parse ( const char* beginDoc, const char* endDoc, Token token; skipCommentTokens ( token ); - if ( collectComments_ && !commentsBefore_.empty () ) - root.setComment ( commentsBefore_, commentAfter ); - - if ( features_.strictRoot_ ) + if ( !root.isArray () && !root.isObject () ) { - if ( !root.isArray () && !root.isObject () ) - { - // Set error location to start of doc, ideally should be first token found in doc - token.type_ = tokenError; - token.start_ = beginDoc; - token.end_ = endDoc; - addError ( "A valid JSON document must be either an array or an object value.", - token ); - return false; - } + // Set error location to start of doc, ideally should be first token found in doc + token.type_ = tokenError; + token.start_ = beginDoc; + token.end_ = endDoc; + addError ( "A valid JSON document must be either an array or an object value.", + token ); + return false; } return successful; } - bool Reader::readValue () { @@ -215,13 +142,6 @@ Reader::readValue () skipCommentTokens ( token ); bool successful = true; - if ( collectComments_ && !commentsBefore_.empty () ) - { - currentValue ().setComment ( commentsBefore_, commentBefore ); - commentsBefore_ = ""; - } - - switch ( token.type_ ) { case tokenObjectBegin: @@ -232,10 +152,14 @@ Reader::readValue () successful = readArray ( token ); break; - case tokenNumber: + case tokenInteger: successful = decodeNumber ( token ); break; + case tokenDouble: + successful = decodeDouble ( token ); + break; + case tokenString: successful = decodeString ( token ); break; @@ -256,12 +180,6 @@ Reader::readValue () return addError ( "Syntax error: value, object or array expected.", token ); } - if ( collectComments_ ) - { - lastValueEnd_ = current_; - lastValue_ = ¤tValue (); - } - return successful; } @@ -269,18 +187,11 @@ Reader::readValue () void Reader::skipCommentTokens ( Token& token ) { - if ( features_.allowComments_ ) - { - do - { - readToken ( token ); - } - while ( token.type_ == tokenComment ); - } - else + do { readToken ( token ); } + while ( token.type_ == tokenComment ); } @@ -343,8 +254,7 @@ Reader::readToken ( Token& token ) case '8': case '9': case '-': - token.type_ = tokenNumber; - readNumber (); + token.type_ = readNumber (); break; case 't': @@ -423,57 +333,17 @@ Reader::match ( Location pattern, bool Reader::readComment () { - Location commentBegin = current_ - 1; Char c = getNextChar (); - bool successful = false; if ( c == '*' ) - successful = readCStyleComment (); - else if ( c == '/' ) - successful = readCppStyleComment (); + return readCStyleComment (); - if ( !successful ) - return false; + if ( c == '/' ) + return readCppStyleComment (); - if ( collectComments_ ) - { - CommentPlacement placement = commentBefore; - - if ( lastValueEnd_ && !containsNewLine ( lastValueEnd_, commentBegin ) ) - { - if ( c != '*' || !containsNewLine ( commentBegin, current_ ) ) - placement = commentAfterOnSameLine; - } - - addComment ( commentBegin, current_, placement ); - } - - return true; + return false; } - -void -Reader::addComment ( Location begin, - Location end, - CommentPlacement placement ) -{ - assert ( collectComments_ ); - - if ( placement == commentAfterOnSameLine ) - { - assert ( lastValue_ != 0 ); - lastValue_->setComment ( std::string ( begin, end ), placement ); - } - else - { - if ( !commentsBefore_.empty () ) - commentsBefore_ += "\n"; - - commentsBefore_ += std::string ( begin, end ); - } -} - - bool Reader::readCStyleComment () { @@ -503,18 +373,36 @@ Reader::readCppStyleComment () return true; } - -void +Reader::TokenType Reader::readNumber () { - while ( current_ != end_ ) - { - if ( ! (*current_ >= '0' && *current_ <= '9') && - !in ( *current_, '.', 'e', 'E', '+', '-' ) ) - break; + static char const extended_tokens[] = { '.', 'e', 'E', '+', '-' }; - ++current_; + TokenType type = tokenInteger; + + if ( current_ != end_ ) + { + if (*current_ == '-') + ++current_; + + while ( current_ != end_ ) + { + if (!std::isdigit (*current_)) + { + auto ret = std::find (std::begin (extended_tokens), + std::end (extended_tokens), *current_); + + if (ret == std::end (extended_tokens)) + break; + + type = tokenDouble; + } + + ++current_; + } } + + return type; } bool @@ -664,28 +552,29 @@ Reader::readArray ( Token& tokenStart ) return true; } +static inline bool +in ( Reader::Char c, Reader::Char c1, Reader::Char c2, Reader::Char c3, Reader::Char c4 ) +{ + return c == c1 || c == c2 || c == c3 || c == c4; +} bool Reader::decodeNumber ( Token& token ) { - bool isDouble = false; - - for ( Location inspect = token.start_; inspect != token.end_; ++inspect ) - { - isDouble = isDouble - || in ( *inspect, '.', 'e', 'E', '+' ) - || ( *inspect == '-' && inspect != token.start_ ); - } - - if ( isDouble ) - return decodeDouble ( token ); - Location current = token.start_; bool isNegative = *current == '-'; if ( isNegative ) ++current; + if (current == token.end_) + { + return addError ( "'" + std::string ( token.start_, token.end_ ) + + "' is not a valid number.", token ); + } + + // The existing Json integers are 32-bit so using a 64-bit value here avoids + // overflows in the conversion code below. std::int64_t value = 0; static_assert(sizeof(value) > sizeof(Value::maxUInt), @@ -1063,7 +952,7 @@ Reader::getFormatedErrorMessages () const std::istream& operator>> ( std::istream& sin, Value& root ) { Json::Reader reader; - bool ok = reader.parse (sin, root, true); + bool ok = reader.parse (sin, root); //JSON_ASSERT( ok ); if (!ok) throw std::runtime_error (reader.getFormatedErrorMessages ()); diff --git a/src/ripple/json/impl/json_value.cpp b/src/ripple/json/impl/json_value.cpp index bb6e108d9c..f0e9ce749f 100644 --- a/src/ripple/json/impl/json_value.cpp +++ b/src/ripple/json/impl/json_value.cpp @@ -125,48 +125,9 @@ static struct DummyValueAllocatorInitializer // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// -#ifdef JSON_VALUE_USE_INTERNAL_MAP -# include -# include -#endif // JSON_VALUE_USE_INTERNAL_MAP - # include -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// 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 ); -} - - // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// @@ -174,7 +135,6 @@ Value::CommentInfo::setComment ( const char* text ) // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// -# ifndef JSON_VALUE_USE_INTERNAL_MAP // Notes: index_ indicates if the string was allocated when // a string is stored. @@ -260,9 +220,6 @@ Value::CZString::isStaticString () const return index_ == noDuplication; } -#endif // ifndef JSON_VALUE_USE_INTERNAL_MAP - - // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// @@ -278,10 +235,6 @@ Value::CZString::isStaticString () const Value::Value ( ValueType type ) : type_ ( type ) , allocated_ ( 0 ) - , comments_ ( 0 ) -# ifdef JSON_VALUE_USE_INTERNAL_MAP - , itemIsUsed_ ( 0 ) -#endif { switch ( type ) { @@ -300,22 +253,11 @@ Value::Value ( ValueType type ) 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; @@ -329,10 +271,6 @@ Value::Value ( ValueType type ) Value::Value ( Int value ) : type_ ( intValue ) - , comments_ ( 0 ) -# ifdef JSON_VALUE_USE_INTERNAL_MAP - , itemIsUsed_ ( 0 ) -#endif { value_.int_ = value; } @@ -340,20 +278,12 @@ Value::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; } @@ -361,10 +291,6 @@ Value::Value ( double 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 ); } @@ -374,10 +300,6 @@ 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) ); @@ -387,10 +309,6 @@ Value::Value ( const char* beginValue, Value::Value ( std::string const& 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 () ); @@ -400,10 +318,6 @@ Value::Value ( std::string const& value ) Value::Value (beast::String const& beastString) : type_ ( stringValue ) , allocated_ ( true ) - , comments_ ( 0 ) -# ifdef JSON_VALUE_USE_INTERNAL_MAP - , itemIsUsed_ ( 0 ) -#endif { value_.string_ = valueAllocator ()->duplicateStringValue ( beastString.toStdString ().c_str (), (unsigned int)beastString.length () ); @@ -413,34 +327,12 @@ Value::Value (beast::String const& beastString) Value::Value ( const StaticString& value ) : type_ ( stringValue ) , allocated_ ( false ) - , comments_ ( 0 ) -# ifdef JSON_VALUE_USE_INTERNAL_MAP - , itemIsUsed_ ( 0 ) -#endif { value_.string_ = const_cast ( 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; } @@ -448,10 +340,6 @@ Value::Value ( bool value ) Value::Value ( const Value& other ) : type_ ( other.type_ ) - , comments_ ( 0 ) -# ifdef JSON_VALUE_USE_INTERNAL_MAP - , itemIsUsed_ ( 0 ) -#endif { switch ( type_ ) { @@ -473,39 +361,15 @@ Value::Value ( const Value& other ) 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_ ); - } - } } @@ -525,29 +389,15 @@ Value::~Value () 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& @@ -562,11 +412,6 @@ Value::Value ( Value&& other ) noexcept : value_ ( other.value_ ) , type_ ( other.type_ ) , allocated_ ( other.allocated_ ) -# ifdef JSON_VALUE_USE_INTERNAL_MAP - , itemIsUsed_ ( other.itemIsUsed_ ) - , memberNameIsStatic_ ( other.memberNameIsStatic_ ) -#endif // JSON_VALUE_USE_INTERNAL_MAP - , comments_ ( other.comments_ ) { std::memset( &other, 0, sizeof(Value) ); } @@ -590,17 +435,6 @@ Value::swap ( Value& other ) noexcept int temp2 = allocated_; allocated_ = other.allocated_; other.allocated_ = temp2; - -# ifdef JSON_VALUE_USE_INTERNAL_MAP - unsigned temp3 = itemIsUsed_; - itemIsUsed_ = other.itemIsUsed_; - other.itemIsUsed_ = itemIsUsed_; - - temp2 = memberNameIsStatic_; - memberNameIsStatic_ = other.memberNameIsStatic_; - other.memberNameIsStatic_ = temp2 -# endif - std::swap(comments_, other.comments_); } ValueType @@ -670,7 +504,6 @@ Value::operator < ( const Value& other ) const || ( other.value_.string_ && value_.string_ && strcmp ( value_.string_, other.value_.string_ ) < 0 ); -#ifndef JSON_VALUE_USE_INTERNAL_MAP case arrayValue: case objectValue: @@ -683,15 +516,6 @@ Value::operator < ( const Value& other ) const 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; } @@ -751,20 +575,11 @@ Value::operator == ( const Value& other ) const || ( 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; @@ -817,14 +632,6 @@ Value::asString () const return ""; // unreachable } -# ifdef JSON_USE_CPPTL -CppTL::ConstString -Value::asConstString () const -{ - return CppTL::ConstString ( asString ().c_str () ); -} -# endif - Value::Int Value::asInt () const { @@ -1035,7 +842,6 @@ Value::size () const 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 () ) @@ -1049,14 +855,6 @@ Value::size () const 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; @@ -1090,22 +888,10 @@ Value::clear () 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; @@ -1120,7 +906,6 @@ Value::resize ( UInt newSize ) if ( type_ == nullValue ) *this = Value ( arrayValue ); -#ifndef JSON_VALUE_USE_INTERNAL_MAP UInt oldSize = size (); if ( newSize == 0 ) @@ -1134,10 +919,6 @@ Value::resize ( UInt newSize ) assert ( size () == newSize ); } - -#else - value_.array_->resize ( newSize ); -#endif } @@ -1149,7 +930,6 @@ Value::operator[] ( UInt index ) if ( type_ == nullValue ) *this = Value ( arrayValue ); -#ifndef JSON_VALUE_USE_INTERNAL_MAP CZString key ( index ); ObjectValues::iterator it = value_.map_->lower_bound ( key ); @@ -1159,9 +939,6 @@ Value::operator[] ( UInt index ) ObjectValues::value_type defaultValue ( key, null ); it = value_.map_->insert ( it, defaultValue ); return (*it).second; -#else - return value_.array_->resolveReference ( index ); -#endif } @@ -1173,7 +950,6 @@ Value::operator[] ( UInt index ) const if ( type_ == nullValue ) return null; -#ifndef JSON_VALUE_USE_INTERNAL_MAP CZString key ( index ); ObjectValues::const_iterator it = value_.map_->find ( key ); @@ -1181,10 +957,6 @@ Value::operator[] ( UInt index ) const return null; return (*it).second; -#else - Value* value = value_.array_->find ( index ); - return value ? *value : null; -#endif } @@ -1204,7 +976,6 @@ Value::resolveReference ( const char* key, 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 ); @@ -1216,9 +987,6 @@ Value::resolveReference ( const char* key, it = value_.map_->insert ( it, defaultValue ); Value& value = (*it).second; return value; -#else - return value_.map_->resolveReference ( key, isStatic ); -#endif } @@ -1247,7 +1015,6 @@ Value::operator[] ( const char* key ) const if ( type_ == nullValue ) return null; -#ifndef JSON_VALUE_USE_INTERNAL_MAP CZString actualKey ( key, CZString::noDuplication ); ObjectValues::const_iterator it = value_.map_->find ( actualKey ); @@ -1255,10 +1022,6 @@ Value::operator[] ( const char* key ) const return null; return (*it).second; -#else - const Value* value = value_.map_->find ( key ); - return value ? *value : null; -#endif } @@ -1281,23 +1044,6 @@ 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 ) { @@ -1329,7 +1075,6 @@ Value::removeMember ( const char* key ) if ( type_ == nullValue ) return null; -#ifndef JSON_VALUE_USE_INTERNAL_MAP CZString actualKey ( key, CZString::noDuplication ); ObjectValues::iterator it = value_.map_->find ( actualKey ); @@ -1339,21 +1084,6 @@ Value::removeMember ( const char* key ) 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 @@ -1362,15 +1092,6 @@ Value::removeMember ( std::string const& 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 { @@ -1386,14 +1107,6 @@ Value::isMember ( std::string const& key ) const } -# ifdef JSON_USE_CPPTL -bool -Value::isMember ( const CppTL::ConstString& key ) const -{ - return isMember ( key.c_str () ); -} -#endif - Value::Members Value::getMemberNames () const { @@ -1404,51 +1117,14 @@ Value::getMemberNames () const 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() ), -// MemberNamesTransform() ) ); -// } -// return EnumMemberNames(); -//} -// -// -//EnumValues -//Value::enumValues() const -//{ -// if ( type_ == objectValue || type_ == arrayValue ) -// return CppTL::Enum::anyValues( *(value_.map_), -// CppTL::Type() ); -// return EnumValues(); -//} -// -//# endif - bool Value::isNull () const @@ -1521,42 +1197,6 @@ 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 ( std::string const& 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 { @@ -1570,37 +1210,12 @@ 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; } @@ -1613,37 +1228,12 @@ 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; } @@ -1657,37 +1247,11 @@ 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; } @@ -1700,37 +1264,11 @@ 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; } @@ -1738,238 +1276,4 @@ Value::end () 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 ( std::string const& key ) - : key_ ( key.c_str () ) - , kind_ ( kindKey ) -{ -} - -// class Path -// ////////////////////////////////////////////////////////////////// - -Path::Path ( std::string const& 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 ( std::string const& 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 ( std::string const& 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 ( std::string const& 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 diff --git a/src/ripple/json/impl/json_valueiterator.inl b/src/ripple/json/impl/json_valueiterator.inl index c26562ea13..a4c45e4430 100644 --- a/src/ripple/json/impl/json_valueiterator.inl +++ b/src/ripple/json/impl/json_valueiterator.inl @@ -30,95 +30,41 @@ // ////////////////////////////////////////////////////////////////// ValueIteratorBase::ValueIteratorBase () -#ifndef JSON_VALUE_USE_INTERNAL_MAP : current_ () , isNull_ ( true ) { } -#else - : - isArray_ ( true ) - , isNull_ ( true ) -{ - iterator_.array_ = ValueInternalArray::IteratorState (); -} -#endif - -#ifndef JSON_VALUE_USE_INTERNAL_MAP ValueIteratorBase::ValueIteratorBase ( const Value::ObjectValues::iterator& current ) : current_ ( current ) , isNull_ ( false ) { } -#else -ValueIteratorBase::ValueIteratorBase ( const ValueInternalArray::IteratorState& state ) - : isArray_ ( true ) -{ - iterator_.array_ = state; -} - - -ValueIteratorBase::ValueIteratorBase ( const ValueInternalMap::IteratorState& state ) - : isArray_ ( false ) -{ - iterator_.map_ = state; -} -#endif Value& ValueIteratorBase::deref () const { -#ifndef JSON_VALUE_USE_INTERNAL_MAP return current_->second; -#else - - if ( isArray_ ) - return ValueInternalArray::dereference ( iterator_.array_ ); - - return ValueInternalMap::value ( iterator_.map_ ); -#endif } void ValueIteratorBase::increment () { -#ifndef JSON_VALUE_USE_INTERNAL_MAP ++current_; -#else - - if ( isArray_ ) - ValueInternalArray::increment ( iterator_.array_ ); - - ValueInternalMap::increment ( iterator_.map_ ); -#endif } void ValueIteratorBase::decrement () { -#ifndef JSON_VALUE_USE_INTERNAL_MAP --current_; -#else - - if ( isArray_ ) - ValueInternalArray::decrement ( iterator_.array_ ); - - ValueInternalMap::decrement ( iterator_.map_ ); -#endif } ValueIteratorBase::difference_type ValueIteratorBase::computeDistance ( const SelfType& other ) const { -#ifndef JSON_VALUE_USE_INTERNAL_MAP -# ifdef JSON_USE_CPPTL_SMALLMAP - return current_ - other.current_; -# else - // Iterator for null value are initialized using the default // constructor, which initialize current_ to the default // std::map::iterator. As begin() and end() are two instance @@ -142,57 +88,31 @@ ValueIteratorBase::computeDistance ( const SelfType& other ) const } return myDistance; -# endif -#else - - if ( isArray_ ) - return ValueInternalArray::distance ( iterator_.array_, other.iterator_.array_ ); - - return ValueInternalMap::distance ( iterator_.map_, other.iterator_.map_ ); -#endif } bool ValueIteratorBase::isEqual ( const SelfType& other ) const { -#ifndef JSON_VALUE_USE_INTERNAL_MAP - if ( isNull_ ) { return other.isNull_; } return current_ == other.current_; -#else - - if ( isArray_ ) - return ValueInternalArray::equals ( iterator_.array_, other.iterator_.array_ ); - - return ValueInternalMap::equals ( iterator_.map_, other.iterator_.map_ ); -#endif } void ValueIteratorBase::copy ( const SelfType& other ) { -#ifndef JSON_VALUE_USE_INTERNAL_MAP current_ = other.current_; -#else - - if ( isArray_ ) - iterator_.array_ = other.iterator_.array_; - - iterator_.map_ = other.iterator_.map_; -#endif } Value ValueIteratorBase::key () const { -#ifndef JSON_VALUE_USE_INTERNAL_MAP const Value::CZString czstring = (*current_).first; if ( czstring.c_str () ) @@ -204,55 +124,26 @@ ValueIteratorBase::key () const } return Value ( czstring.index () ); -#else - - if ( isArray_ ) - return Value ( ValueInternalArray::indexOf ( iterator_.array_ ) ); - - bool isStatic; - const char* memberName = ValueInternalMap::key ( iterator_.map_, isStatic ); - - if ( isStatic ) - return Value ( StaticString ( memberName ) ); - - return Value ( memberName ); -#endif } UInt ValueIteratorBase::index () const { -#ifndef JSON_VALUE_USE_INTERNAL_MAP const Value::CZString czstring = (*current_).first; if ( !czstring.c_str () ) return czstring.index (); return Value::UInt ( -1 ); -#else - - if ( isArray_ ) - return Value::UInt ( ValueInternalArray::indexOf ( iterator_.array_ ) ); - - return Value::UInt ( -1 ); -#endif } const char* ValueIteratorBase::memberName () const { -#ifndef JSON_VALUE_USE_INTERNAL_MAP const char* name = (*current_).first.c_str (); return name ? name : ""; -#else - - if ( !isArray_ ) - return ValueInternalMap::key ( iterator_.map_ ); - - return ""; -#endif } @@ -268,23 +159,10 @@ ValueConstIterator::ValueConstIterator () { } - -#ifndef JSON_VALUE_USE_INTERNAL_MAP ValueConstIterator::ValueConstIterator ( const Value::ObjectValues::iterator& current ) : ValueIteratorBase ( current ) { } -#else -ValueConstIterator::ValueConstIterator ( const ValueInternalArray::IteratorState& state ) - : ValueIteratorBase ( state ) -{ -} - -ValueConstIterator::ValueConstIterator ( const ValueInternalMap::IteratorState& state ) - : ValueIteratorBase ( state ) -{ -} -#endif ValueConstIterator& ValueConstIterator::operator = ( const ValueIteratorBase& other ) @@ -307,22 +185,10 @@ ValueIterator::ValueIterator () } -#ifndef JSON_VALUE_USE_INTERNAL_MAP ValueIterator::ValueIterator ( const Value::ObjectValues::iterator& current ) : ValueIteratorBase ( current ) { } -#else -ValueIterator::ValueIterator ( const ValueInternalArray::IteratorState& state ) - : ValueIteratorBase ( state ) -{ -} - -ValueIterator::ValueIterator ( const ValueInternalMap::IteratorState& state ) - : ValueIteratorBase ( state ) -{ -} -#endif ValueIterator::ValueIterator ( const ValueConstIterator& other ) : ValueIteratorBase ( other ) diff --git a/src/ripple/json/impl/json_writer.cpp b/src/ripple/json/impl/json_writer.cpp index 8852a7efb2..433e53a015 100644 --- a/src/ripple/json/impl/json_writer.cpp +++ b/src/ripple/json/impl/json_writer.cpp @@ -189,18 +189,9 @@ Writer::~Writer () // ////////////////////////////////////////////////////////////////// FastWriter::FastWriter () - : yamlCompatiblityEnabled_ ( false ) { } - -void -FastWriter::enableYAMLCompatibility () -{ - yamlCompatiblityEnabled_ = true; -} - - std::string FastWriter::write ( const Value& root ) { @@ -272,8 +263,7 @@ FastWriter::writeValue ( const Value& value ) document_ += ","; document_ += valueToQuotedString ( name.c_str () ); - document_ += yamlCompatiblityEnabled_ ? ": " - : ":"; + document_ += ":"; writeValue ( value[name] ); } @@ -300,9 +290,7 @@ StyledWriter::write ( const Value& root ) document_ = ""; addChildValues_ = false; indentString_ = ""; - writeCommentBeforeValue ( root ); writeValue ( root ); - writeCommentAfterValueOnSameLine ( root ); document_ += "\n"; return document_; } @@ -357,19 +345,14 @@ StyledWriter::writeValue ( const Value& value ) { std::string const& name = *it; const Value& childValue = value[name]; - writeCommentBeforeValue ( childValue ); writeWithIndent ( valueToQuotedString ( name.c_str () ) ); document_ += " : "; writeValue ( childValue ); if ( ++it == members.end () ) - { - writeCommentAfterValueOnSameLine ( childValue ); break; - } document_ += ","; - writeCommentAfterValueOnSameLine ( childValue ); } unindent (); @@ -402,7 +385,6 @@ StyledWriter::writeArrayValue ( const Value& value ) while ( true ) { const Value& childValue = value[index]; - writeCommentBeforeValue ( childValue ); if ( hasChildValue ) writeWithIndent ( childValues_[index] ); @@ -413,13 +395,9 @@ StyledWriter::writeArrayValue ( const Value& value ) } if ( ++index == size ) - { - writeCommentAfterValueOnSameLine ( childValue ); break; - } document_ += ","; - writeCommentAfterValueOnSameLine ( childValue ); } unindent (); @@ -465,11 +443,10 @@ StyledWriter::isMultineArray ( const Value& value ) addChildValues_ = true; int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' - for ( int index = 0; index < size && !isMultiLine; ++index ) + for ( int index = 0; index < size; ++index ) { writeValue ( value[index] ); lineLength += int ( childValues_[index].length () ); - isMultiLine = isMultiLine && hasCommentForValue ( value[index] ); } addChildValues_ = false; @@ -530,70 +507,6 @@ StyledWriter::unindent () indentString_.resize ( indentString_.size () - indentSize_ ); } - -void -StyledWriter::writeCommentBeforeValue ( const Value& root ) -{ - if ( !root.hasComment ( commentBefore ) ) - return; - - document_ += normalizeEOL ( root.getComment ( commentBefore ) ); - document_ += "\n"; -} - - -void -StyledWriter::writeCommentAfterValueOnSameLine ( const Value& root ) -{ - if ( root.hasComment ( commentAfterOnSameLine ) ) - document_ += " " + normalizeEOL ( root.getComment ( commentAfterOnSameLine ) ); - - if ( root.hasComment ( commentAfter ) ) - { - document_ += "\n"; - document_ += normalizeEOL ( root.getComment ( commentAfter ) ); - document_ += "\n"; - } -} - - -bool -StyledWriter::hasCommentForValue ( const Value& value ) -{ - return value.hasComment ( commentBefore ) - || value.hasComment ( commentAfterOnSameLine ) - || value.hasComment ( commentAfter ); -} - - -std::string -StyledWriter::normalizeEOL ( std::string const& text ) -{ - std::string normalized; - normalized.reserve ( text.length () ); - const char* begin = text.c_str (); - const char* end = begin + text.length (); - const char* current = begin; - - while ( current != end ) - { - char c = *current++; - - if ( c == '\r' ) // mac or dos EOL - { - if ( *current == '\n' ) // convert dos EOL - ++current; - - normalized += '\n'; - } - else // handle unix EOL & other char - normalized += c; - } - - return normalized; -} - - // Class StyledStreamWriter // ////////////////////////////////////////////////////////////////// @@ -611,9 +524,7 @@ StyledStreamWriter::write ( std::ostream& out, const Value& root ) document_ = &out; addChildValues_ = false; indentString_ = ""; - writeCommentBeforeValue ( root ); writeValue ( root ); - writeCommentAfterValueOnSameLine ( root ); *document_ << "\n"; document_ = nullptr; // Forget the stream, for safety. } @@ -668,19 +579,14 @@ StyledStreamWriter::writeValue ( const Value& value ) { std::string const& name = *it; const Value& childValue = value[name]; - writeCommentBeforeValue ( childValue ); writeWithIndent ( valueToQuotedString ( name.c_str () ) ); *document_ << " : "; writeValue ( childValue ); if ( ++it == members.end () ) - { - writeCommentAfterValueOnSameLine ( childValue ); break; - } *document_ << ","; - writeCommentAfterValueOnSameLine ( childValue ); } unindent (); @@ -713,7 +619,6 @@ StyledStreamWriter::writeArrayValue ( const Value& value ) while ( true ) { const Value& childValue = value[index]; - writeCommentBeforeValue ( childValue ); if ( hasChildValue ) writeWithIndent ( childValues_[index] ); @@ -724,13 +629,9 @@ StyledStreamWriter::writeArrayValue ( const Value& value ) } if ( ++index == size ) - { - writeCommentAfterValueOnSameLine ( childValue ); break; - } *document_ << ","; - writeCommentAfterValueOnSameLine ( childValue ); } unindent (); @@ -776,11 +677,10 @@ StyledStreamWriter::isMultineArray ( const Value& value ) addChildValues_ = true; int lineLength = 4 + (size - 1) * 2; // '[ ' + ', '*n + ' ]' - for ( int index = 0; index < size && !isMultiLine; ++index ) + for ( int index = 0; index < size; ++index ) { writeValue ( value[index] ); lineLength += int ( childValues_[index].length () ); - isMultiLine = isMultiLine && hasCommentForValue ( value[index] ); } addChildValues_ = false; @@ -843,69 +743,6 @@ StyledStreamWriter::unindent () } -void -StyledStreamWriter::writeCommentBeforeValue ( const Value& root ) -{ - if ( !root.hasComment ( commentBefore ) ) - return; - - *document_ << normalizeEOL ( root.getComment ( commentBefore ) ); - *document_ << "\n"; -} - - -void -StyledStreamWriter::writeCommentAfterValueOnSameLine ( const Value& root ) -{ - if ( root.hasComment ( commentAfterOnSameLine ) ) - *document_ << " " + normalizeEOL ( root.getComment ( commentAfterOnSameLine ) ); - - if ( root.hasComment ( commentAfter ) ) - { - *document_ << "\n"; - *document_ << normalizeEOL ( root.getComment ( commentAfter ) ); - *document_ << "\n"; - } -} - - -bool -StyledStreamWriter::hasCommentForValue ( const Value& value ) -{ - return value.hasComment ( commentBefore ) - || value.hasComment ( commentAfterOnSameLine ) - || value.hasComment ( commentAfter ); -} - - -std::string -StyledStreamWriter::normalizeEOL ( std::string const& text ) -{ - std::string normalized; - normalized.reserve ( text.length () ); - const char* begin = text.c_str (); - const char* end = begin + text.length (); - const char* current = begin; - - while ( current != end ) - { - char c = *current++; - - if ( c == '\r' ) // mac or dos EOL - { - if ( *current == '\n' ) // convert dos EOL - ++current; - - normalized += '\n'; - } - else // handle unix EOL & other char - normalized += c; - } - - return normalized; -} - - std::ostream& operator<< ( std::ostream& sout, const Value& root ) { Json::StyledStreamWriter writer; diff --git a/src/ripple/json/json_config.h b/src/ripple/json/json_config.h deleted file mode 100644 index 39e6e16d63..0000000000 --- a/src/ripple/json/json_config.h +++ /dev/null @@ -1,62 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of rippled: https://github.com/ripple/rippled - Copyright (c) 2012, 2013 Ripple Labs Inc. - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -#ifndef RIPPLE_JSON_JSON_CONFIG_H_INCLUDED -#define RIPPLE_JSON_JSON_CONFIG_H_INCLUDED - -/// If defined, indicates that json library is embedded in CppTL library. -//# define JSON_IN_CPPTL 1 - -/// If defined, indicates that json may leverage CppTL library -//# define JSON_USE_CPPTL 1 -/// If defined, indicates that cpptl vector based map should be used instead of std::map -/// as Value container. -//# define JSON_USE_CPPTL_SMALLMAP 1 -/// If defined, indicates that Json specific container should be used -/// (hash table & simple deque container with customizable allocator). -/// THIS FEATURE IS STILL EXPERIMENTAL! -//# define JSON_VALUE_USE_INTERNAL_MAP 1 -/// Force usage of standard new/malloc based allocator instead of memory pool based allocator. -/// The memory pools allocator used optimization (initializing Value and ValueInternalLink -/// as if it was a POD) that may cause some validation tool to report errors. -/// Only has effects if JSON_VALUE_USE_INTERNAL_MAP is defined. -//# define JSON_USE_SIMPLE_INTERNAL_ALLOCATOR 1 - -/// If defined, indicates that Json use exception to report invalid type manipulation -/// instead of C assert macro. -# define JSON_USE_EXCEPTION 1 - -# ifdef JSON_IN_CPPTL -# include -# ifndef JSON_USE_CPPTL -# define JSON_USE_CPPTL 1 -# endif -# endif - -# ifdef JSON_IN_CPPTL -# define JSON_API CPPTL_API -# elif defined(JSON_DLL_BUILD) -# define JSON_API __declspec(dllexport) -# elif defined(JSON_DLL) -# define JSON_API __declspec(dllimport) -# else -# define JSON_API -# endif - -#endif // JSON_CONFIG_H_INCLUDED diff --git a/src/ripple/json/json_features.h b/src/ripple/json/json_features.h deleted file mode 100644 index d81e3fe9c0..0000000000 --- a/src/ripple/json/json_features.h +++ /dev/null @@ -1,62 +0,0 @@ -//------------------------------------------------------------------------------ -/* - This file is part of rippled: https://github.com/ripple/rippled - Copyright (c) 2012, 2013 Ripple Labs Inc. - - Permission to use, copy, modify, and/or distribute this software for any - purpose with or without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies. - - THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES - WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR - ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN - ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF - OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. -*/ -//============================================================================== - -#ifndef RIPPLE_JSON_JSON_FEATURES_H_INCLUDED -#define RIPPLE_JSON_JSON_FEATURES_H_INCLUDED - -#include - -namespace Json -{ - -/** \brief Configuration passed to reader and writer. - * This configuration object can be used to force the Reader or Writer - * to behave in a standard conforming way. - */ -class JSON_API Features -{ -public: - /** \brief A configuration that allows all features and assumes all strings are UTF-8. - * - C & C++ comments are allowed - * - Root object can be any JSON value - * - Assumes Value strings are encoded in UTF-8 - */ - static Features all (); - - /** \brief A configuration that is strictly compatible with the JSON specification. - * - Comments are forbidden. - * - Root object must be either an array or an object value. - * - Assumes Value strings are encoded in UTF-8 - */ - static Features strictMode (); - - /** \brief Initialize the configuration like JsonConfig::allFeatures; - */ - Features (); - - /// \c true if comments are allowed. Default: \c true. - bool allowComments_; - - /// \c true if root must be either an array or an object value. Default: \c false. - bool strictRoot_; -}; - -} // namespace Json - -#endif // CPPTL_JSON_FEATURES_H_INCLUDED diff --git a/src/ripple/json/json_forwards.h b/src/ripple/json/json_forwards.h index b3c9fd12df..639022ab3e 100644 --- a/src/ripple/json/json_forwards.h +++ b/src/ripple/json/json_forwards.h @@ -20,38 +20,17 @@ #ifndef RIPPLE_JSON_JSON_FORWARDS_H_INCLUDED #define RIPPLE_JSON_JSON_FORWARDS_H_INCLUDED -#include - namespace Json { -// writer.h -class FastWriter; -class StyledWriter; - -// reader.h -class Reader; - -// features.h -class Features; - // value.h typedef int Int; typedef unsigned int UInt; class StaticString; -class Path; -class PathArgument; class Value; class ValueIteratorBase; class ValueIterator; class ValueConstIterator; -#ifdef JSON_VALUE_USE_INTERNAL_MAP -class ValueAllocator; -class ValueMapAllocator; -class ValueInternalLink; -class ValueInternalArray; -class ValueInternalMap; -#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP } // namespace Json diff --git a/src/ripple/json/json_reader.h b/src/ripple/json/json_reader.h index 39ca103326..db3aab394f 100644 --- a/src/ripple/json/json_reader.h +++ b/src/ripple/json/json_reader.h @@ -22,8 +22,6 @@ # define CPPTL_JSON_READER_H_INCLUDED -#include -#include #include #include @@ -35,7 +33,7 @@ namespace Json /** \brief Unserialize a JSON document into a Value. * */ -class JSON_API Reader +class Reader { public: typedef char Char; @@ -46,44 +44,25 @@ public: */ Reader (); - /** \brief Constructs a Reader allowing the specified feature set - * for parsing. + /** \brief Read a Value from a JSON document. + * \param document UTF-8 encoded string containing the document to read. + * \param root [out] Contains the root value of the document if it was + * successfully parsed. + * \return \c true if the document was successfully parsed, \c false if an error occurred. */ - Reader ( const Features& features ); + bool parse ( std::string const& document, Value& root); /** \brief Read a Value from a JSON document. * \param document UTF-8 encoded string containing the document to read. * \param root [out] Contains the root value of the document if it was * successfully parsed. - * \param collectComments \c true to collect comment and allow writing them back during - * serialization, \c false to discard comments. - * This parameter is ignored if Features::allowComments_ - * is \c false. * \return \c true if the document was successfully parsed, \c false if an error occurred. */ - bool parse ( std::string const& document, - Value& root, - bool collectComments = true ); - - /** \brief Read a Value from a JSON document. - * \param document UTF-8 encoded string containing the document to read. - * \param root [out] Contains the root value of the document if it was - * successfully parsed. - * \param collectComments \c true to collect comment and allow writing them back during - * serialization, \c false to discard comments. - * This parameter is ignored if Features::allowComments_ - * is \c false. - * \return \c true if the document was successfully parsed, \c false if an error occurred. - */ - bool parse ( const char* beginDoc, const char* endDoc, - Value& root, - bool collectComments = true ); + bool parse ( const char* beginDoc, const char* endDoc, Value& root); /// \brief Parse from input stream. /// \see Json::operator>>(std::istream&, Json::Value&). - bool parse ( std::istream& is, - Value& root, - bool collectComments = true ); + bool parse ( std::istream& is, Value& root); /** \brief Returns a user friendly string that list errors in the parsed document. * \return Formatted error message with the list of errors with their location in @@ -101,7 +80,8 @@ private: tokenArrayBegin, tokenArrayEnd, tokenString, - tokenNumber, + tokenInteger, + tokenDouble, tokenTrue, tokenFalse, tokenNull, @@ -138,7 +118,7 @@ private: bool readCStyleComment (); bool readCppStyleComment (); bool readString (); - void readNumber (); + Reader::TokenType readNumber (); bool readValue (); bool readObject ( Token& token ); bool readArray ( Token& token ); @@ -168,9 +148,6 @@ private: int& line, int& column ) const; std::string getLocationLineAndColumn ( Location location ) const; - void addComment ( Location begin, - Location end, - CommentPlacement placement ); void skipCommentTokens ( Token& token ); typedef std::stack Nodes; @@ -182,9 +159,6 @@ private: Location current_; Location lastValueEnd_; Value* lastValue_; - std::string commentsBefore_; - Features features_; - bool collectComments_; }; /** \brief Read from 'sin' into 'root'. diff --git a/src/ripple/json/json_value.h b/src/ripple/json/json_value.h index 372bc36b97..e6a99e0f90 100644 --- a/src/ripple/json/json_value.h +++ b/src/ripple/json/json_value.h @@ -20,7 +20,6 @@ #ifndef RIPPLE_JSON_JSON_VALUE_H_INCLUDED #define RIPPLE_JSON_JSON_VALUE_H_INCLUDED -#include #include #include #include @@ -54,11 +53,6 @@ enum CommentPlacement numberOfCommentPlacement }; -//# ifdef JSON_USE_CPPTL -// typedef CppTL::AnyEnumerator EnumMemberNames; -// typedef CppTL::AnyEnumerator EnumValues; -//# endif - /** \brief Lightweight wrapper to tag static string. * * Value constructor and objectValue member assignement takes advantage of the @@ -73,7 +67,7 @@ enum CommentPlacement * object[code] = 1234; * \endcode */ -class JSON_API StaticString +class StaticString { public: explicit StaticString ( const char* czstring ) @@ -122,13 +116,10 @@ private: * It is possible to iterate over the list of a #objectValue values using * the getMemberNames() method. */ -class JSON_API Value +class Value { friend class ValueIteratorBase; -# ifdef JSON_VALUE_USE_INTERNAL_MAP - friend class ValueInternalLink; - friend class ValueInternalMap; -# endif + public: typedef std::vector Members; typedef ValueIterator iterator; @@ -143,8 +134,6 @@ public: static const UInt maxUInt; private: -#ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION -# ifndef JSON_VALUE_USE_INTERNAL_MAP class CZString { public: @@ -171,13 +160,7 @@ private: }; public: -# ifndef JSON_USE_CPPTL_SMALLMAP typedef std::map ObjectValues; -# else - typedef CppTL::SmallMap ObjectValues; -# endif // ifndef JSON_USE_CPPTL_SMALLMAP -# endif // ifndef JSON_VALUE_USE_INTERNAL_MAP -#endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION public: /** \brief Create a default Value of the given type. @@ -215,9 +198,6 @@ public: Value ( std::string const& value ); // VFALCO DEPRECATED Avoid this conversion Value (beast::String const& beastString); -# ifdef JSON_USE_CPPTL - Value ( const CppTL::ConstString& value ); -# endif Value ( bool value ); Value ( const Value& other ); ~Value (); @@ -246,9 +226,6 @@ public: const char* asCString () const; std::string asString () const; -# ifdef JSON_USE_CPPTL - CppTL::ConstString asConstString () const; -# endif Int asInt () const; UInt asUInt () const; double asDouble () const; @@ -330,23 +307,14 @@ public: * \endcode */ Value& operator[] ( const StaticString& key ); -# ifdef JSON_USE_CPPTL - /// Access an object value by name, create a null member if it does not exist. - Value& operator[] ( const CppTL::ConstString& key ); - /// Access an object value by name, returns null if there is no member with that name. - const Value& operator[] ( const CppTL::ConstString& key ) const; -# endif + /// Return the member named key if it exist, defaultValue otherwise. Value get ( const char* key, const Value& defaultValue ) const; /// Return the member named key if it exist, defaultValue otherwise. Value get ( std::string const& key, const Value& defaultValue ) const; -# ifdef JSON_USE_CPPTL - /// Return the member named key if it exist, defaultValue otherwise. - Value get ( const CppTL::ConstString& key, - const Value& defaultValue ) const; -# endif + /// \brief Remove and return the named member. /// /// Do nothing if it did not exist. @@ -361,10 +329,6 @@ public: bool isMember ( const char* key ) const; /// Return true if the object has a member named key. bool isMember ( std::string const& key ) const; -# ifdef JSON_USE_CPPTL - /// Return true if the object has a member named key. - bool isMember ( const CppTL::ConstString& key ) const; -# endif /// \brief Return a list of the member names. /// @@ -373,17 +337,6 @@ public: /// \post if type() was nullValue, it remains nullValue Members getMemberNames () const; - //# ifdef JSON_USE_CPPTL - // EnumMemberNames enumMemberNames() const; - // EnumValues enumValues() const; - //# endif - - /// Comments must be //... or /* ... */ - void setComment ( const char* comment, - CommentPlacement placement ); - /// Comments must be //... or /* ... */ - void setComment ( std::string const& comment, - CommentPlacement placement ); bool hasComment ( CommentPlacement placement ) const; /// Include delimiters and embedded newlines. std::string getComment ( CommentPlacement placement ) const; @@ -400,48 +353,7 @@ private: Value& resolveReference ( const char* key, bool isStatic ); -# ifdef JSON_VALUE_USE_INTERNAL_MAP - inline bool isItemAvailable () const - { - return itemIsUsed_ == 0; - } - - inline void setItemUsed ( bool isUsed = true ) - { - itemIsUsed_ = isUsed ? 1 : 0; - } - - inline bool isMemberNameStatic () const - { - return memberNameIsStatic_ == 0; - } - - inline void setMemberNameIsStatic ( bool isStatic ) - { - memberNameIsStatic_ = isStatic ? 1 : 0; - } -# endif // # ifdef JSON_VALUE_USE_INTERNAL_MAP - private: - struct CommentInfo - { - CommentInfo (); - ~CommentInfo (); - - void setComment ( const char* text ); - - char* comment_; - }; - - //struct MemberNamesTransform - //{ - // typedef const char *result_type; - // const char *operator()( const CZString &name ) const - // { - // return name.c_str(); - // } - //}; - union ValueHolder { Int int_; @@ -449,88 +361,10 @@ private: double real_; bool bool_; char* string_; -# ifdef JSON_VALUE_USE_INTERNAL_MAP - ValueInternalArray* array_; - ValueInternalMap* map_; -#else ObjectValues* map_; -# endif } value_; ValueType type_ : 8; int allocated_ : 1; // Notes: if declared as bool, bitfield is useless. -# ifdef JSON_VALUE_USE_INTERNAL_MAP - unsigned int itemIsUsed_ : 1; // used by the ValueInternalMap container. - int memberNameIsStatic_ : 1; // used by the ValueInternalMap container. -# endif - CommentInfo* comments_; -}; - - -/** \brief Experimental and untested: represents an element of the "path" to access a node. - */ -class PathArgument -{ -public: - friend class Path; - - PathArgument (); - PathArgument ( UInt index ); - PathArgument ( const char* key ); - PathArgument ( std::string const& key ); - -private: - enum Kind - { - kindNone = 0, - kindIndex, - kindKey - }; - std::string key_; - UInt index_; - Kind kind_; -}; - -/** \brief Experimental and untested: represents a "path" to access a node. - * - * Syntax: - * - "." => root node - * - ".[n]" => elements at index 'n' of root node (an array value) - * - ".name" => member named 'name' of root node (an object value) - * - ".name1.name2.name3" - * - ".[0][1][2].name1[3]" - * - ".%" => member name is provided as parameter - * - ".[%]" => index is provied as parameter - */ -class Path -{ -public: - Path ( std::string const& path, - const PathArgument& a1 = PathArgument (), - const PathArgument& a2 = PathArgument (), - const PathArgument& a3 = PathArgument (), - const PathArgument& a4 = PathArgument (), - const PathArgument& a5 = PathArgument () ); - - const Value& resolve ( const Value& root ) const; - Value resolve ( const Value& root, - const Value& defaultValue ) const; - /// Creates the "path" to access the specified node and returns a reference on the node. - Value& make ( Value& root ) const; - -private: - typedef std::vector InArgs; - typedef std::vector Args; - - void makePath ( std::string const& path, - const InArgs& in ); - void addPathInArg ( std::string const& path, - const InArgs& in, - InArgs::const_iterator& itInArg, - PathArgument::Kind kind ); - void invalidPath ( std::string const& path, - int location ); - - Args args_; }; /** \brief Experimental do not use: Allocator to customize member name and string value memory management done by Value. @@ -554,346 +388,6 @@ public: virtual void releaseStringValue ( char* value ) = 0; }; -#ifdef JSON_VALUE_USE_INTERNAL_MAP -/** \brief Allocator to customize Value internal map. - * Below is an example of a simple implementation (default implementation actually - * use memory pool for speed). - * \code - class DefaultValueMapAllocator : public ValueMapAllocator - { - public: // overridden from ValueMapAllocator - virtual ValueInternalMap *newMap() - { - return new ValueInternalMap(); - } - - virtual ValueInternalMap *newMapCopy( const ValueInternalMap &other ) - { - return new ValueInternalMap( other ); - } - - virtual void destructMap( ValueInternalMap *map ) - { - delete map; - } - - virtual ValueInternalLink *allocateMapBuckets( unsigned int size ) - { - return new ValueInternalLink[size]; - } - - virtual void releaseMapBuckets( ValueInternalLink *links ) - { - delete [] links; - } - - virtual ValueInternalLink *allocateMapLink() - { - return new ValueInternalLink(); - } - - virtual void releaseMapLink( ValueInternalLink *link ) - { - delete link; - } - }; - * \endcode - */ -class JSON_API ValueMapAllocator -{ -public: - virtual ~ValueMapAllocator (); - virtual ValueInternalMap* newMap () = 0; - virtual ValueInternalMap* newMapCopy ( const ValueInternalMap& other ) = 0; - virtual void destructMap ( ValueInternalMap* map ) = 0; - virtual ValueInternalLink* allocateMapBuckets ( unsigned int size ) = 0; - virtual void releaseMapBuckets ( ValueInternalLink* links ) = 0; - virtual ValueInternalLink* allocateMapLink () = 0; - virtual void releaseMapLink ( ValueInternalLink* link ) = 0; -}; - -/** \brief ValueInternalMap hash-map bucket chain link (for internal use only). - * \internal previous_ & next_ allows for bidirectional traversal. - */ -class JSON_API ValueInternalLink -{ -public: - enum { itemPerLink = 6 }; // sizeof(ValueInternalLink) = 128 on 32 bits architecture. - enum InternalFlags - { - flagAvailable = 0, - flagUsed = 1 - }; - - ValueInternalLink (); - - ~ValueInternalLink (); - - Value items_[itemPerLink]; - char* keys_[itemPerLink]; - ValueInternalLink* previous_; - ValueInternalLink* next_; -}; - - -/** \brief A linked page based hash-table implementation used internally by Value. - * \internal ValueInternalMap is a tradional bucket based hash-table, with a linked - * list in each bucket to handle collision. There is an addional twist in that - * each node of the collision linked list is a page containing a fixed amount of - * value. This provides a better compromise between memory usage and speed. - * - * Each bucket is made up of a chained list of ValueInternalLink. The last - * link of a given bucket can be found in the 'previous_' field of the following bucket. - * The last link of the last bucket is stored in tailLink_ as it has no following bucket. - * Only the last link of a bucket may contains 'available' item. The last link always - * contains at least one element unless is it the bucket one very first link. - */ -class JSON_API ValueInternalMap -{ - friend class ValueIteratorBase; - friend class Value; -public: - typedef unsigned int HashKey; - typedef unsigned int BucketIndex; - -# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - struct IteratorState - { - IteratorState () - : map_ (0) - , link_ (0) - , itemIndex_ (0) - , bucketIndex_ (0) - { - } - ValueInternalMap* map_; - ValueInternalLink* link_; - BucketIndex itemIndex_; - BucketIndex bucketIndex_; - }; -# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - - ValueInternalMap (); - ValueInternalMap ( const ValueInternalMap& other ); - ValueInternalMap& operator = ( const ValueInternalMap& other ); - ~ValueInternalMap (); - - void swap ( ValueInternalMap& other ) noexcept; - - BucketIndex size () const; - - void clear (); - - bool reserveDelta ( BucketIndex growth ); - - bool reserve ( BucketIndex newItemCount ); - - const Value* find ( const char* key ) const; - - Value* find ( const char* key ); - - Value& resolveReference ( const char* key, - bool isStatic ); - - void remove ( const char* key ); - - void doActualRemove ( ValueInternalLink* link, - BucketIndex index, - BucketIndex bucketIndex ); - - ValueInternalLink*& getLastLinkInBucket ( BucketIndex bucketIndex ); - - Value& setNewItem ( const char* key, - bool isStatic, - ValueInternalLink* link, - BucketIndex index ); - - Value& unsafeAdd ( const char* key, - bool isStatic, - HashKey hashedKey ); - - HashKey hash ( const char* key ) const; - - int compare ( const ValueInternalMap& other ) const; - -private: - void makeBeginIterator ( IteratorState& it ) const; - void makeEndIterator ( IteratorState& it ) const; - static bool equals ( const IteratorState& x, const IteratorState& other ); - static void increment ( IteratorState& iterator ); - static void incrementBucket ( IteratorState& iterator ); - static void decrement ( IteratorState& iterator ); - static const char* key ( const IteratorState& iterator ); - static const char* key ( const IteratorState& iterator, bool& isStatic ); - static Value& value ( const IteratorState& iterator ); - static int distance ( const IteratorState& x, const IteratorState& y ); - -private: - ValueInternalLink* buckets_; - ValueInternalLink* tailLink_; - BucketIndex bucketsSize_; - BucketIndex itemCount_; -}; - -/** \brief A simplified deque implementation used internally by Value. -* \internal -* It is based on a list of fixed "page", each page contains a fixed number of items. -* Instead of using a linked-list, a array of pointer is used for fast item look-up. -* Look-up for an element is as follow: -* - compute page index: pageIndex = itemIndex / itemsPerPage -* - look-up item in page: pages_[pageIndex][itemIndex % itemsPerPage] -* -* Insertion is amortized constant time (only the array containing the index of pointers -* need to be reallocated when items are appended). -*/ -class JSON_API ValueInternalArray -{ - friend class Value; - friend class ValueIteratorBase; -public: - enum { itemsPerPage = 8 }; // should be a power of 2 for fast divide and modulo. - typedef Value::ArrayIndex ArrayIndex; - typedef unsigned int PageIndex; - -# ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - struct IteratorState // Must be a POD - { - IteratorState () - : array_ (0) - , currentPageIndex_ (0) - , currentItemIndex_ (0) - { - } - ValueInternalArray* array_; - Value** currentPageIndex_; - unsigned int currentItemIndex_; - }; -# endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION - - ValueInternalArray (); - ValueInternalArray ( const ValueInternalArray& other ); - ValueInternalArray& operator = ( const ValueInternalArray& other ); - ~ValueInternalArray (); - void swap ( ValueInternalArray& other ) noexcept; - - void clear (); - void resize ( ArrayIndex newSize ); - - Value& resolveReference ( ArrayIndex index ); - - Value* find ( ArrayIndex index ) const; - - ArrayIndex size () const; - - int compare ( const ValueInternalArray& other ) const; - -private: - static bool equals ( const IteratorState& x, const IteratorState& other ); - static void increment ( IteratorState& iterator ); - static void decrement ( IteratorState& iterator ); - static Value& dereference ( const IteratorState& iterator ); - static Value& unsafeDereference ( const IteratorState& iterator ); - static int distance ( const IteratorState& x, const IteratorState& y ); - static ArrayIndex indexOf ( const IteratorState& iterator ); - void makeBeginIterator ( IteratorState& it ) const; - void makeEndIterator ( IteratorState& it ) const; - void makeIterator ( IteratorState& it, ArrayIndex index ) const; - - void makeIndexValid ( ArrayIndex index ); - - Value** pages_; - ArrayIndex size_; - PageIndex pageCount_; -}; - -/** \brief Experimental: do not use. Allocator to customize Value internal array. - * Below is an example of a simple implementation (actual implementation use - * memory pool). - \code -class DefaultValueArrayAllocator : public ValueArrayAllocator -{ -public: // overridden from ValueArrayAllocator -virtual ~DefaultValueArrayAllocator() -{ -} - -virtual ValueInternalArray *newArray() -{ - return new ValueInternalArray(); -} - -virtual ValueInternalArray *newArrayCopy( const ValueInternalArray &other ) -{ - return new ValueInternalArray( other ); -} - -virtual void destruct( ValueInternalArray *array ) -{ - delete array; -} - -virtual void reallocateArrayPageIndex( Value **&indexes, - ValueInternalArray::PageIndex &indexCount, - ValueInternalArray::PageIndex minNewIndexCount ) -{ - ValueInternalArray::PageIndex newIndexCount = (indexCount*3)/2 + 1; - if ( minNewIndexCount > newIndexCount ) - newIndexCount = minNewIndexCount; - void *newIndexes = realloc( indexes, sizeof(Value*) * newIndexCount ); - if ( !newIndexes ) - throw std::bad_alloc(); - indexCount = newIndexCount; - indexes = static_cast( newIndexes ); -} -virtual void releaseArrayPageIndex( Value **indexes, - ValueInternalArray::PageIndex indexCount ) -{ - if ( indexes ) - free( indexes ); -} - -virtual Value *allocateArrayPage() -{ - return static_cast( malloc( sizeof(Value) * ValueInternalArray::itemsPerPage ) ); -} - -virtual void releaseArrayPage( Value *value ) -{ - if ( value ) - free( value ); -} -}; - \endcode - */ -class JSON_API ValueArrayAllocator -{ -public: - virtual ~ValueArrayAllocator (); - virtual ValueInternalArray* newArray () = 0; - virtual ValueInternalArray* newArrayCopy ( const ValueInternalArray& other ) = 0; - virtual void destructArray ( ValueInternalArray* array ) = 0; - /** \brief Reallocate array page index. - * Reallocates an array of pointer on each page. - * \param indexes [input] pointer on the current index. May be \c NULL. - * [output] pointer on the new index of at least - * \a minNewIndexCount pages. - * \param indexCount [input] current number of pages in the index. - * [output] number of page the reallocated index can handle. - * \b MUST be >= \a minNewIndexCount. - * \param minNewIndexCount Minimum number of page the new index must be able to - * handle. - */ - virtual void reallocateArrayPageIndex ( Value**& indexes, - ValueInternalArray::PageIndex& indexCount, - ValueInternalArray::PageIndex minNewIndexCount ) = 0; - virtual void releaseArrayPageIndex ( Value** indexes, - ValueInternalArray::PageIndex indexCount ) = 0; - virtual Value* allocateArrayPage () = 0; - virtual void releaseArrayPage ( Value* value ) = 0; -}; -#endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP - - /** \brief base class for Value iterators. * */ @@ -905,12 +399,8 @@ public: typedef ValueIteratorBase SelfType; ValueIteratorBase (); -#ifndef JSON_VALUE_USE_INTERNAL_MAP + explicit ValueIteratorBase ( const Value::ObjectValues::iterator& current ); -#else - ValueIteratorBase ( const ValueInternalArray::IteratorState& state ); - ValueIteratorBase ( const ValueInternalMap::IteratorState& state ); -#endif bool operator == ( const SelfType& other ) const { @@ -950,18 +440,9 @@ protected: void copy ( const SelfType& other ); private: -#ifndef JSON_VALUE_USE_INTERNAL_MAP Value::ObjectValues::iterator current_; // Indicates that iterator is for a null value. bool isNull_; -#else - union - { - ValueInternalArray::IteratorState array_; - ValueInternalMap::IteratorState map_; - } iterator_; - bool isArray_; -#endif }; /** \brief const iterator for object and array value. @@ -981,12 +462,7 @@ public: private: /*! \internal Use by Value to create an iterator. */ -#ifndef JSON_VALUE_USE_INTERNAL_MAP explicit ValueConstIterator ( const Value::ObjectValues::iterator& current ); -#else - ValueConstIterator ( const ValueInternalArray::IteratorState& state ); - ValueConstIterator ( const ValueInternalMap::IteratorState& state ); -#endif public: SelfType& operator = ( const ValueIteratorBase& other ); @@ -1041,12 +517,7 @@ public: private: /*! \internal Use by Value to create an iterator. */ -#ifndef JSON_VALUE_USE_INTERNAL_MAP explicit ValueIterator ( const Value::ObjectValues::iterator& current ); -#else - ValueIterator ( const ValueInternalArray::IteratorState& state ); - ValueIterator ( const ValueInternalMap::IteratorState& state ); -#endif public: SelfType& operator = ( const SelfType& other ); diff --git a/src/ripple/json/json_writer.h b/src/ripple/json/json_writer.h index d2cce17966..41c6bd94cd 100644 --- a/src/ripple/json/json_writer.h +++ b/src/ripple/json/json_writer.h @@ -20,7 +20,6 @@ #ifndef RIPPLE_JSON_JSON_WRITER_H_INCLUDED #define RIPPLE_JSON_JSON_WRITER_H_INCLUDED -#include #include #include #include @@ -32,7 +31,7 @@ class Value; /** \brief Abstract class for writers. */ -class JSON_API Writer +class Writer { public: virtual ~Writer (); @@ -46,14 +45,12 @@ public: * but may be usefull to support feature such as RPC where bandwith is limited. * \sa Reader, Value */ -class JSON_API FastWriter : public Writer +class FastWriter : public Writer { public: FastWriter (); virtual ~FastWriter () {} - void enableYAMLCompatibility (); - public: // overridden from Writer virtual std::string write ( const Value& root ); @@ -61,7 +58,6 @@ private: void writeValue ( const Value& value ); std::string document_; - bool yamlCompatiblityEnabled_; }; /** \brief Writes a Value in JSON format in a human friendly way. @@ -82,7 +78,7 @@ private: * * \sa Reader, Value, Value::setComment() */ -class JSON_API StyledWriter: public Writer +class StyledWriter: public Writer { public: StyledWriter (); @@ -104,10 +100,6 @@ private: void writeWithIndent ( std::string const& value ); void indent (); void unindent (); - void writeCommentBeforeValue ( const Value& root ); - void writeCommentAfterValueOnSameLine ( const Value& root ); - bool hasCommentForValue ( const Value& value ); - static std::string normalizeEOL ( std::string const& text ); typedef std::vector ChildValues; @@ -139,7 +131,7 @@ private: * \param indentation Each level will be indented by this amount extra. * \sa Reader, Value, Value::setComment() */ -class JSON_API StyledStreamWriter +class StyledStreamWriter { public: StyledStreamWriter ( std::string indentation = "\t" ); @@ -162,10 +154,6 @@ private: void writeWithIndent ( std::string const& value ); void indent (); void unindent (); - void writeCommentBeforeValue ( const Value& root ); - void writeCommentAfterValueOnSameLine ( const Value& root ); - bool hasCommentForValue ( const Value& value ); - static std::string normalizeEOL ( std::string const& text ); typedef std::vector ChildValues; @@ -177,11 +165,11 @@ private: bool addChildValues_; }; -std::string JSON_API valueToString ( Int value ); -std::string JSON_API valueToString ( UInt value ); -std::string JSON_API valueToString ( double value ); -std::string JSON_API valueToString ( bool value ); -std::string JSON_API valueToQuotedString ( const char* value ); +std::string valueToString ( Int value ); +std::string valueToString ( UInt value ); +std::string valueToString ( double value ); +std::string valueToString ( bool value ); +std::string valueToQuotedString ( const char* value ); /// \brief Output using the StyledStreamWriter. /// \see Json::operator>>() diff --git a/src/ripple/json/to_string.h b/src/ripple/json/to_string.h index 3d05e2bcf5..04834df1e4 100644 --- a/src/ripple/json/to_string.h +++ b/src/ripple/json/to_string.h @@ -20,7 +20,6 @@ #ifndef RIPPLE_JSON_TO_STRING_H_INCLUDED #define RIPPLE_JSON_TO_STRING_H_INCLUDED -#include #include #include diff --git a/src/ripple/rpc/tests/WriteJson.test.cpp b/src/ripple/rpc/tests/WriteJson.test.cpp index 2d930f4bb7..2540fde3eb 100644 --- a/src/ripple/rpc/tests/WriteJson.test.cpp +++ b/src/ripple/rpc/tests/WriteJson.test.cpp @@ -52,11 +52,6 @@ struct WriteJson_test : TestOutputSuite void run () override { - runTest ("null"); - runTest ("true"); - runTest ("0"); - runTest ("23.5"); - runTest ("string", "\"a string\""); runTest ("empty dict", "{}"); runTest ("empty array", "[]"); runTest ("array", "[23,4.25,true,null,\"string\"]"); diff --git a/src/ripple/unity/json.cpp b/src/ripple/unity/json.cpp index 48f1a30c88..17bae6c432 100644 --- a/src/ripple/unity/json.cpp +++ b/src/ripple/unity/json.cpp @@ -27,12 +27,6 @@ // For json/ // -#ifdef JSON_USE_CPPTL -#include -#endif -#ifndef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -#include -#endif #define JSON_ASSERT_UNREACHABLE assert( false ) #define JSON_ASSERT( condition ) assert( condition ); // @todo <= change this into an exception throw