Implement support for string_view (attempt no. 3) (#3423)

* Add key_compare member to ordered_map

* Replace == with key_compare in ordered_map

* Expose the actual comparison function used by object_t

nlohmann::ordered_map uses a different comparison function than the one
provided via template parameter.
* Introduce a type trait to detect if object_t has a key_compare member.
* Rename object_comparator_t to default_object_comparator_t.
* Add object_comparator_t to be conditionally defined as
  object_t::key_compare, if available, or default_object_comparator_t
  otherwise.
* Update the documentation accordingly.

Co-authored-by: Niels Lohmann <niels.lohmann@gmail.com>

* Add type traits to check if a type is usable as object key

Add type trait to check:
* if a type is a specialization of a template.
* if a type is a json_pointer.
* if a type is a basic_json::{const_,}iterator.
* if two types are comparable using a given comparison functor.
* if a type is comparable to basic_json::object_t::key_type.
* if a type has a member type is_transparent.
* if a type is usable as object key.
* if a type has an erase() function accepting a given KeyType.

Co-authored-by: Niels Lohmann <niels.lohmann@gmail.com>

* Rework basic_json element access to accept more key types

Rework basic_json element access member functions and operators to
accept any type that meets the requirements defined by type trait
detail::is_usable_as_key_type.

Member functions and operators:
* at()
* operator[]
* value()
* erase()
* find()
* count()
* contains()

Update documentation to reflect these changes.

Add unit tests to excercise the new functions using std::string_view.

Co-authored-by: Niels Lohmann <niels.lohmann@gmail.com>

Co-authored-by: Niels Lohmann <niels.lohmann@gmail.com>

doc/mkdocs/docs/api/basic_json/operator[].md

@@ -6,26 +6,32 @@ reference operator[](size_type idx);
 const_reference operator[](size_type idx) const;
 
 // (2)
-reference operator[](const typename object_t::key_type& key);
+reference operator[](typename object_t::key_type key);
 const_reference operator[](const typename object_t::key_type& key) const;
-template<typename T>
-reference operator[](T* key);
-template<typename T>
-const_reference operator[](T* key) const;
 
 // (3)
+template<typename KeyType>
+reference operator[](KeyType&& key);
+template<typename KeyType>
+const_reference operator[](KeyType&& key) const;
+
+// (4)
 reference operator[](const json_pointer& ptr);
 const_reference operator[](const json_pointer& ptr) const;
 ```
 
 1. Returns a reference to the array element at specified location `idx`.
-2. Returns a reference to the object element at with specified key `key`.
-3. Returns a reference to the element at with specified JSON pointer `ptr`.
+2. Returns a reference to the object element with specified key `key`. The non-const qualified overload takes the key by value.
+3. See 2. This overload is only available if `KeyType` is comparable with `#!cpp typename object_t::key_type` and
+   `#!cpp typename object_comparator_t::is_transparent` denotes a type.
+4. Returns a reference to the element with specified JSON pointer `ptr`.
 
 ## Template parameters
 
-`T`
-:   string literal convertible to `object_t::key_type`
+`KeyType`
+:   A type for an object key other than [`json_pointer`](../json_pointer/index.md) that is comparable with
+    [`string_t`](string_t.md) using  [`object_comparator_t`](object_comparator_t.md).
+    This can also be a string view (C++17).
 
 ## Parameters
 
@@ -40,9 +46,10 @@ const_reference operator[](const json_pointer& ptr) const;
     
 ## Return value
 
-1. reference to the element at index `idx`
-2. reference to the element at key `key`
-3. reference to the element pointed to by `ptr`
+1. (const) reference to the element at index `idx`
+2. (const) reference to the element at key `key`
+3. (const) reference to the element at key `key`
+4. (const) reference to the element pointed to by `ptr`
 
 ## Exception safety
 
@@ -56,7 +63,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 2. The function can throw the following exceptions:
     - Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the JSON value is not an object
       or null; in that case, using the `[]` operator with a key makes no sense.
-3. The function can throw the following exceptions:
+3. See 2.
+4. The function can throw the following exceptions:
     - Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in the passed
       JSON pointer `ptr` begins with '0'.
     - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in the passed
@@ -70,7 +78,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 
 1. Constant if `idx` is in the range of the array. Otherwise, linear in `idx - size()`.
 2. Logarithmic in the size of the container.
-3. Constant
+3. Logarithmic in the size of the container.
+4. Logarithmic in the size of the container.
 
 ## Notes
 
@@ -87,7 +96,9 @@ Strong exception safety: if an exception occurs, the original value stays intact
 2. If `key` is not found in the object, then it is silently added to the object and filled with a `#!json null` value to
    make `key` a valid reference. In case the value was `#!json null` before, it is converted to an object.
 
-3. `null` values are created in arrays and objects if necessary.
+3. See 2.
+
+4. `null` values are created in arrays and objects if necessary.
    
     In particular:
 
@@ -143,7 +154,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
     --8<-- "examples/operatorarray__key_type.output"
     ```
 
-??? example "Example (2): access specified object element"
+??? example "Example (2): access specified object element (const)"
 
     The example below shows how object elements can be read using the `[]` operator.
     
@@ -157,7 +168,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
     --8<-- "examples/operatorarray__key_type_const.output"
     ```
 
-??? example "Example (3): access specified element via JSON Pointer"
+??? example "Example (4): access specified element via JSON Pointer"
 
     The example below shows how values can be read and written using JSON Pointers.
     
@@ -171,7 +182,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
     --8<-- "examples/operatorjson_pointer.output"
     ```
 
-??? example "Example (3): access specified element via JSON Pointer"
+??? example "Example (4): access specified element via JSON Pointer (const)"
 
     The example below shows how values can be read using JSON Pointers.
     
@@ -193,5 +204,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
 ## Version history
 
 1. Added in version 1.0.0.
-2. Added in version 1.0.0. Overloads for `T* key` added in version 1.1.0.
-3. Added in version 2.0.0.
+2. Added in version 1.0.0. Added overloads for `T* key` in version 1.1.0. Removed overloads for `T* key` (replaced by 3) in version 3.11.0.
+3. Added in version 3.11.0.
+4. Added in version 2.0.0.