mirror of https://github.com/nlohmann/json.git synced 2026-10-03 07:25:20 +00:00

Files

Niels Lohmann 904c8c6710 Index the large objects of json_view

Lookups in objects are linear, as for ordered_json. Objects with 128
members or more now get a hash table after parsing (open addressing; the
first of duplicate keys is kept, as for the linear search), so that
operator[], at(), find(), contains(), count(), value(), and JSON pointers
take constant time on average in them; the idea of switching to a hash
table for large objects is Boost.JSON's. The parser notes such objects when
it closes them (out of line, so that the parse loop only has a call for
it), and the object node keeps the number of its table.

Looking up each key of an object with 10,000 members: 59.8 ms -> 0.16 ms.
Parsing (json_document::parse, best of 7, separate processes): most files
within 1%; canada +5%, mesh.pretty +3%, citm +3%.

Tests: objects with 127, 128, 129, and 10,000 members (escaped, empty,
and duplicate keys, missing keys, comparisons), nested large objects, and
documents reused with read().

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

2026-09-30 21:01:58 +02:00

3.5 KiB

Raw Blame History

nlohmann::basic_json_view::contains

// (1)
bool contains(string_view_t key) const;
bool contains(const char* key) const;
bool contains(const string_t& key) const;

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

Checks whether the value is an object with a member with key key.
Checks whether a JSON pointer ptr can be resolved, starting at this value.

Parameters

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

Return value

#!cpp true if the value is an object and has a member with key key, #!cpp false otherwise
#!cpp true if ptr can be resolved to a value starting at this view, #!cpp false otherwise

Exception safety

No-throw guarantee: this function never throws exceptions.

Complexity

Linear in the number of members: as for ordered_json, members are compared one after another, in document order, stopping at the first match. Each comparison first checks the key's length -- already known from the index, without reading the key bytes -- before comparing its content. Objects with 128 or more members get a hash index while parsing, so that a lookup in them takes constant time on average.
Linear in the number of reference tokens of ptr and, for each token, in the number of members of the object at that level or the index into the array -- as for operator[] and at with a JSON pointer.

Notes

Overload 1 always returns #!cpp false when the value is not an object -- including a discarded view.

!!! info "Postconditions"

If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
`#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
throw.

!!! info "Overload 2 never throws"

Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
simply make it return `#!cpp false`.

Examples

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

The example below counts how many of a batch of records carry an optional `retry_of` field, using `contains()`
to check without ever materializing a single record of the batch.

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

Output:

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

??? example "Example: (2) check with JSON pointer"

The example below checks an optional, nested field with a JSON pointer, and shows two pointers that
`#!cpp contains()` resolves to `#!cpp false` without throwing.

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

Output:

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

Version history

Added in version 3.13.0.

3.5 KiB Raw Blame History