generic-library/rapidjson
1
0
Fork 0
mirror of https://github.com/Tencent/rapidjson.git synced 2025-03-06 13:41:35 +01:00
Code Issues Projects Releases Wiki Activity

GenericValue: improve operator[] disambiguation

Browse Source 
In the original disambiguation fix for `GenericValue::operator[]` (#170),
the documentation has been missing, which led to quite badly rendered
Doxygen pages.

During a cleanup, I've realized that a much simpler disambiguation is
possible:

````cpp
  GenericValue& operator[](SizeType idx); // array
  template <typename T>
  GenericValue& operator[](T* name);      // object
````

This approach works, as non-template functions are preferred over
template functions.

In order to improve the error messages, the pointer type is restricted
to `(const) Ch`.

Update `tutorial.md` to drop the ambiguity warning.
This commit is contained in:
Philipp A. Hartmann 2014-10-24 13:55:26 +02:00
parent 5ccc663479
commit e8445e0bbc
2 changed files with 15 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/tutorial.md
View File

@ -121,9 +121,7 @@ In the following, details about querying individual types are discussed.
By default, `SizeType` is typedef of `unsigned`. In most systems, array is limited to store up to 2^32-1 elements.
You may access the elements in array by integer literal, for example, `a[1]`, `a[2]`. However, `a[0]` will generate a compiler error. It is because two overloaded operators `operator[](SizeType)` and `operator[](const char*)` is available, and C++ can treat `0` as a null pointer. Workarounds:
* `a[SizeType(0)]`
* `a[0u]`
You may access the elements in array by integer literal, for example, `a[0]`, `a[1]`, `a[2]`.
Array is similar to `std::vector`, instead of using indices, you may also use iterator to access all the elements.
~~~~~~~~~~cpp

33
include/rapidjson/document.h
View File

@ -795,15 +795,6 @@ public:
//! Check whether the object is empty.
bool ObjectEmpty() const { RAPIDJSON_ASSERT(IsObject()); return data_.o.size == 0; }
template <typename T>
GenericValue& operator[](T t) {
return DoIndex(t, internal::IsPointer<T>());
}
template <typename T>
const GenericValue& operator[](T t) const { return const_cast<GenericValue&>(*this)[t]; }
private:
//! Get the value associated with the name.
/*!
\note In version 0.1x, if the member is not found, this function returns a null value. This makes issue 7.
@ -812,20 +803,14 @@ private:
A better approach is to use FindMember().
\note Linear time complexity.
*/
GenericValue& DoIndex(const Ch* name, internal::TrueType) {
template <typename T>
RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(GenericValue&)) operator[](T* name) {
GenericValue n(StringRef(name));
return (*this)[n];
}
template <typename T>
RAPIDJSON_DISABLEIF_RETURN((internal::NotExpr<internal::IsSame<typename internal::RemoveConst<T>::Type, Ch> >),(const GenericValue&)) operator[](T* name) const { return const_cast<GenericValue&>(*this)[name]; }
//! Get an element from array by index.
/*! \param index Zero-based index of element.
*/
GenericValue& DoIndex(SizeType index, internal::FalseType) {
RAPIDJSON_ASSERT(IsArray());
RAPIDJSON_ASSERT(index < data_.a.size);
return data_.a.elements[index];
}
public:
// This version is faster because it does not need a StrLen().
@ -1150,6 +1135,16 @@ public:
data_.a.size = 0;
}
//! Get an element from array by index.
/*! \param index Zero-based index of element.
*/
GenericValue& operator[](SizeType index) {
RAPIDJSON_ASSERT(IsArray());
RAPIDJSON_ASSERT(index < data_.a.size);
return data_.a.elements[index];
}
const GenericValue& operator[](SizeType index) const { return const_cast<GenericValue&>(*this)[index]; }
//! Element iterator
/*! \pre IsArray() == true */
ValueIterator Begin() { RAPIDJSON_ASSERT(IsArray()); return data_.a.elements; }