mirror of https://github.com/nlohmann/json.git synced 2025-06-08 00:22:37 +08:00

Florian Albrechtskirchinger 5352856f04

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>

2022-04-29 21:40:02 +02:00

2.9 KiB

Raw Blame History

nlohmann::basic_json::contains

// (1)
bool contains(const typename object_t::key_type& key) const;

// (2)
template<typename KeyType>
bool contains(KeyType&& key) const;

// (3)
bool contains(const json_pointer& ptr) const;

Check whether an element exists in a JSON object with a key equivalent to key. If the element is not found or the JSON value is not an object, #!cpp false is returned.
See 1. 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.
Check whether the given JSON pointer ptr can be resolved in the current JSON value.

Template parameters

KeyType: A type for an object key other than json_pointer that is comparable with string_t using object_comparator_t. This can also be a string view (C++17).

Parameters

key (in): key value to check its existence.
ptr (in): JSON pointer to check its existence.

Return value

#!cpp true if an element with specified key exists. If no such element with such key is found or the JSON value is not an object, #!cpp false is returned.
See 1.
#!cpp true if the JSON pointer can be resolved to a stored value, #!cpp false otherwise.

Exception safety

Strong exception safety: if an exception occurs, the original value stays intact.

Exceptions

The function does not throw exceptions.
The function does not throw exceptions.
The function can throw the following exceptions:
- Throws parse_error.106 if an array index begins with 0.
- Throws parse_error.109 if an array index was not a number.

Complexity

Logarithmic in the size of the JSON object.

Notes

This method always returns #!cpp false when executed on a JSON type that is not an object.
This method can be executed on any JSON value type.

!!! info "Postconditions"

If `#!cpp j.contains(x)` returns `#!c true` for a key or JSON pointer `x`, then it is safe to call `j[x]`.

Examples

??? example "Example (1) check with key"

The example shows how `contains()` is used.

```cpp
--8<-- "examples/contains.cpp"
```

Output:

```json
--8<-- "examples/contains.output"
```

??? example "Example (3) check with JSON pointer"

The example shows how `contains()` is used.

```cpp
--8<-- "examples/contains_json_pointer.cpp"
```

Output:

```json
--8<-- "examples/contains_json_pointer.output"
```

Version history

Added in version 3.11.0.
Added in version 3.6.0. Extended template KeyType to support comparable types in version 3.11.0.
Added in version 3.7.0.

2.9 KiB Raw Blame History