keyword stringclasses 7
values | repo_name stringlengths 8 98 | file_path stringlengths 4 244 | file_extension stringclasses 29
values | file_size int64 0 84.1M | line_count int64 0 1.6M | content stringlengths 1 84.1M ⌀ | language stringclasses 14
values |
|---|---|---|---|---|---|---|---|
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/json_noexception.md | .md | 1,085 | 46 | # JSON_NOEXCEPTION
```cpp
#define JSON_NOEXCEPTION
```
Exceptions can be switched off by defining the symbol `JSON_NOEXCEPTION`. When defining `JSON_NOEXCEPTION`, `#!cpp try`
is replaced by `#!cpp if (true)`, `#!cpp catch` is replaced by `#!cpp if (false)`, and `#!cpp throw` is replaced by
`#!cpp std::abort()`.
The ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/json_has_three_way_comparison.md | .md | 744 | 33 | # JSON_HAS_THREE_WAY_COMPARISON
```cpp
#define JSON_HAS_THREE_WAY_COMPARISON /* value */
```
This macro indicates whether the compiler and standard library support 3-way comparison.
Possible values are `1` when supported or `0` when unsupported.
## Default definition
The default value is detected based on the prepr... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/json_skip_unsupported_compiler_check.md | .md | 716 | 34 | # JSON_SKIP_UNSUPPORTED_COMPILER_CHECK
```cpp
#define JSON_SKIP_UNSUPPORTED_COMPILER_CHECK
```
When defined, the library will not create a compile error when a known unsupported compiler is detected. This allows to
use the library with compilers that do not fully support C++11 and may only work if unsupported feature... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/json_throw_user.md | .md | 2,609 | 76 | # JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER
```cpp
// (1)
#define JSON_CATCH_USER(exception) /* value */
// (2)
#define JSON_THROW_USER(exception) /* value */
// (3)
#define JSON_TRY_USER /* value */
```
Controls how exceptions are handled by the library.
1. This macro overrides [`#!cpp catch`](https://en.cppr... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/json_has_filesystem.md | .md | 1,514 | 44 | # JSON_HAS_FILESYSTEM / JSON_HAS_EXPERIMENTAL_FILESYSTEM
```cpp
#define JSON_HAS_FILESYSTEM /* value */
#define JSON_HAS_EXPERIMENTAL_FILESYSTEM /* value */
```
When compiling with C++17, the library provides conversions from and to
[`std::filesystem::path`](https://en.cppreference.com/w/cpp/filesystem/path). As comp... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/nlohmann_json_namespace.md | .md | 1,115 | 42 | # NLOHMANN_JSON_NAMESPACE
```cpp
#define NLOHMANN_JSON_NAMESPACE /* value */
```
This macro evaluates to the full name of the `nlohmann` namespace.
## Default definition
The default value consists of the root namespace (`nlohmann`) and an inline ABI namespace. See
[`nlohmann` Namespace](../../features/namespace.md#... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/nlohmann_define_type_non_intrusive.md | .md | 5,228 | 128 | # NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT
```cpp
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(type, member...) // (1)
#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(type, member...) // (2)
```
These macros can be used to simplify the serialization/deseri... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/nlohmann_json_namespace_no_version.md | .md | 1,074 | 46 | # NLOHMANN_JSON_NAMESPACE_NO_VERSION
```cpp
#define NLOHMANN_JSON_NAMESPACE_NO_VERSION /* value */
```
If defined to `1`, the version component is omitted from the inline namespace. See
[`nlohmann` Namespace](../../features/namespace.md#structure) for details.
## Default definition
The default value is `0`.
```cpp... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/macros/json_has_cpp_11.md | .md | 1,145 | 42 | # JSON_HAS_CPP_11, JSON_HAS_CPP_14, JSON_HAS_CPP_17, JSON_HAS_CPP_20
```cpp
#define JSON_HAS_CPP_11
#define JSON_HAS_CPP_14
#define JSON_HAS_CPP_17
#define JSON_HAS_CPP_20
```
The library targets C++11, but also supports some features introduced in later C++ versions (e.g., `std::string_view`
support for C++17). For ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/adl_serializer/to_json.md | .md | 986 | 44 | # <small>nlohmann::adl_serializer::</small>to_json
```cpp
template<typename BasicJsonType, typename TargetType = ValueType>
static auto to_json(BasicJsonType& j, TargetType && val) noexcept(
noexcept(::nlohmann::to_json(j, std::forward<TargetType>(val))))
-> decltype(::nlohmann::to_json(j, std::forward<TargetType>... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/adl_serializer/index.md | .md | 908 | 36 | # <small>nlohmann::</small>adl_serializer
```cpp
template<typename, typename>
struct adl_serializer;
```
Serializer that uses ADL ([Argument-Dependent Lookup](https://en.cppreference.com/w/cpp/language/adl)) to choose
`to_json`/`from_json` functions from the types' namespaces.
It is implemented similar to
```cpp
te... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/adl_serializer/from_json.md | .md | 2,150 | 74 | # <small>nlohmann::adl_serializer::</small>from_json
```cpp
// (1)
template<typename BasicJsonType, typename TargetType = ValueType>
static auto from_json(BasicJsonType && j, TargetType& val) noexcept(
noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
-> decltype(::nlohmann::from_json(std::forw... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/byte_container_with_subtype/byte_container_with_subtype.md | .md | 1,021 | 47 | # <small>nlohmann::byte_container_with_subtype::</small>byte_container_with_subtype
```cpp
// (1)
byte_container_with_subtype();
// (2)
byte_container_with_subtype(const container_type& container);
byte_container_with_subtype(container_type&& container);
// (3)
byte_container_with_subtype(const container_type& conta... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/byte_container_with_subtype/set_subtype.md | .md | 767 | 42 | # <small>nlohmann::byte_container_with_subtype::</small>set_subtype
```cpp
void set_subtype(subtype_type subtype) noexcept;
```
Sets the binary subtype of the value, also flags a binary JSON value as having a subtype, which has implications for
serialization.
## Parameters
`subtype` (in)
: subtype to set
## Exce... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/byte_container_with_subtype/clear_subtype.md | .md | 755 | 37 | # <small>nlohmann::byte_container_with_subtype::</small>clear_subtype
```cpp
void clear_subtype() noexcept;
```
Clears the binary subtype and flags the value as not having a subtype, which has implications for serialization; for
instance MessagePack will prefer the bin family over the ext family.
## Exception safety... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/byte_container_with_subtype/index.md | .md | 1,244 | 36 | # <small>nlohmann::</small>byte_container_with_subtype
```cpp
template<typename BinaryType>
class byte_container_with_subtype : public BinaryType;
```
This type extends the template parameter `BinaryType` provided to [`basic_json`](../basic_json/index.md) with a subtype
used by BSON and MessagePack. This type exists ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/byte_container_with_subtype/subtype.md | .md | 1,002 | 43 | # <small>nlohmann::byte_container_with_subtype::</small>subtype
```cpp
constexpr subtype_type subtype() const noexcept;
```
Returns the numerical subtype of the value if it has a subtype. If it does not have a subtype, this function will return
`subtype_type(-1)` as a sentinel value.
## Return value
the numerical s... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/byte_container_with_subtype/has_subtype.md | .md | 682 | 40 | # <small>nlohmann::byte_container_with_subtype::</small>has_subtype
```cpp
constexpr bool has_subtype() const noexcept;
```
Returns whether the value has a subtype.
## Return value
whether the value has a subtype
## Exception safety
No-throw guarantee: this function never throws exceptions.
## Complexity
Consta... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_ValueType.md | .md | 2,404 | 83 | # <small>nlohmann::basic_json::</small>operator ValueType
```cpp
template<typename ValueType>
JSON_EXPLICIT operator ValueType() const;
```
Implicit type conversion between the JSON value and a compatible value. The call is realized by calling
[`get()`](get.md). See [Notes](#notes) for the meaning of `JSON_EXPLICIT`.... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/swap.md | .md | 4,902 | 157 | # <small>nlohmann::basic_json::</small>swap
```cpp
// (1)
void swap(reference other) noexcept;
// (2)
void swap(reference left, reference right) noexcept;
// (3)
void swap(array_t& other);
// (4)
void swap(object_t& other);
// (5)
void swap(string_t& other);
// (6)
void swap(binary_t& other);
// (7)
void swap(ty... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_gt.md | .md | 2,290 | 87 | # <small>nlohmann::basic_json::</small>operator>
```cpp
// until C++20
bool operator>(const_reference lhs, const_reference rhs) noexcept; // (1)
template<typename ScalarType>
bool operator>(const_reference lhs, const ScalarType rhs) noexcept; // (2)
template<typename ScalarType>
bool operator>(ScalarType lhs, con... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/json_base_class_t.md | .md | 1,165 | 46 | # <small>nlohmann::basic_json::</small>json_base_class_t
```cpp
using json_base_class_t = detail::json_base_class<CustomBaseClass>;
```
The base class used to inject custom functionality into each instance of `basic_json`.
Examples of such functionality might be metadata, additional member functions (e.g., visitors),... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_number_unsigned.md | .md | 1,056 | 47 | # <small>nlohmann::basic_json::</small>is_number_unsigned
```cpp
constexpr bool is_number_unsigned() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON value is an unsigned integer number. This excludes
floating-point and signed integer values.
## Return value
`#!cpp true` if type is... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/begin.md | .md | 663 | 43 | # <small>nlohmann::basic_json::</small>begin
```cpp
iterator begin() noexcept;
const_iterator begin() const noexcept;
```
Returns an iterator to the first element.
## Return value
iterator to the first element
## Exception safety
No-throw gu... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/default_object_comparator_t.md | .md | 863 | 36 | # <small>nlohmann::basic_json::</small>default_object_comparator_t
```cpp
using default_object_comparator_t = std::less<StringType>; // until C++14
using default_object_comparator_t = std::less<>; // since C++14
```
The default comparator used by [`object_t`](object_t.md).
Since C++14 a transparent comp... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/patch_inplace.md | .md | 2,575 | 71 | # <small>nlohmann::basic_json::</small>patch_inplace
```cpp
void patch_inplace(const basic_json& json_patch) const;
```
[JSON Patch](http://jsonpatch.com) defines a JSON document structure for expressing a sequence of operations to apply to
a JSON document. With this function, a JSON Patch is applied to the current J... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_number_integer.md | .md | 1,114 | 48 | # <small>nlohmann::basic_json::</small>is_number_integer
```cpp
constexpr bool is_number_integer() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON value is a signed or unsigned integer number. This excludes
floating-point values.
## Return value
`#!cpp true` if type is an integer ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_string.md | .md | 662 | 40 | # <small>nlohmann::basic_json::</small>is_string
```cpp
constexpr bool is_string() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON value is a string.
## Return value
`#!cpp true` if type is a string, `#!cpp false` otherwise.
## Exception safety
No-throw guarantee: this member fu... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/insert.md | .md | 6,528 | 180 | # <small>nlohmann::basic_json::</small>insert
```cpp
// (1)
iterator insert(const_iterator pos, const basic_json& val);
iterator insert(const_iterator pos, basic_json&& val);
// (2)
iterator insert(const_iterator pos, size_type cnt, const basic_json& val);
// (3)
iterator insert(const_iterator pos, const_iterator fi... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/other_error.md | .md | 1,697 | 68 | # <small>nlohmann::basic_json::</small>other_error
```cpp
class other_error : public exception;
```
This exception is thrown in case of errors that cannot be classified with the other exception types.
Exceptions have ids 5xx (see [list of other errors](../../home/exceptions.md#further-exceptions)).
```plantuml
std:... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/find.md | .md | 2,220 | 87 | # <small>nlohmann::basic_json::</small>find
```cpp
// (1)
iterator find(const typename object_t::key_type& key);
const_iterator find(const typename object_t::key_type& key) const;
// (2)
template<typename KeyType>
iterator find(KeyType&& key);
template<typename KeyType>
const_iterator find(KeyType&& key) const;
```
... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_structured.md | .md | 1,384 | 64 | # <small>nlohmann::basic_json::</small>is_structured
```cpp
constexpr bool is_structured() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON type is structured (array or object).
## Return value
`#!cpp true` if type is structured (array or object), `#!cpp false` otherwise.
## Excep... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/invalid_iterator.md | .md | 1,719 | 68 | # <small>nlohmann::basic_json::</small>invalid_iterator
```cpp
class invalid_iterator : public exception;
```
This exception is thrown if iterators passed to a library function do not match the expected semantics.
Exceptions have ids 2xx (see [list of iterator errors](../../home/exceptions.md#iterator-errors)).
```... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/to_cbor.md | .md | 1,480 | 62 | # <small>nlohmann::basic_json::</small>to_cbor
```cpp
// (1)
static std::vector<std::uint8_t> to_cbor(const basic_json& j);
// (2)
static void to_cbor(const basic_json& j, detail::output_adapter<std::uint8_t> o);
static void to_cbor(const basic_json& j, detail::output_adapter<char> o);
```
Serializes a given JSON va... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/array.md | .md | 1,614 | 61 | # <small>nlohmann::basic_json::</small>array
```cpp
static basic_json array(initializer_list_t init = {});
```
Creates a JSON array value from a given initializer list. That is, given a list of values `a, b, c`, creates the JSON
value `#!json [a, b, c]`. If the initializer list is empty, the empty array `#!json []` i... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/cbegin.md | .md | 641 | 42 | # <small>nlohmann::basic_json::</small>cbegin
```cpp
const_iterator cbegin() const noexcept;
```
Returns an iterator to the first element.
## Return value
iterator to the first element
## Exception safety
No-throw guarantee: this member func... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/size.md | .md | 1,544 | 58 | # <small>nlohmann::basic_json::</small>size
```cpp
size_type size() const noexcept;
```
Returns the number of elements in a JSON value.
## Return value
The return value depends on the different types and is defined as follows:
| Value type | return value |
|------------|-----------------... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_value_t.md | .md | 1,470 | 55 | # <small>nlohmann::basic_json::</small>operator value_t
```cpp
constexpr operator value_t() const noexcept;
```
Return the type of the JSON value as a value from the [`value_t`](value_t.md) enumeration.
## Return value
the type of the JSON value
| Value type | return value |
|-----... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_spaceship.md | .md | 3,045 | 101 | # <small>nlohmann::basic_json::</small>operator<=>
```cpp
// since C++20
class basic_json {
std::partial_ordering operator<=>(const_reference rhs) const noexcept; // (1)
template<typename ScalarType>
std::partial_ordering operator<=>(const ScalarType rhs) const noexcept; // (2)
};
```
1. 3-way compares ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/object.md | .md | 1,799 | 64 | # <small>nlohmann::basic_json::</small>object
```cpp
static basic_json object(initializer_list_t init = {});
```
Creates a JSON object value from a given initializer list. The initializer lists elements must be pairs, and their first
elements must be strings. If the initializer list is empty, the empty object `#!json... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/emplace_back.md | .md | 1,226 | 55 | # <small>nlohmann::basic_json::</small>emplace_back
```cpp
template<class... Args>
reference emplace_back(Args&& ... args);
```
Creates a JSON value from the passed parameters `args` to the end of the JSON value. If the function is called on a JSON
`#!json null` value, an empty array is created before appending the v... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/value.md | .md | 5,167 | 160 | # <small>nlohmann::basic_json::</small>value
```cpp
// (1)
template<class ValueType>
ValueType value(const typename object_t::key_type& key,
ValueType&& default_value) const;
// (2)
template<class ValueType, class KeyType>
ValueType value(KeyType&& key,
ValueType&& default_value) const... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_primitive.md | .md | 1,860 | 70 | # <small>nlohmann::basic_json::</small>is_primitive
```cpp
constexpr bool is_primitive() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON type is primitive (string, number, boolean, `#!json null`,
binary).
## Return value
`#!cpp true` if type is primitive (string, number, boolean, ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_le.md | .md | 2,336 | 88 | # <small>nlohmann::basic_json::</small>operator<=
```cpp
// until C++20
bool operator<=(const_reference lhs, const_reference rhs) noexcept; // (1)
template<typename ScalarType>
bool operator<=(const_reference lhs, const ScalarType rhs) noexcept; // (2)
template<typename ScalarType>
bool operator<=(ScalarType lhs,... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/erase.md | .md | 7,465 | 212 | # <small>nlohmann::basic_json::</small>erase
```cpp
// (1)
iterator erase(iterator pos);
const_iterator erase(const_iterator pos);
// (2)
iterator erase(iterator first, iterator last);
const_iterator erase(const_iterator first, const_iterator last);
// (3)
size_type erase(const typename object_t::key_type& key);
//... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/count.md | .md | 1,993 | 79 | # <small>nlohmann::basic_json::</small>count
```cpp
// (1)
size_type count(const typename object_t::key_type& key) const;
// (2)
template<typename KeyType>
size_type count(KeyType&& key) const;
```
1. Returns the number of elements with key `key`. If `ObjectType` is the default `std::map` type, the return value will... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/to_bjdata.md | .md | 1,939 | 71 | # <small>nlohmann::basic_json::</small>to_bjdata
```cpp
// (1)
static std::vector<std::uint8_t> to_bjdata(const basic_json& j,
const bool use_size = false,
const bool use_type = false);
// (2)
static void to_bjdata(const basic_json&... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_number_float.md | .md | 1,038 | 47 | # <small>nlohmann::basic_json::</small>is_number_float
```cpp
constexpr bool is_number_float() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON value is a floating-point number. This excludes signed and
unsigned integer values.
## Return value
`#!cpp true` if type is a floating-poi... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator[].md | .md | 8,075 | 242 | # <small>nlohmann::basic_json::</small>operator[]
```cpp
// (1)
reference operator[](size_type idx);
const_reference operator[](size_type idx) const;
// (2)
reference operator[](typename object_t::key_type key);
const_reference operator[](const typename object_t::key_type& key) const;
// (3)
template<typename KeyTyp... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/rbegin.md | .md | 726 | 43 | # <small>nlohmann::basic_json::</small>rbegin
```cpp
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
```
Returns an iterator to the reverse-beginning; that is, the last element.
## Return value
reverse ite... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/meta.md | .md | 3,249 | 57 | # <small>nlohmann::basic_json::</small>meta
```cpp
static basic_json meta();
```
This function returns a JSON object with information about the library, including the version number and information on
the platform and compiler.
## Return value
JSON object holding version information
| key | description... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/out_of_range.md | .md | 1,774 | 69 | # <small>nlohmann::basic_json::</small>out_of_range
```cpp
class out_of_range : public exception;
```
This exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for
instance in case of array indices or nonexisting object keys.
Exceptions have ids 4xx (see [li... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/number_unsigned_t.md | .md | 3,250 | 77 | # <small>nlohmann::basic_json::</small>number_unsigned_t
```cpp
using number_unsigned_t = NumberUnsignedType;
```
The type used to store JSON numbers (unsigned).
[RFC 8259](https://tools.ietf.org/html/rfc8259) describes numbers as follows:
> The representation of numbers is similar to that used in most programming l... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/sax_parse.md | .md | 3,195 | 116 | # <small>nlohmann::basic_json::</small>sax_parse
```cpp
// (1)
template <typename InputType, typename SAX>
static bool sax_parse(InputType&& i,
SAX* sax,
input_format_t format = input_format_t::json,
const bool strict = true,
const... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/get_binary.md | .md | 745 | 46 | # <small>nlohmann::basic_json::</small>get_binary
```cpp
binary_t& get_binary();
const binary_t& get_binary() const;
```
Returns a reference to the stored binary value.
## Return value
Reference to binary value.
## Exception safety
Strong exception safety: if an exception occurs, the original value stays intact.... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/to_ubjson.md | .md | 1,951 | 71 | # <small>nlohmann::basic_json::</small>to_ubjson
```cpp
// (1)
static std::vector<std::uint8_t> to_ubjson(const basic_json& j,
const bool use_size = false,
const bool use_type = false);
// (2)
static void to_ubjson(const basic_json&... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/cend.md | .md | 644 | 42 | # <small>nlohmann::basic_json::</small>cend
```cpp
const_iterator cend() const noexcept;
```
Returns an iterator to one past the last element.
## Return value
iterator one past the last element
## Exception safety
No-throw guarantee: this me... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/emplace.md | .md | 1,518 | 57 | # <small>nlohmann::basic_json::</small>emplace
```cpp
template<class... Args>
std::pair<iterator, bool> emplace(Args&& ... args);
```
Inserts a new element into a JSON object constructed in-place with the given `args` if there is no element with the key
in the container. If the function is called on a JSON null value... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/rend.md | .md | 832 | 44 | # <small>nlohmann::basic_json::</small>rend
```cpp
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
```
Returns an iterator to the reverse-end; that is, one before the first element. This element acts as a placeholder,
attempting to access it results in undefined behavior.
 enumeration.
## Return value
the type of the JSON value
| Value type | return value |
|-------------------------... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/empty.md | .md | 1,749 | 67 | # <small>nlohmann::basic_json::</small>empty
```cpp
bool empty() const noexcept;
```
Checks if a JSON value has no elements (i.e. whether its [`size()`](size.md) is `0`).
## Return value
The return value depends on the different types and is defined as follows:
| Value type | return value ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/get_allocator.md | .md | 502 | 32 | # <small>nlohmann::basic_json::</small>get_allocator
```cpp
static allocator_type get_allocator();
```
Returns the allocator associated with the container.
## Return value
associated allocator
## Examples
??? example
The example shows how `get_allocator()` is used to created `json` values.
```cp... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/std_swap.md | .md | 782 | 52 | # std::swap<basic_json\>
```cpp
namespace std {
void swap(nlohmann::basic_json& j1, nlohmann::basic_json& j2);
}
```
Exchanges the values of two JSON objects.
## Parameters
`j1` (in, out)
: value to be replaced by `j2`
`j2` (in, out)
: value to be replaced by `j1`
## Possible implementation
```cpp
void s... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/error_handler_t.md | .md | 950 | 43 | # <small>nlohmann::basic_json::</small>error_handler_t
```cpp
enum class error_handler_t {
strict,
replace,
ignore
};
```
This enumeration is used in the [`dump`](dump.md) function to choose how to treat decoding errors while serializing a
`basic_json` value. Three values are differentiated:
strict
: t... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_eq.md | .md | 4,589 | 169 | # <small>nlohmann::basic_json::</small>operator==
```cpp
// until C++20
bool operator==(const_reference lhs, const_reference rhs) noexcept; // (1)
template<typename ScalarType>
bool operator==(const_reference lhs, const ScalarType rhs) noexcept; // (2)
template<typename ScalarType>
bool operator==(ScalarType lhs,... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/json_serializer.md | .md | 866 | 42 | # <small>nlohmann::basic_json::</small>json_serializer
```cpp
template<typename T, typename SFINAE>
using json_serializer = JSONSerializer<T, SFINAE>;
```
## Template parameters
`T`
: type to convert; will be used in the `to_json`/`from_json` functions
`SFINAE`
: type to add compile type checks via SFINAE; usua... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/value_t.md | .md | 2,632 | 82 | # <small>nlohmann::basic_json::</small>value_t
```cpp
enum class value_t : std::uint8_t {
null,
object,
array,
string,
boolean,
number_integer,
number_unsigned,
number_float,
binary,
discarded
};
```
This enumeration collects the different JSON types. It is internally used to d... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/patch.md | .md | 2,545 | 74 | # <small>nlohmann::basic_json::</small>patch
```cpp
basic_json patch(const basic_json& json_patch) const;
```
[JSON Patch](http://jsonpatch.com) defines a JSON document structure for expressing a sequence of operations to apply to
a JSON document. With this function, a JSON Patch is applied to the current JSON value ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/update.md | .md | 3,853 | 143 | # <small>nlohmann::basic_json::</small>update
```cpp
// (1)
void update(const_reference j, bool merge_objects = false);
// (2)
void update(const_iterator first, const_iterator last, bool merge_objects = false);
```
1. Inserts all values from JSON object `j`.
2. Inserts all values from range `[first, last)`
When `me... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/from_cbor.md | .md | 4,172 | 118 | # <small>nlohmann::basic_json::</small>from_cbor
```cpp
// (1)
template<typename InputType>
static basic_json from_cbor(InputType&& i,
const bool strict = true,
const bool allow_exceptions = true,
const cbor_tag_handler_t tag_handler =... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/index.md | .md | 16,874 | 324 | # <small>nlohmann::</small>basic_json
<small>Defined in header `<nlohmann/json.hpp>`</small>
```cpp
template<
template<typename U, typename V, typename... Args> class ObjectType = std::map,
template<typename U, typename... Args> class ArrayType = std::vector,
class StringType = std::string,
class Bool... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/object_comparator_t.md | .md | 816 | 33 | # <small>nlohmann::basic_json::</small>object_comparator_t
```cpp
using object_comparator_t = typename object_t::key_compare;
// or
using object_comparator_t = default_object_comparator_t;
```
The comparator used by [`object_t`](object_t.md). Defined as `#!cpp typename object_t::key_compare` if available,
and [`defau... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/at.md | .md | 7,555 | 227 | # <small>nlohmann::basic_json::</small>at
```cpp
// (1)
reference at(size_type idx);
const_reference at(size_type idx) const;
// (2)
reference at(const typename object_t::key_type& key);
const_reference at(const typename object_t::key_type& key) const;
// (3)
template<typename KeyType>
reference at(KeyType&& key);
t... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/std_hash.md | .md | 777 | 35 | # <small>std::</small>hash<nlohmann::basic_json\>
```cpp
namespace std {
struct hash<nlohmann::basic_json>;
}
```
Return a hash value for a JSON object. The hash function tries to rely on `std::hash` where possible. Furthermore, the
type of the JSON value is taken into account to have different hash values for `#... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/to_bson.md | .md | 1,301 | 60 | # <small>nlohmann::basic_json::</small>to_bson
```cpp
// (1)
static std::vector<std::uint8_t> to_bson(const basic_json& j);
// (2)
static void to_bson(const basic_json& j, detail::output_adapter<std::uint8_t> o);
static void to_bson(const basic_json& j, detail::output_adapter<char> o);
```
BSON (Binary JSON) is a bi... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/accept.md | .md | 3,174 | 114 | # <small>nlohmann::basic_json::</small>accept
```cpp
// (1)
template<typename InputType>
static bool accept(InputType&& i,
const bool ignore_comments = false);
// (2)
template<typename IteratorType>
static bool accept(IteratorType first, IteratorType last,
const bool ignore_comme... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/dump.md | .md | 2,609 | 80 | # <small>nlohmann::basic_json::</small>dump
```cpp
string_t dump(const int indent = -1,
const char indent_char = ' ',
const bool ensure_ascii = false,
const error_handler_t error_handler = error_handler_t::strict) const;
```
Serialization function for JSON values. The functio... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/parse_error.md | .md | 2,115 | 75 | # <small>nlohmann::basic_json::</small>parse_error
```cpp
class parse_error : public exception;
```
This exception is thrown by the library when a parse error occurs. Parse errors can occur during the deserialization of
JSON text, BSON, CBOR, MessagePack, UBJSON, as well as when using JSON Patch.
Member `byte` holds... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator+=.md | .md | 3,058 | 111 | # <small>nlohmann::basic_json::</small>operator+=
```cpp
// (1)
reference operator+=(basic_json&& val);
reference operator+=(const basic_json& val);
// (2)
reference operator+=(const typename object_t::value_type& val);
// (3)
reference operator+=(initializer_list_t init);
```
1. Appends the given element `val` to ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/string_t.md | .md | 2,187 | 67 | # <small>nlohmann::basic_json::</small>string_t
```cpp
using string_t = StringType;
```
The type used to store JSON strings.
[RFC 8259](https://tools.ietf.org/html/rfc8259) describes JSON strings as follows:
> A string is a sequence of zero or more Unicode characters.
To store objects in C++, a type is defined by t... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/parse.md | .md | 6,308 | 215 | # <small>nlohmann::basic_json::</small>parse
```cpp
// (1)
template<typename InputType>
static basic_json parse(InputType&& i,
const parser_callback_t cb = nullptr,
const bool allow_exceptions = true,
const bool ignore_comments = false);
// (2)
t... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/type_name.md | .md | 1,604 | 55 | # <small>nlohmann::basic_json::</small>type_name
```cpp
const char* type_name() const noexcept;
```
Returns the type name as string to be used in error messages -- usually to indicate that a function was called on a
wrong JSON type.
## Return value
a string representation of the type ([`value_t`](value_t.md)):
... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/number_integer_t.md | .md | 3,198 | 77 | # <small>nlohmann::basic_json::</small>number_integer_t
```cpp
using number_integer_t = NumberIntegerType;
```
The type used to store JSON numbers (integers).
[RFC 8259](https://tools.ietf.org/html/rfc8259) describes numbers as follows:
> The representation of numbers is similar to that used in most programming lang... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/crend.md | .md | 802 | 43 | # <small>nlohmann::basic_json::</small>crend
```cpp
const_reverse_iterator crend() const noexcept;
```
Returns an iterator to the reverse-end; that is, one before the first element. This element acts as a placeholder,
attempting to access it results in undefined behavior.
```cpp
template <typename BasicJsonType>
std::string to_string(const BasicJsonType& j);
```
This function implements a user-defined to_string for JSON objects.
## Template parameters
`BasicJsonType`
: a specialization of [`basic_json`](index.md)
## Return value
string containing the seri... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/array_t.md | .md | 1,744 | 69 | # <small>nlohmann::basic_json::</small>array_t
```cpp
using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
```
The type used to store JSON arrays.
[RFC 8259](https://tools.ietf.org/html/rfc8259) describes JSON arrays as follows:
> An array is an ordered sequence of zero or more values.
To store objects... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/boolean_t.md | .md | 930 | 43 | # <small>nlohmann::basic_json::</small>boolean_t
```cpp
using boolean_t = BooleanType;
```
The type used to store JSON booleans.
[RFC 8259](https://tools.ietf.org/html/rfc8259) implicitly describes a boolean as a type which differentiates the two
literals `#!json true` and `#!json false`.
To store objects in C++, a... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/operator_ge.md | .md | 2,349 | 87 | # <small>nlohmann::basic_json::</small>operator>=
```cpp
// until C++20
bool operator>=(const_reference lhs, const_reference rhs) noexcept; // (1)
template<typename ScalarType>
bool operator>=(const_reference lhs, const ScalarType rhs) noexcept; // (2)
template<typename ScalarType>
bool operator>=(ScalarType lhs,... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/parse_event_t.md | .md | 800 | 30 | # <small>nlohmann::basic_json::</small>parse_event_t
```cpp
enum class parse_event_t : std::uint8_t {
object_start,
object_end,
array_start,
array_end,
key,
value
};
```
The parser callback distinguishes the following events:
- `object_start`: the parser read `{` and started to process a JSON... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_boolean.md | .md | 689 | 40 | # <small>nlohmann::basic_json::</small>is_boolean
```cpp
constexpr bool is_boolean() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON value is `#!json true` or `#!json false`.
## Return value
`#!cpp true` if type is boolean, `#!cpp false` otherwise.
## Exception safety
No-throw g... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/from_bjdata.md | .md | 2,686 | 94 | # <small>nlohmann::basic_json::</small>from_bjdata
```cpp
// (1)
template<typename InputType>
static basic_json from_bjdata(InputType&& i,
const bool strict = true,
const bool allow_exceptions = true);
// (2)
template<typename IteratorType>
static basic_json ... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/is_null.md | .md | 662 | 40 | # <small>nlohmann::basic_json::</small>is_null
```cpp
constexpr bool is_null() const noexcept;
```
This function returns `#!cpp true` if and only if the JSON value is `#!json null`.
## Return value
`#!cpp true` if type is `#!json null`, `#!cpp false` otherwise.
## Exception safety
No-throw guarantee: this mem... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/max_size.md | .md | 1,806 | 61 | # <small>nlohmann::basic_json::</small>max_size
```cpp
size_type max_size() const noexcept;
```
Returns the maximum number of elements a JSON value is able to hold due to system or library implementation limitations,
i.e. `std::distance(begin(), end())` for the JSON value.
## Return value
The return value depen... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/merge_patch.md | .md | 1,537 | 64 | # <small>nlohmann::basic_json::</small>merge_patch
```cpp
void merge_patch(const basic_json& apply_patch);
```
The merge patch format is primarily intended for use with the HTTP PATCH method as a means of describing a set of
modifications to a target resource's content. This function applies a merge patch to the curr... | Markdown |
3D | OpenMS/OpenMS | src/openms/extern/nlohmann_json/docs/mkdocs/docs/api/basic_json/from_ubjson.md | .md | 3,556 | 107 | # <small>nlohmann::basic_json::</small>from_ubjson
```cpp
// (1)
template<typename InputType>
static basic_json from_ubjson(InputType&& i,
const bool strict = true,
const bool allow_exceptions = true);
// (2)
template<typename IteratorType>
static basic_json ... | Markdown |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.