cppunit-cvs

[Baptiste L. <bl...@us...>]

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 &current );
+ #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 &current );
+ #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 &current );
+ #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