- Array index can be passed as int to operator[], allowing use of literal:

blep · blep · commit fa130ef871be · 2010-12-24T12:47:14.000Z
Json::Value array;
  array.append( 1234 );
  int value = array[0].asInt();  // did not compile previously
diff --git a/NEWS.txt b/NEWS.txt
@@ -32,6 +32,11 @@
     
   - The type Json::ArrayIndex is used for indexes of a JSON value array. It
     is an unsigned int (typically 32 bits).
+	
+  - Array index can be passed as int to operator[], allowing use of literal:
+    Json::Value array;
+	array.append( 1234 );
+	int value = array[0].asInt();  // did not compile previously
 
 * Tests
 
diff --git a/include/json/value.h b/include/json/value.h
@@ -284,11 +284,25 @@ namespace Json {
       /// (You may need to say 'value[0u]' to get your compiler to distinguish
       ///  this from the operator[] which takes a string.)
       Value &operator[]( ArrayIndex index );
-      /// Access an array element (zero based index )
+
+	  /// Access an array element (zero based index ).
+      /// If the array contains less than index element, then null value are inserted
+      /// in the array so that its size is index+1.
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      Value &operator[]( int index );
+
+	  /// Access an array element (zero based index )
       /// (You may need to say 'value[0u]' to get your compiler to distinguish
       ///  this from the operator[] which takes a string.)
       const Value &operator[]( ArrayIndex index ) const;
-      /// If the array contains at least index+1 elements, returns the element value, 
+
+	  /// Access an array element (zero based index )
+      /// (You may need to say 'value[0u]' to get your compiler to distinguish
+      ///  this from the operator[] which takes a string.)
+      const Value &operator[]( int index ) const;
+
+	  /// If the array contains at least index+1 elements, returns the element value, 
       /// otherwise returns defaultValue.
       Value get( ArrayIndex index, 
                  const Value &defaultValue ) const;
diff --git a/src/jsontestrunner/main.cpp b/src/jsontestrunner/main.cpp
@@ -3,6 +3,10 @@
 // recognized in your jurisdiction.
 // See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
 
+/* This executable is used for testing parser/writer using real JSON files.
+ */
+
+
 #include <json/json.h>
 #include <algorithm> // sort
 #include <stdio.h>
diff --git a/src/lib_json/json_value.cpp b/src/lib_json/json_value.cpp
@@ -975,6 +975,14 @@ Value::operator[]( ArrayIndex index )
 }
 
 
+Value &
+Value::operator[]( int index )
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
 const Value &
 Value::operator[]( ArrayIndex index ) const
 {
@@ -994,6 +1002,14 @@ Value::operator[]( ArrayIndex index ) const
 }
 
 
+const Value &
+Value::operator[]( int index ) const
+{
+   JSON_ASSERT( index >= 0 );
+   return (*this)[ ArrayIndex(index) ];
+}
+
+
 Value &
 Value::operator[]( const char *key )
 {
diff --git a/src/test_lib_json/jsontest.h b/src/test_lib_json/jsontest.h
@@ -199,7 +199,7 @@ namespace JsonTest {
 /// JSONTEST_ASSERT( x == y ) << "x=" << x << ", y=" << y;
 /// JSONTEST_ASSERT( x == y );
 #define JSONTEST_ASSERT( expr )                                               \
-   if ( condition )                                                           \
+   if ( expr )                                                                \
    {                                                                          \
    }                                                                          \
    else                                                                       \
diff --git a/src/test_lib_json/main.cpp b/src/test_lib_json/main.cpp
@@ -172,6 +172,18 @@ JSONTEST_FIXTURE( ValueTest, isUInt )
 }
 
 
+JSONTEST_FIXTURE( ValueTest, accessArray )
+{
+	const unsigned int index0 = 0;
+	JSONTEST_ASSERT( Json::Value(1234) == array1_[index0] ) << "Json::Value::operator[ArrayIndex]";
+	JSONTEST_ASSERT( Json::Value(1234) == array1_[0] ) << "Json::Value::operator[int]";
+
+	const Json::Value &constArray = array1_;
+	JSONTEST_ASSERT( Json::Value(1234) == constArray[index0] ) << "Json::Value::operator[ArrayIndex] const";
+	JSONTEST_ASSERT( Json::Value(1234) == constArray[0] ) << "Json::Value::operator[int] const";
+}
+
+
 void
 ValueTest::checkConstMemberCount( const Json::Value &value, unsigned int expectedCount )
 {
@@ -245,5 +257,7 @@ int main( int argc, const char *argv[] )
    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isDouble );
    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isString );
    JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isNull );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, isNull );
+   JSONTEST_REGISTER_FIXTURE( runner, ValueTest, accessArray );
    return runner.runCommandLine( argc, argv );
 }
