[Cppunit-cvs] cppunit2/include/json config.h, 1.2, 1.3 forwards.h, 1.2, 1.3 value.h, 1.2, 1.3
Brought to you by:
blep
Menu
▾
▴
[Cppunit-cvs] cppunit2/include/json config.h, 1.2, 1.3 forwards.h, 1.2, 1.3 value.h, 1.2, 1.3
|
From: Baptiste L. <bl...@us...> - 2006-09-01 19:48:16
|
Update of /cvsroot/cppunit/cppunit2/include/json In directory sc8-pr-cvs4.sourceforge.net:/tmp/cvs-serv22940/include/json Modified Files: config.h forwards.h value.h Log Message: - synchronized with lastest jsoncpp. Index: config.h =================================================================== RCS file: /cvsroot/cppunit/cppunit2/include/json/config.h,v retrieving revision 1.2 retrieving revision 1.3 diff -C2 -d -r1.2 -r1.3 *** config.h 5 Jun 2006 13:22:58 -0000 1.2 --- config.h 1 Sep 2006 19:48:11 -0000 1.3 *************** *** 7,11 **** --- 7,22 ---- /// 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 Index: value.h =================================================================== RCS file: /cvsroot/cppunit/cppunit2/include/json/value.h,v retrieving revision 1.2 retrieving revision 1.3 diff -C2 -d -r1.2 -r1.3 *** value.h 5 Jun 2006 13:22:58 -0000 1.2 --- value.h 1 Sep 2006 19:48:11 -0000 1.3 *************** *** 15,18 **** --- 15,20 ---- # endif + /** \brief JSON (JavaScript Object Notation). + */ namespace Json { *************** *** 39,46 **** }; ! # ifdef JSON_USE_CPPTL ! typedef CppTL::AnyEnumerator<const char *> EnumMemberNames; ! typedef CppTL::AnyEnumerator<const Value &> EnumValues; ! # endif /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value. --- 41,84 ---- }; ! //# ifdef JSON_USE_CPPTL ! // typedef CppTL::AnyEnumerator<const char *> EnumMemberNames; ! // typedef CppTL::AnyEnumerator<const Value &> EnumValues; ! //# endif ! ! /** \brief Lightweight wrapper to tag static string. ! * ! * Value constructor and objectValue member assignement takes advantage of the ! * StaticString and avoid the cost of string duplication when storing the ! * string or the member name. ! * ! * Example of usage: ! * \code ! * Json::Value aValue( StaticString("some text") ); ! * Json::Value object; ! * static const StaticString code("code"); ! * object[code] = 1234; ! * \endcode ! */ ! class JSON_API StaticString ! { ! public: ! explicit StaticString( const char *czstring ) ! : str_( czstring ) ! { ! } ! ! operator const char *() const ! { ! return str_; ! } ! ! const char *c_str() const ! { ! return str_; ! } ! ! private: ! const char *str_; ! }; /** \brief Represents a <a HREF="http://www.json.org">JSON</a> value. *************** *** 73,76 **** --- 111,119 ---- class JSON_API Value { + friend class ValueIteratorBase; + # ifdef JSON_VALUE_USE_INTERNAL_MAP + friend class ValueInternalLink; + friend class ValueInternalMap; + # endif public: typedef std::vector<std::string> Members; *************** *** 79,82 **** --- 122,126 ---- typedef ValueIterator iterator; typedef ValueConstIterator const_iterator; + typedef UInt ArrayIndex; static const Value null; *************** *** 84,89 **** static const Int maxInt; static const UInt maxUInt; - private: class CZString { --- 128,135 ---- static const Int maxInt; static const UInt maxUInt; + private: + #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION + # ifndef JSON_VALUE_USE_INTERNAL_MAP class CZString { *************** *** 104,107 **** --- 150,154 ---- int index() const; const char *c_str() const; + bool isStaticString() const; private: void swap( CZString &other ); *************** *** 111,119 **** public: ! # ifndef JSON_USE_CPPTL_SMALLMAP typedef std::map<CZString, Value> ObjectValues; ! # else typedef CppTL::SmallMap<CZString, Value> ObjectValues; ! # endif public: --- 158,168 ---- public: ! # ifndef JSON_USE_CPPTL_SMALLMAP typedef std::map<CZString, Value> ObjectValues; ! # else typedef CppTL::SmallMap<CZString, Value> ObjectValues; ! # endif // ifndef JSON_USE_CPPTL_SMALLMAP ! # endif // ifndef JSON_VALUE_USE_INTERNAL_MAP ! #endif // ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION public: *************** *** 123,126 **** --- 172,185 ---- Value( double value ); Value( const char *value ); + /** \brief Constructs a value from a static string. + * Like other value string constructor but do not duplicate the string for + * internal storage. The given string must remain alive after the call to this + * constructor. + * Example of usage: + * \code + * Json::Value aValue( StaticString("some text") ); + * \endcode + */ + Value( const StaticString &value ); Value( const std::string &value ); # ifdef JSON_USE_CPPTL *************** *** 195,210 **** Value &append( const Value &value ); ! // Access an object value by name, create a null member if it does not exist. Value &operator[]( const char *key ); ! // Access an object value by name, returns null if there is no member with that name. const Value &operator[]( const char *key ) const; ! // Access an object value by name, create a null member if it does not exist. Value &operator[]( const std::string &key ); ! // Access an object value by name, returns null if there is no member with that name. const Value &operator[]( const std::string &key ) const; # 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 --- 254,280 ---- Value &append( const Value &value ); ! /// Access an object value by name, create a null member if it does not exist. Value &operator[]( const char *key ); ! /// Access an object value by name, returns null if there is no member with that name. const Value &operator[]( const char *key ) const; ! /// Access an object value by name, create a null member if it does not exist. Value &operator[]( const std::string &key ); ! /// Access an object value by name, returns null if there is no member with that name. const Value &operator[]( const std::string &key ) const; + /** \brief Access an object value by name, create a null member if it does not exist. + * If the object as no entry for that name, then the member name used to store + * the new entry is not duplicated. + * Example of use: + * \code + * Json::Value object; + * static const StaticString code("code"); + * object[code] = 1234; + * \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 *************** *** 232,239 **** Members getMemberNames() const; ! # ifdef JSON_USE_CPPTL ! EnumMemberNames enumMemberNames() const; ! EnumValues enumValues() const; ! # endif void setComment( const char *comment, --- 302,309 ---- Members getMemberNames() const; ! //# ifdef JSON_USE_CPPTL ! // EnumMemberNames enumMemberNames() const; ! // EnumValues enumValues() const; ! //# endif void setComment( const char *comment, *************** *** 253,256 **** --- 323,352 ---- 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 { *************** *** 263,274 **** }; ! struct MemberNamesTransform ! { ! typedef const char *result_type; ! const char *operator()( const CZString &name ) const ! { ! return name.c_str(); ! } ! }; union ValueHolder --- 359,370 ---- }; ! //struct MemberNamesTransform ! //{ ! // typedef const char *result_type; ! // const char *operator()( const CZString &name ) const ! // { ! // return name.c_str(); ! // } ! //}; union ValueHolder *************** *** 279,290 **** bool bool_; char *string_; ObjectValues *map_; } value_; ValueType type_ : 8; ! bool allocated_ : 1; CommentInfo *comments_; }; /** \brief Experimental and untested: base class for Value iterators. * --- 375,809 ---- 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( Value::UInt index ); + PathArgument( const char *key ); + PathArgument( const std::string &key ); + + private: + enum Kind + { + kindNone = 0, + kindIndex, + kindKey + }; + std::string key_; + Value::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( const std::string &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<const PathArgument *> InArgs; + typedef std::vector<PathArgument> Args; + + void makePath( const std::string &path, + const InArgs &in ); + void addPathInArg( const std::string &path, + const InArgs &in, + InArgs::const_iterator &itInArg, + PathArgument::Kind kind ); + void invalidPath( const std::string &path, + int location ); + + Args args_; + }; + + /** \brief Allocator to customize member name and string value memory management done by Value. + * + * - makeMemberName() and releaseMemberName() are called to respectively duplicate and + * free an Json::objectValue member name. + * - duplicateStringValue() and releaseStringValue() are called similarly to + * duplicate and free a Json::stringValue value. + */ + class ValueAllocator + { + public: + enum { unknown = -1 }; + + virtual ~ValueAllocator(); + + virtual char *makeMemberName( const char *memberName ) = 0; + virtual void releaseMemberName( char *memberName ) = 0; + virtual char *duplicateStringValue( const char *value, + unsigned int length = unknown ) = 0; + 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 + { + 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 ); + + 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 + { + 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 ); + + 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 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<Value **>( newIndexes ); + } + virtual void releaseArrayPageIndex( Value **indexes, + ValueInternalArray::PageIndex indexCount ) + { + if ( indexes ) + free( indexes ); + } + + virtual Value *allocateArrayPage() + { + return static_cast<Value *>( 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 Experimental and untested: base class for Value iterators. * *************** *** 298,302 **** --- 817,826 ---- ValueIteratorBase(); + #ifndef JSON_VALUE_USE_INTERNAL_MAP explicit ValueIteratorBase( const Value::ObjectValues::iterator ¤t ); + #else + ValueIteratorBase( const ValueInternalArray::IteratorState &state ); + ValueIteratorBase( const ValueInternalMap::IteratorState &state ); + #endif bool operator ==( const SelfType &other ) const *************** *** 315,318 **** --- 839,851 ---- } + /// Returns either the index or the member name of the referenced value as a Value. + Value key() const; + + /// Returns the index of the referenced Value. -1 if it is not an arrayValue. + Value::UInt index() const; + + /// Returns the member name of the referenced Value. "" if it is not an objectValue. + const char *memberName() const; + protected: Value &deref() const; *************** *** 329,333 **** --- 862,875 ---- private: + #ifndef JSON_VALUE_USE_INTERNAL_MAP Value::ObjectValues::iterator current_; + #else + union + { + ValueInternalArray::IteratorState array_; + ValueInternalMap::IteratorState map_; + } iterator_; + bool isArray_; + #endif }; *************** *** 337,340 **** --- 879,883 ---- class ValueConstIterator : public ValueIteratorBase { + friend class Value; public: typedef unsigned int size_t; *************** *** 345,351 **** --- 888,901 ---- ValueConstIterator(); + private: /*! \internal Use by Value to create an iterator. */ + #ifndef JSON_VALUE_USE_INTERNAL_MAP explicit ValueConstIterator( const Value::ObjectValues::iterator ¤t ); + #else + ValueConstIterator( const ValueInternalArray::IteratorState &state ); + ValueConstIterator( const ValueInternalMap::IteratorState &state ); + #endif + public: SelfType &operator =( const ValueIteratorBase &other ); *************** *** 387,390 **** --- 937,941 ---- class ValueIterator : public ValueIteratorBase { + friend class Value; public: typedef unsigned int size_t; *************** *** 397,403 **** --- 948,961 ---- ValueIterator( const ValueConstIterator &other ); ValueIterator( const ValueIterator &other ); + private: /*! \internal Use by Value to create an iterator. */ + #ifndef JSON_VALUE_USE_INTERNAL_MAP explicit ValueIterator( const Value::ObjectValues::iterator ¤t ); + #else + ValueIterator( const ValueInternalArray::IteratorState &state ); + ValueIterator( const ValueInternalMap::IteratorState &state ); + #endif + public: SelfType &operator =( const SelfType &other ); *************** *** 436,507 **** - - /** \brief Experimental and untested: represents an element of the "path" to access a node. - */ - class PathArgument - { - public: - friend class Path; - - PathArgument(); - PathArgument( Value::UInt index ); - PathArgument( const char *key ); - PathArgument( const std::string &key ); - - private: - enum Kind - { - kindNone = 0, - kindIndex, - kindKey - }; - std::string key_; - Value::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( const std::string &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<const PathArgument *> InArgs; - typedef std::vector<PathArgument> Args; - - void makePath( const std::string &path, - const InArgs &in ); - void addPathInArg( const std::string &path, - const InArgs &in, - InArgs::const_iterator &itInArg, - PathArgument::Kind kind ); - void invalidPath( const std::string &path, - int location ); - - Args args_; - }; - } // namespace Json --- 994,997 ---- Index: forwards.h =================================================================== RCS file: /cvsroot/cppunit/cppunit2/include/json/forwards.h,v retrieving revision 1.2 retrieving revision 1.3 diff -C2 -d -r1.2 -r1.3 *** forwards.h 5 Jun 2006 13:22:58 -0000 1.2 --- forwards.h 1 Sep 2006 19:48:11 -0000 1.3 *************** *** 11,14 **** --- 11,15 ---- // value.h + class StaticString; class Path; class PathArgument; *************** *** 17,20 **** --- 18,28 ---- 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 |
