\ No newline at end of file
diff --git a/api/adl_serializer/from_json/index.html b/api/adl_serializer/from_json/index.html
new file mode 100644
index 000000000..b12ac5898
--- /dev/null
+++ b/api/adl_serializer/from_json/index.html
@@ -0,0 +1,104 @@
+ from_json - JSON for Modern C++
The example below shows how a from_json function can be implemented for a user-defined type. This function is called by the adl_serializer when get<ns::person>() is called.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+namespacens
+{
+// a simple struct to model a person
+structperson
+{
+std::stringname;
+std::stringaddress;
+intage;
+};
+}// namespace ns
+
+namespacens
+{
+voidfrom_json(constjson&j,person&p)
+{
+j.at("name").get_to(p.name);
+j.at("address").get_to(p.address);
+j.at("age").get_to(p.age);
+}
+}// namespace ns
+
+intmain()
+{
+jsonj;
+j["name"]="Ned Flanders";
+j["address"]="744 Evergreen Terrace";
+j["age"]=60;
+
+autop=j.get<ns::person>();
+
+std::cout<<p.name<<" ("<<p.age<<") lives in "<<p.address<<std::endl;
+}
+
Output:
NedFlanders(60)livesin744EvergreenTerrace
+
Example: (2) Non-default-constructible type
The example below shows how a from_json is implemented as part of a specialization of the adl_serializer to realize the conversion of a non-default-constructible type.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+namespacens
+{
+// a simple struct to model a person (not default constructible)
+structperson
+{
+person(std::stringn,std::stringa,intaa)
+:name(std::move(n)),address(std::move(a)),age(aa)
+{}
+
+std::stringname;
+std::stringaddress;
+intage;
+};
+}// namespace ns
+
+namespacenlohmann
+{
+template<>
+structadl_serializer<ns::person>
+{
+staticns::personfrom_json(constjson&j)
+{
+return{j.at("name"),j.at("address"),j.at("age")};
+}
+
+// Here's the catch! You must provide a to_json method! Otherwise, you
+// will not be able to convert person to json, since you fully
+// specialized adl_serializer on that type
+staticvoidto_json(json&j,ns::personp)
+{
+j["name"]=p.name;
+j["address"]=p.address;
+j["age"]=p.age;
+}
+};
+}// namespace nlohmann
+
+intmain()
+{
+jsonj;
+j["name"]="Ned Flanders";
+j["address"]="744 Evergreen Terrace";
+j["age"]=60;
+
+autop=j.get<ns::person>();
+
+std::cout<<p.name<<" ("<<p.age<<") lives in "<<p.address<<std::endl;
+}
+
\ No newline at end of file
diff --git a/api/adl_serializer/index.html b/api/adl_serializer/index.html
new file mode 100644
index 000000000..2452b112b
--- /dev/null
+++ b/api/adl_serializer/index.html
@@ -0,0 +1,15 @@
+ Overview - JSON for Modern C++
Serializer that uses ADL (Argument-Dependent Lookup) to choose to_json/from_json functions from the types' namespaces.
It is implemented similar to
template<typenameValueType>
+structadl_serializer{
+template<typenameBasicJsonType>
+staticvoidto_json(BasicJsonType&j,constT&value){
+// calls the "to_json" method in T's namespace
+}
+
+template<typenameBasicJsonType>
+staticvoidfrom_json(constBasicJsonType&j,T&value){
+// same thing, but with the "from_json" method
+}
+};
+
\ No newline at end of file
diff --git a/api/adl_serializer/to_json/index.html b/api/adl_serializer/to_json/index.html
new file mode 100644
index 000000000..eade8bd84
--- /dev/null
+++ b/api/adl_serializer/to_json/index.html
@@ -0,0 +1,38 @@
+ to_json - JSON for Modern C++
The example below shows how a to_json function can be implemented for a user-defined type. This function is called by the adl_serializer when the constructor basic_json(ns::person) is called.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+namespacens
+{
+// a simple struct to model a person
+structperson
+{
+std::stringname;
+std::stringaddress;
+intage;
+};
+}// namespace ns
+
+namespacens
+{
+voidto_json(json&j,constperson&p)
+{
+j=json{{"name",p.name},{"address",p.address},{"age",p.age}};
+}
+}// namespace ns
+
+intmain()
+{
+ns::personp={"Ned Flanders","744 Evergreen Terrace",60};
+
+jsonj=p;
+
+std::cout<<j<<std::endl;
+}
+
\ No newline at end of file
diff --git a/api/basic_json/accept/index.html b/api/basic_json/accept/index.html
new file mode 100644
index 000000000..df99a3d00
--- /dev/null
+++ b/api/basic_json/accept/index.html
@@ -0,0 +1,37 @@
+ accept - JSON for Modern C++
The value_type of the iterator must be an integral type with size of 1, 2 or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
Unlike the parse function, this function neither throws an exception in case of invalid JSON input (i.e., a parse error) nor creates diagnostic information.
Ignoring comments via ignore_comments added in version 3.9.0.
Deprecation
Overload (2) replaces calls to accept with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like accept({ptr,ptr+len},...); with accept(ptr,ptr+len,...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/array/index.html b/api/basic_json/array/index.html
new file mode 100644
index 000000000..265b7c462
--- /dev/null
+++ b/api/basic_json/array/index.html
@@ -0,0 +1,25 @@
+ array - JSON for Modern C++
Creates a JSON array value from a given initializer list. That is, given a list of values a, b, c, creates the JSON value [a,b,c]. If the initializer list is empty, the empty array [] is created.
This function is only needed to express two edge cases that cannot be realized with the initializer list constructor (basic_json(initializer_list_t, bool, value_t)). These cases are:
creating an array whose elements are all pairs whose first element is a string -- in this case, the initializer list constructor would create an object, taking the first elements as keys
creating an empty array -- passing the empty initializer list to the initializer list constructor yields an empty object
\ No newline at end of file
diff --git a/api/basic_json/array_t/index.html b/api/basic_json/array_t/index.html
new file mode 100644
index 000000000..71cfe843a
--- /dev/null
+++ b/api/basic_json/array_t/index.html
@@ -0,0 +1,17 @@
+ array_t - JSON for Modern C++
An implementation may set limits on the maximum depth of nesting.
In this class, the array's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON array.
\ No newline at end of file
diff --git a/api/basic_json/at/index.html b/api/basic_json/at/index.html
new file mode 100644
index 000000000..58e96c34c
--- /dev/null
+++ b/api/basic_json/at/index.html
@@ -0,0 +1,508 @@
+ at - JSON for Modern C++
Returns a reference to the array element at specified location idx, with bounds checking.
Returns a reference to the object element with specified key key, with bounds checking.
See 2. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
Returns a reference to the element at specified JSON pointer ptr, with bounds checking.
Throws type_error.304 if the JSON value is not an array; in this case, calling at with an index makes no sense. See example below.
Throws out_of_range.401 if the index idx is out of range of the array; that is, idx >= size(). See example below.
The function can throw the following exceptions:
Throws type_error.304 if the JSON value is not an object; in this case, calling at with a key makes no sense. See example below.
Throws out_of_range.403 if the key key is not stored in the object; that is, find(key) == end(). See example below.
See 2.
The function can throw the following exceptions:
Throws parse_error.106 if an array index in the passed JSON pointer ptr begins with '0'. See example below.
Throws parse_error.109 if an array index in the passed JSON pointer ptr is not a number. See example below.
Throws out_of_range.401 if an array index in the passed JSON pointer ptr is out of range. See example below.
Throws out_of_range.402 if the array index '-' is used in the passed JSON pointer ptr. As at provides checked access (and no elements are implicitly inserted), the index '-' is always invalid. See example below.
Throws out_of_range.403 if the JSON pointer describes a key of an object which cannot be found. See example below.
Throws out_of_range.404 if the JSON pointer ptr can not be resolved. See example below.
Example: (3) access specified object element using string_view with bounds checking
The example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.
#include<iostream>
+#include<string_view>
+#include<nlohmann/json.hpp>
+
+usingnamespacestd::string_view_literals;
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create JSON object
+constjsonobject=
+{
+{"the good","il buono"},
+{"the bad","il cattivo"},
+{"the ugly","il brutto"}
+};
+
+// output element with key "the ugly" using string_view
+std::cout<<object.at("the ugly"sv)<<'\n';
+
+
+// exception type_error.304
+try
+{
+// use at() with string_view on a non-object type
+constjsonstr="I am a string";
+std::cout<<str.at("the good"sv)<<'\n';
+}
+catch(json::type_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// exception out_of_range.401
+try
+{
+// try to read from a nonexisting key using string_view
+std::cout<<object.at("the fast"sv)<<'\n';
+}
+catch(json::out_of_range)
+{
+std::cout<<"out of range"<<'\n';
+}
+}
+
Output:
"il brutto"
+[json.exception.type_error.304]cannotuseat()withstring
+outofrange
+
Example: (4) access specified element via JSON Pointer
The example below shows how object elements can be read and written using at(). It also demonstrates the different exceptions that can be thrown.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+usingnamespacenlohmann::literals;
+
+intmain()
+{
+// create a JSON value
+jsonj=
+{
+{"number",1},{"string","foo"},{"array",{1,2}}
+};
+
+// read-only access
+
+// output element with JSON pointer "/number"
+std::cout<<j.at("/number"_json_pointer)<<'\n';
+// output element with JSON pointer "/string"
+std::cout<<j.at("/string"_json_pointer)<<'\n';
+// output element with JSON pointer "/array"
+std::cout<<j.at("/array"_json_pointer)<<'\n';
+// output element with JSON pointer "/array/1"
+std::cout<<j.at("/array/1"_json_pointer)<<'\n';
+
+// writing access
+
+// change the string
+j.at("/string"_json_pointer)="bar";
+// output the changed string
+std::cout<<j["string"]<<'\n';
+
+// change an array element
+j.at("/array/1"_json_pointer)=21;
+// output the changed array
+std::cout<<j["array"]<<'\n';
+
+
+// out_of_range.106
+try
+{
+// try to use an array index with leading '0'
+json::referenceref=j.at("/array/01"_json_pointer);
+}
+catch(json::parse_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.109
+try
+{
+// try to use an array index that is not a number
+json::referenceref=j.at("/array/one"_json_pointer);
+}
+catch(json::parse_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.401
+try
+{
+// try to use an invalid array index
+json::referenceref=j.at("/array/4"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.402
+try
+{
+// try to use the array index '-'
+json::referenceref=j.at("/array/-"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.403
+try
+{
+// try to use a JSON pointer to a nonexistent object key
+json::const_referenceref=j.at("/foo"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.404
+try
+{
+// try to use a JSON pointer that cannot be resolved
+json::referenceref=j.at("/number/foo"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+}
+
Example: (4) access specified element via JSON Pointer
The example below shows how object elements can be read using at(). It also demonstrates the different exceptions that can be thrown.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+usingnamespacenlohmann::literals;
+
+intmain()
+{
+// create a JSON value
+constjsonj=
+{
+{"number",1},{"string","foo"},{"array",{1,2}}
+};
+
+// read-only access
+
+// output element with JSON pointer "/number"
+std::cout<<j.at("/number"_json_pointer)<<'\n';
+// output element with JSON pointer "/string"
+std::cout<<j.at("/string"_json_pointer)<<'\n';
+// output element with JSON pointer "/array"
+std::cout<<j.at("/array"_json_pointer)<<'\n';
+// output element with JSON pointer "/array/1"
+std::cout<<j.at("/array/1"_json_pointer)<<'\n';
+
+// out_of_range.109
+try
+{
+// try to use an array index that is not a number
+json::const_referenceref=j.at("/array/one"_json_pointer);
+}
+catch(json::parse_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.401
+try
+{
+// try to use an invalid array index
+json::const_referenceref=j.at("/array/4"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.402
+try
+{
+// try to use the array index '-'
+json::const_referenceref=j.at("/array/-"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.403
+try
+{
+// try to use a JSON pointer to a nonexistent object key
+json::const_referenceref=j.at("/foo"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+// out_of_range.404
+try
+{
+// try to use a JSON pointer that cannot be resolved
+json::const_referenceref=j.at("/number/foo"_json_pointer);
+}
+catch(json::out_of_range&e)
+{
+std::cout<<e.what()<<'\n';
+}
+}
+
\ No newline at end of file
diff --git a/api/basic_json/back/index.html b/api/basic_json/back/index.html
new file mode 100644
index 000000000..63fd60c69
--- /dev/null
+++ b/api/basic_json/back/index.html
@@ -0,0 +1,52 @@
+ back - JSON for Modern C++
In case of a structured type (array or object), a reference to the last element is returned. In case of number, string, boolean, or binary values, a reference to the value is returned.
\ No newline at end of file
diff --git a/api/basic_json/basic_json/index.html b/api/basic_json/basic_json/index.html
new file mode 100644
index 000000000..aa8607af3
--- /dev/null
+++ b/api/basic_json/basic_json/index.html
@@ -0,0 +1,462 @@
+ (Constructor) - JSON for Modern C++
Create an empty JSON value with a given type. The value will be default initialized with an empty value which depends on the type:
Value type
initial value
null
null
boolean
false
string
""
number
0
object
{}
array
[]
binary
empty array
The postcondition of this constructor can be restored by calling clear().
Create a null JSON value. It either takes a null pointer as parameter (explicitly creating null) or no parameter (implicitly creating null). The passed null pointer itself is not read -- it is only used to choose the right constructor.
This is a "catch all" constructor for all compatible JSON types; that is, types for which a to_json() method exists. The constructor forwards the parameter val to that method (to json_serializer<U>::to_json method with U = uncvref_t<CompatibleType>, to be exact).
Template type CompatibleType includes, but is not limited to, the following types:
arrays: array_t and all kinds of compatible containers such as std::vector, std::deque, std::list, std::forward_list, std::array, std::valarray, std::set, std::unordered_set, std::multiset, and std::unordered_multiset with a value_type from which a basic_json value can be constructed.
objects: object_t and all kinds of compatible associative containers such as std::map, std::unordered_map, std::multimap, and std::unordered_multimap with a key_type compatible to string_t and a value_type from which a basic_json value can be constructed.
strings: string_t, string literals, and all compatible string containers can be used.
binary: binary_t / std::vector<uint8_t> may be used; unfortunately because string literals cannot be distinguished from binary character arrays by the C++ type system, all types compatible with const char* will be directed to the string constructor instead. This is both for backwards compatibility, and due to the fact that a binary type is not a standard JSON type.
See the examples below.
This is a constructor for existing basic_json types. It does not hijack copy/move constructors, since the parameter has different template arguments than the current ones.
The constructor tries to convert the internal m_value of the parameter.
Creates a JSON value of type array or object from the passed initializer list init. In case type_deduction is true (default), the type of the JSON value to be created is deducted from the initializer list init according to the following rules:
If the list is empty, an empty JSON object value {} is created.
If the list consists of pairs whose first element is a string, a JSON object value is created where the first elements of the pairs are treated as keys and the second elements are as values.
In all other cases, an array is created.
The rules aim to create the best fit between a C++ initializer list and JSON values. The rationale is as follows:
The empty initializer list is written as {} which is exactly an empty JSON object.
C++ has no way of describing mapped types other than to list a list of pairs. As JSON requires that keys must be of type string, rule 2 is the weakest constraint one can pose on initializer lists to interpret them as an object.
In all other cases, the initializer list could not be interpreted as JSON object type, so interpreting it as JSON array type is safe.
With the rules described above, the following JSON values cannot be expressed by an initializer list:
the empty array ([]): use array(initializer_list_t) with an empty initializer list in this case
arrays whose elements satisfy rule 2: use array(initializer_list_t) with the same initializer list in this case
Function array() and object() force array and object creation from initializer lists, respectively.
Constructs a JSON array value by creating cnt copies of a passed value. In case cnt is 0, an empty array is created.
Constructs the JSON value with the contents of the range [first, last). The semantics depends on the different types a JSON value can have:
In case of other primitive types (number, boolean, or string), first must be begin() and last must be end(). In this case, the value is copied. Otherwise, invalid_iterator.204 is thrown.
In case of structured types (array, object), the constructor behaves as similar versions for std::vector or std::map; that is, a JSON array or object is constructed from the values in the range.
Creates a copy of a given JSON value.
Move constructor. Constructs a JSON value with the contents of the given value other using move semantics. It "steals" the resources from other and leaves it as JSON null value.
the value to be forwarded to the respective constructor
init (in)
initializer list with JSON values
type_deduction (in)
internal parameter; when set to true, the type of the JSON value is deducted from the initializer list init; when set to false, the type provided via manual_type is forced. This mode is used by the functions array(initializer_list_t) and object(initializer_list_t).
manual_type (in)
internal parameter; when type_deduction is set to false, the created JSON value will use the provided type (only value_t::array and value_t::object are valid); when type_deduction is set to true, this parameter has no effect
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
No-throw guarantee: this constructor never throws exceptions.
Depends on the called constructor. For types directly supported by the library (i.e., all types for which no to_json() function was provided), strong guarantee holds: if an exception is thrown, there are no changes to any JSON value.
Depends on the called constructor. For types directly supported by the library (i.e., all types for which no to_json() function was provided), strong guarantee holds: if an exception is thrown, there are no changes to any JSON value.
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
Strong guarantee: if an exception is thrown, there are no changes to any JSON value.
No-throw guarantee: this constructor never throws exceptions.
Throws type_error.301 if type_deduction is false, manual_type is value_t::object, but init contains an element which is not a pair whose first element is a string. In this case, the constructor could not create an object. If type_deduction would have been true, an array would have been created. See object(initializer_list_t) for an example.
(none)
The function can throw the following exceptions:
Throws invalid_iterator.201 if iterators first and last are not compatible (i.e., do not belong to the same JSON value). In this case, the range [first, last) is undefined.
Throws invalid_iterator.204 if iterators first and last belong to a primitive type (number, boolean, or string), but first does not point to the first element anymore. In this case, the range [first, last) is undefined. See example code below.
Throws invalid_iterator.206 if iterators first and last belong to a null value. In this case, the range [first, last) is undefined.
When used without parentheses around an empty initializer list, basic_json() is called instead of this function, yielding the JSON null value.
Overload 7:
Preconditions
Iterators first and last must be initialized. **This precondition is enforced with a runtime assertion.
Range [first, last) is valid. Usually, this precondition cannot be checked efficiently. Only certain edge cases are detected; see the description of the exceptions above. A violation of this precondition yields undefined behavior.
Example: (1) create an empty value with a given type
The following code shows the constructor for different value_t values.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create the different JSON values with default values
+jsonj_null(json::value_t::null);
+jsonj_boolean(json::value_t::boolean);
+jsonj_number_integer(json::value_t::number_integer);
+jsonj_number_float(json::value_t::number_float);
+jsonj_object(json::value_t::object);
+jsonj_array(json::value_t::array);
+jsonj_string(json::value_t::string);
+
+// serialize the JSON values
+std::cout<<j_null<<'\n';
+std::cout<<j_boolean<<'\n';
+std::cout<<j_number_integer<<'\n';
+std::cout<<j_number_float<<'\n';
+std::cout<<j_object<<'\n';
+std::cout<<j_array<<'\n';
+std::cout<<j_string<<'\n';
+}
+
Output:
null
+false
+0
+0.0
+{}
+[]
+""
+
Example: (2) create a null object
The following code shows the constructor with and without a null pointer parameter.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// implicitly create a JSON null value
+jsonj1;
+
+// explicitly create a JSON null value
+jsonj2(nullptr);
+
+// serialize the JSON null value
+std::cout<<j1<<'\n'<<j2<<'\n';
+}
+
Output:
null
+null
+
Example: (3) create a JSON value from compatible types
The following code shows the constructor with several compatible types.
#include<iostream>
+#include<deque>
+#include<list>
+#include<forward_list>
+#include<set>
+#include<unordered_map>
+#include<unordered_set>
+#include<valarray>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// ============
+// object types
+// ============
+
+// create an object from an object_t value
+json::object_tobject_value={{"one",1},{"two",2}};
+jsonj_object_t(object_value);
+
+// create an object from std::map
+std::map<std::string,int>c_map
+{
+{"one",1},{"two",2},{"three",3}
+};
+jsonj_map(c_map);
+
+// create an object from std::unordered_map
+std::unordered_map<constchar*,double>c_umap
+{
+{"one",1.2},{"two",2.3},{"three",3.4}
+};
+jsonj_umap(c_umap);
+
+// create an object from std::multimap
+std::multimap<std::string,bool>c_mmap
+{
+{"one",true},{"two",true},{"three",false},{"three",true}
+};
+jsonj_mmap(c_mmap);// only one entry for key "three" is used
+
+// create an object from std::unordered_multimap
+std::unordered_multimap<std::string,bool>c_ummap
+{
+{"one",true},{"two",true},{"three",false},{"three",true}
+};
+jsonj_ummap(c_ummap);// only one entry for key "three" is used
+
+// serialize the JSON objects
+std::cout<<j_object_t<<'\n';
+std::cout<<j_map<<'\n';
+std::cout<<j_umap<<'\n';
+std::cout<<j_mmap<<'\n';
+std::cout<<j_ummap<<"\n\n";
+
+
+// ===========
+// array types
+// ===========
+
+// create an array from an array_t value
+json::array_tarray_value={"one","two",3,4.5,false};
+jsonj_array_t(array_value);
+
+// create an array from std::vector
+std::vector<int>c_vector{1,2,3,4};
+jsonj_vec(c_vector);
+
+// create an array from std::valarray
+std::valarray<short>c_valarray{10,9,8,7};
+jsonj_valarray(c_valarray);
+
+// create an array from std::deque
+std::deque<double>c_deque{1.2,2.3,3.4,5.6};
+jsonj_deque(c_deque);
+
+// create an array from std::list
+std::list<bool>c_list{true,true,false,true};
+jsonj_list(c_list);
+
+// create an array from std::forward_list
+std::forward_list<std::int64_t>c_flist{12345678909876,23456789098765,34567890987654,45678909876543};
+jsonj_flist(c_flist);
+
+// create an array from std::array
+std::array<unsignedlong,4>c_array{{1,2,3,4}};
+jsonj_array(c_array);
+
+// create an array from std::set
+std::set<std::string>c_set{"one","two","three","four","one"};
+jsonj_set(c_set);// only one entry for "one" is used
+
+// create an array from std::unordered_set
+std::unordered_set<std::string>c_uset{"one","two","three","four","one"};
+jsonj_uset(c_uset);// only one entry for "one" is used
+
+// create an array from std::multiset
+std::multiset<std::string>c_mset{"one","two","one","four"};
+jsonj_mset(c_mset);// both entries for "one" are used
+
+// create an array from std::unordered_multiset
+std::unordered_multiset<std::string>c_umset{"one","two","one","four"};
+jsonj_umset(c_umset);// both entries for "one" are used
+
+// serialize the JSON arrays
+std::cout<<j_array_t<<'\n';
+std::cout<<j_vec<<'\n';
+std::cout<<j_valarray<<'\n';
+std::cout<<j_deque<<'\n';
+std::cout<<j_list<<'\n';
+std::cout<<j_flist<<'\n';
+std::cout<<j_array<<'\n';
+std::cout<<j_set<<'\n';
+std::cout<<j_uset<<'\n';
+std::cout<<j_mset<<'\n';
+std::cout<<j_umset<<"\n\n";
+
+
+// ============
+// string types
+// ============
+
+// create string from a string_t value
+json::string_tstring_value="The quick brown fox jumps over the lazy dog.";
+jsonj_string_t(string_value);
+
+// create a JSON string directly from a string literal
+jsonj_string_literal("The quick brown fox jumps over the lazy dog.");
+
+// create string from std::string
+std::strings_stdstring="The quick brown fox jumps over the lazy dog.";
+jsonj_stdstring(s_stdstring);
+
+// serialize the JSON strings
+std::cout<<j_string_t<<'\n';
+std::cout<<j_string_literal<<'\n';
+std::cout<<j_stdstring<<"\n\n";
+
+
+// ============
+// number types
+// ============
+
+// create a JSON number from number_integer_t
+json::number_integer_tvalue_integer_t=-42;
+jsonj_integer_t(value_integer_t);
+
+// create a JSON number from number_unsigned_t
+json::number_integer_tvalue_unsigned_t=17;
+jsonj_unsigned_t(value_unsigned_t);
+
+// create a JSON number from an anonymous enum
+enum{enum_value=17};
+jsonj_enum(enum_value);
+
+// create values of different integer types
+shortn_short=42;
+intn_int=-23;
+longn_long=1024;
+int_least32_tn_int_least32_t=-17;
+uint8_tn_uint8_t=8;
+
+// create (integer) JSON numbers
+jsonj_short(n_short);
+jsonj_int(n_int);
+jsonj_long(n_long);
+jsonj_int_least32_t(n_int_least32_t);
+jsonj_uint8_t(n_uint8_t);
+
+// create values of different floating-point types
+json::number_float_tv_ok=3.141592653589793;
+json::number_float_tv_nan=NAN;
+json::number_float_tv_infinity=INFINITY;
+
+// create values of different floating-point types
+floatn_float=42.23;
+floatn_float_nan=1.0f/0.0f;
+doublen_double=23.42;
+
+// create (floating point) JSON numbers
+jsonj_ok(v_ok);
+jsonj_nan(v_nan);
+jsonj_infinity(v_infinity);
+jsonj_float(n_float);
+jsonj_float_nan(n_float_nan);
+jsonj_double(n_double);
+
+// serialize the JSON numbers
+std::cout<<j_integer_t<<'\n';
+std::cout<<j_unsigned_t<<'\n';
+std::cout<<j_enum<<'\n';
+std::cout<<j_short<<'\n';
+std::cout<<j_int<<'\n';
+std::cout<<j_long<<'\n';
+std::cout<<j_int_least32_t<<'\n';
+std::cout<<j_uint8_t<<'\n';
+std::cout<<j_ok<<'\n';
+std::cout<<j_nan<<'\n';
+std::cout<<j_infinity<<'\n';
+std::cout<<j_float<<'\n';
+std::cout<<j_float_nan<<'\n';
+std::cout<<j_double<<"\n\n";
+
+
+// =============
+// boolean types
+// =============
+
+// create boolean values
+jsonj_truth=true;
+jsonj_falsity=false;
+
+// serialize the JSON booleans
+std::cout<<j_truth<<'\n';
+std::cout<<j_falsity<<'\n';
+}
+
Output:
{"one":1,"two":2}
+{"one":1,"three":3,"two":2}
+{"one":1.2,"three":3.4,"two":2.3}
+{"one":true,"three":false,"two":true}
+{"one":true,"three":false,"two":true}
+
+["one","two",3,4.5,false]
+[1,2,3,4]
+[10,9,8,7]
+[1.2,2.3,3.4,5.6]
+[true,true,false,true]
+[12345678909876,23456789098765,34567890987654,45678909876543]
+[1,2,3,4]
+["four","one","three","two"]
+["four","three","two","one"]
+["four","one","one","two"]
+["four","two","one","one"]
+
+"The quick brown fox jumps over the lazy dog."
+"The quick brown fox jumps over the lazy dog."
+"The quick brown fox jumps over the lazy dog."
+
+-42
+17
+17
+42
+-23
+1024
+-17
+8
+3.141592653589793
+null
+null
+42.22999954223633
+null
+23.42
+
+true
+false
+
Note the output is platform-dependent.
Example: (5) create a container (array or object) from an initializer list
The example below shows how JSON values are created from initializer lists.
The code below shows the move constructor explicitly called via std::move.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON value
+jsona=23;
+
+// move contents of a to b
+jsonb(std::move(a));
+
+// serialize the JSON arrays
+std::cout<<a<<'\n';
+std::cout<<b<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/begin/index.html b/api/basic_json/begin/index.html
new file mode 100644
index 000000000..e0072760c
--- /dev/null
+++ b/api/basic_json/begin/index.html
@@ -0,0 +1,20 @@
+ begin - JSON for Modern C++
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to the first element
+json::iteratorit=array.begin();
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/binary/index.html b/api/basic_json/binary/index.html
new file mode 100644
index 000000000..47decae65
--- /dev/null
+++ b/api/basic_json/binary/index.html
@@ -0,0 +1,27 @@
+ binary - JSON for Modern C++
Creates a JSON binary array value from a given binary container.
Creates a JSON binary array value from a given binary container with subtype.
Binary values are part of various binary formats, such as CBOR, MessagePack, and BSON. This constructor is used to create a value for serialization to those formats.
Note, this function exists because of the difficulty in correctly specifying the correct template overload in the standard value ctor, as both JSON arrays and JSON binary arrays are backed with some form of a std::vector. Because JSON binary arrays are a non-standard extension it was decided that it would be best to prevent automatic initialization of a binary array type, for backwards compatibility and so it does not happen on accident.
\ No newline at end of file
diff --git a/api/basic_json/binary_t/index.html b/api/basic_json/binary_t/index.html
new file mode 100644
index 000000000..bfe16b114
--- /dev/null
+++ b/api/basic_json/binary_t/index.html
@@ -0,0 +1,13 @@
+ binary_t - JSON for Modern C++
This type is a type designed to carry binary data that appears in various serialized formats, such as CBOR's Major Type 2, MessagePack's bin, and BSON's generic binary subtype. This type is NOT a part of standard JSON and exists solely for compatibility with these binary types. As such, it is simply defined as an ordered sequence of zero or more byte values.
Additionally, as an implementation detail, the subtype of the binary data is carried around as a std::uint64_t, which is compatible with both of the binary data formats that use binary subtyping, (though the specific numbering is incompatible with each other, and it is up to the user to translate between them). The subtype is added to BinaryType via the helper type byte_container_with_subtype.
Bin format family stores a byte array in 2, 3, or 5 bytes of extra bytes in addition to the size of the byte array.
BSON's specifications describe several binary types; however, this type is intended to represent the generic binary type which has the description:
Generic binary subtype - This is the most commonly used binary subtype and should be the 'default' for drivers and tools.
None of these impose any limitations on the internal representation other than the basic unit of storage be some type of array whose parts are decomposable into bytes.
The default representation of this binary format is a std::vector<std::uint8_t>, which is a very common way to represent a byte array in modern C++.
Binary Arrays are stored as pointers in a basic_json type. That is, for any access to array values, a pointer of the type binary_t* must be dereferenced.
Binary values are represented as byte strings. Subtypes are written as tags.
MessagePack
If a subtype is given and the binary array contains exactly 1, 2, 4, 8, or 16 elements, the fixext family (fixext1, fixext2, fixext4, fixext8) is used. For other sizes, the ext family (ext8, ext16, ext32) is used. The subtype is then added as signed 8-bit integer.
If no subtype is given, the bin family (bin8, bin16, bin32) is used.
BSON
If a subtype is given, it is used and added as unsigned 8-bit integer.
If no subtype is given, the generic binary subtype 0x00 is used.
\ No newline at end of file
diff --git a/api/basic_json/boolean_t/index.html b/api/basic_json/boolean_t/index.html
new file mode 100644
index 000000000..2ec184e14
--- /dev/null
+++ b/api/basic_json/boolean_t/index.html
@@ -0,0 +1,13 @@
+ boolean_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/cbegin/index.html b/api/basic_json/cbegin/index.html
new file mode 100644
index 000000000..3f5dec2d3
--- /dev/null
+++ b/api/basic_json/cbegin/index.html
@@ -0,0 +1,19 @@
+ cbegin - JSON for Modern C++
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+constjsonarray={1,2,3,4,5};
+
+// get an iterator to the first element
+json::const_iteratorit=array.cbegin();
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/cbor_tag_handler_t/index.html b/api/basic_json/cbor_tag_handler_t/index.html
new file mode 100644
index 000000000..cfae4ed22
--- /dev/null
+++ b/api/basic_json/cbor_tag_handler_t/index.html
@@ -0,0 +1,38 @@
+ cbor_tag_handler_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/cend/index.html b/api/basic_json/cend/index.html
new file mode 100644
index 000000000..4124f8685
--- /dev/null
+++ b/api/basic_json/cend/index.html
@@ -0,0 +1,22 @@
+ cend - JSON for Modern C++
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to one past the last element
+json::const_iteratorit=array.cend();
+
+// decrement the iterator to point to the last element
+--it;
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/clear/index.html b/api/basic_json/clear/index.html
new file mode 100644
index 000000000..a0129254d
--- /dev/null
+++ b/api/basic_json/clear/index.html
@@ -0,0 +1,44 @@
+ clear - JSON for Modern C++
Clears the content of a JSON value and resets it to the default value as if basic_json(value_t) would have been called with the current value type from type():
\ No newline at end of file
diff --git a/api/basic_json/contains/index.html b/api/basic_json/contains/index.html
new file mode 100644
index 000000000..0eff9a57d
--- /dev/null
+++ b/api/basic_json/contains/index.html
@@ -0,0 +1,104 @@
+ contains - JSON for Modern C++
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, false is returned.
See 1. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
Check whether the given JSON pointer ptr can be resolved in the current JSON value.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+usingnamespacenlohmann::literals;
+
+intmain()
+{
+// create a JSON value
+jsonj=
+{
+{"number",1},{"string","foo"},{"array",{1,2}}
+};
+
+std::cout<<std::boolalpha
+<<j.contains("/number"_json_pointer)<<'\n'
+<<j.contains("/string"_json_pointer)<<'\n'
+<<j.contains("/array"_json_pointer)<<'\n'
+<<j.contains("/array/1"_json_pointer)<<'\n'
+<<j.contains("/array/-"_json_pointer)<<'\n'
+<<j.contains("/array/4"_json_pointer)<<'\n'
+<<j.contains("/baz"_json_pointer)<<std::endl;
+
+try
+{
+// try to use an array index with leading '0'
+j.contains("/array/01"_json_pointer);
+}
+catch(json::parse_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+
+try
+{
+// try to use an array index that is not a number
+j.contains("/array/one"_json_pointer);
+}
+catch(json::parse_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+}
+
\ No newline at end of file
diff --git a/api/basic_json/count/index.html b/api/basic_json/count/index.html
new file mode 100644
index 000000000..b61f6d52a
--- /dev/null
+++ b/api/basic_json/count/index.html
@@ -0,0 +1,49 @@
+ count - JSON for Modern C++
Returns the number of elements with key key. If ObjectType is the default std::map type, the return value will always be 0 (key was not found) or 1 (key was found).
See 1. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
\ No newline at end of file
diff --git a/api/basic_json/crbegin/index.html b/api/basic_json/crbegin/index.html
new file mode 100644
index 000000000..7dc4d9381
--- /dev/null
+++ b/api/basic_json/crbegin/index.html
@@ -0,0 +1,19 @@
+ crbegin - JSON for Modern C++
The following code shows an example for crbegin().
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to the reverse-beginning
+json::const_reverse_iteratorit=array.crbegin();
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/crend/index.html b/api/basic_json/crend/index.html
new file mode 100644
index 000000000..ff5eeab01
--- /dev/null
+++ b/api/basic_json/crend/index.html
@@ -0,0 +1,22 @@
+ crend - JSON for Modern C++
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.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to the reverse-end
+json::const_reverse_iteratorit=array.crend();
+
+// increment the iterator to point to the first element
+--it;
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/default_object_comparator_t/index.html b/api/basic_json/default_object_comparator_t/index.html
new file mode 100644
index 000000000..0213ebc7f
--- /dev/null
+++ b/api/basic_json/default_object_comparator_t/index.html
@@ -0,0 +1,17 @@
+ default_object_comparator_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/diff/index.html b/api/basic_json/diff/index.html
new file mode 100644
index 000000000..c91891812
--- /dev/null
+++ b/api/basic_json/diff/index.html
@@ -0,0 +1,66 @@
+ diff - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/dump/index.html b/api/basic_json/dump/index.html
new file mode 100644
index 000000000..9eb61ab66
--- /dev/null
+++ b/api/basic_json/dump/index.html
@@ -0,0 +1,108 @@
+ dump - JSON for Modern C++
Serialization function for JSON values. The function tries to mimic Python's json.dumps() function, and currently supports its indent and ensure_ascii parameters.
If indent is nonnegative, then array elements and object members will be pretty-printed with that indent level. An indent level of 0 will only insert newlines. -1 (the default) selects the most compact representation.
indent_char (in)
The character to use for indentation if indent is greater than 0. The default is (space).
ensure_ascii (in)
If ensure_ascii is true, all non-ASCII characters in the output are escaped with \uXXXX sequences, and the result consists of ASCII characters only.
error_handler (in)
how to react on decoding errors; there are three possible values (see error_handler_t: strict (throws and exception in case a decoding error occurs; default), replace (replace invalid UTF-8 sequences with U+FFFD), and ignore (ignore invalid UTF-8 sequences during serialization; all bytes are copied to the output unchanged)).
\ No newline at end of file
diff --git a/api/basic_json/emplace/index.html b/api/basic_json/emplace/index.html
new file mode 100644
index 000000000..1ad46a784
--- /dev/null
+++ b/api/basic_json/emplace/index.html
@@ -0,0 +1,40 @@
+ emplace - JSON for Modern C++
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, an empty object is created before appending the value created from args.
a pair consisting of an iterator to the inserted element, or the already-existing element if no insertion happened, and a bool denoting whether the insertion took place.
The example shows how emplace() can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object. Further note how no value is added if there was already one value stored with the same key.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create JSON values
+jsonobject={{"one",1},{"two",2}};
+jsonnull;
+
+// print values
+std::cout<<object<<'\n';
+std::cout<<null<<'\n';
+
+// add values
+autores1=object.emplace("three",3);
+null.emplace("A","a");
+null.emplace("B","b");
+
+// the following call will not add an object, because there is already
+// a value stored at key "B"
+autores2=null.emplace("B","c");
+
+// print values
+std::cout<<object<<'\n';
+std::cout<<*res1.first<<" "<<std::boolalpha<<res1.second<<'\n';
+
+std::cout<<null<<'\n';
+std::cout<<*res2.first<<" "<<std::boolalpha<<res2.second<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/emplace_back/index.html b/api/basic_json/emplace_back/index.html
new file mode 100644
index 000000000..6ddbad094
--- /dev/null
+++ b/api/basic_json/emplace_back/index.html
@@ -0,0 +1,31 @@
+ emplace_back - JSON for Modern C++
Creates a JSON value from the passed parameters args to the end of the JSON value. If the function is called on a JSON null value, an empty array is created before appending the value created from args.
\ No newline at end of file
diff --git a/api/basic_json/empty/index.html b/api/basic_json/empty/index.html
new file mode 100644
index 000000000..3304fae3e
--- /dev/null
+++ b/api/basic_json/empty/index.html
@@ -0,0 +1,45 @@
+ empty - JSON for Modern C++
This function does not return whether a string stored as JSON value is empty -- it returns whether the JSON container itself is empty which is false in the case of a string.
\ No newline at end of file
diff --git a/api/basic_json/end/index.html b/api/basic_json/end/index.html
new file mode 100644
index 000000000..0c03f814f
--- /dev/null
+++ b/api/basic_json/end/index.html
@@ -0,0 +1,23 @@
+ end - JSON for Modern C++
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to one past the last element
+json::iteratorit=array.end();
+
+// decrement the iterator to point to the last element
+--it;
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/erase/index.html b/api/basic_json/erase/index.html
new file mode 100644
index 000000000..ab5ebaac3
--- /dev/null
+++ b/api/basic_json/erase/index.html
@@ -0,0 +1,151 @@
+ erase - JSON for Modern C++
Removes an element from a JSON value specified by iterator pos. The iterator pos must be valid and dereferenceable. Thus, the end() iterator (which is valid, but is not dereferenceable) cannot be used as a value for pos.
If called on a primitive type other than null, the resulting JSON value will be null.
Remove an element range specified by [first; last) from a JSON value. The iterator first does not need to be dereferenceable if first == last: erasing an empty range is a no-op.
If called on a primitive type other than null, the resulting JSON value will be null.
Removes an element from a JSON object by key.
See 3. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
Throws type_error.307 if called on a null value; example: "cannot use erase() with null"
Throws invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: "iterator does not fit current value"
Throws invalid_iterator.205 if called on a primitive type with invalid iterator (i.e., any iterator which is not begin()); example: "iterator out of range"
The function can throw the following exceptions:
Throws type_error.307 if called on a null value; example: "cannot use erase() with null"
Throws invalid_iterator.203 if called on iterators which does not belong to the current JSON value; example: "iterators do not fit current value"
Throws invalid_iterator.204 if called on a primitive type with invalid iterators (i.e., if first != begin() and last != end()); example: "iterators out of range"
The function can throw the following exceptions:
Throws type_error.307 when called on a type other than JSON object; example: "cannot use erase() with null"
See 3.
The function can throw the following exceptions:
Throws type_error.307 when called on a type other than JSON object; example: "cannot use erase() with null"
Throws out_of_range.401 when idx >= size(); example: "array index 17 is out of range"
\ No newline at end of file
diff --git a/api/basic_json/error_handler_t/index.html b/api/basic_json/error_handler_t/index.html
new file mode 100644
index 000000000..a0d39e32a
--- /dev/null
+++ b/api/basic_json/error_handler_t/index.html
@@ -0,0 +1,33 @@
+ error_handler_t - JSON for Modern C++
This enumeration is used in the dump function to choose how to treat decoding errors while serializing a basic_json value. Three values are differentiated:
strict
throw a type_error exception in case of invalid UTF-8
replace
replace invalid UTF-8 sequences with U+FFFD (� REPLACEMENT CHARACTER)
ignore
ignore invalid UTF-8 sequences; all bytes are copied to the output unchanged
The example below shows how the different values of the error_handler_t influence the behavior of dump when reading serializing an invalid UTF-8 sequence.
\ No newline at end of file
diff --git a/api/basic_json/exception/index.html b/api/basic_json/exception/index.html
new file mode 100644
index 000000000..0c200c45d
--- /dev/null
+++ b/api/basic_json/exception/index.html
@@ -0,0 +1,24 @@
+ exception - JSON for Modern C++
This class is an extension of std::exception objects with a member id for exception ids. It is used as the base class for all exceptions thrown by the basic_json class. This class can hence be used as "wildcard" to catch exceptions, see example below.
Subclasses:
parse_error for exceptions indicating a parse error
invalid_iterator for exceptions indicating errors with iterators
type_error for exceptions indicating executing a member function with a wrong type
out_of_range for exceptions indicating access out of the defined range
other_error for exceptions indicating other library errors
To have nothrow-copy-constructible exceptions, we internally use std::runtime_error which can cope with arbitrary-length error messages. Intermediate strings are built with static functions and then passed to the actual constructor.
\ No newline at end of file
diff --git a/api/basic_json/find/index.html b/api/basic_json/find/index.html
new file mode 100644
index 000000000..27d86d994
--- /dev/null
+++ b/api/basic_json/find/index.html
@@ -0,0 +1,58 @@
+ find - JSON for Modern C++
Finds an element in a JSON object with a key equivalent to key. If the element is not found or the JSON value is not an object, end() is returned.
See 1. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
Iterator to an element with a key equivalent to key. If no such element is found or the JSON value is not an object, a past-the-end iterator (see end()) is returned.
\ No newline at end of file
diff --git a/api/basic_json/flatten/index.html b/api/basic_json/flatten/index.html
new file mode 100644
index 000000000..594a413d0
--- /dev/null
+++ b/api/basic_json/flatten/index.html
@@ -0,0 +1,46 @@
+ flatten - JSON for Modern C++
The function creates a JSON object whose keys are JSON pointers (see RFC 6901) and whose values are all primitive (see is_primitive() for more information). The original JSON value can be restored using the unflatten() function.
\ No newline at end of file
diff --git a/api/basic_json/from_bjdata/index.html b/api/basic_json/from_bjdata/index.html
new file mode 100644
index 000000000..f9cfa0562
--- /dev/null
+++ b/api/basic_json/from_bjdata/index.html
@@ -0,0 +1,35 @@
+ from_bjdata - JSON for Modern C++
deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
\ No newline at end of file
diff --git a/api/basic_json/from_bson/index.html b/api/basic_json/from_bson/index.html
new file mode 100644
index 000000000..a4089a375
--- /dev/null
+++ b/api/basic_json/from_bson/index.html
@@ -0,0 +1,36 @@
+ from_bson - JSON for Modern C++
deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Overload (2) replaces calls to from_bson with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_bson(ptr,len,...); with from_bson(ptr,ptr+len,...);.
Overload (2) replaces calls to from_bson with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_bson({ptr,ptr+len},...); with from_bson(ptr,ptr+len,...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/from_cbor/index.html b/api/basic_json/from_cbor/index.html
new file mode 100644
index 000000000..97d2b272e
--- /dev/null
+++ b/api/basic_json/from_cbor/index.html
@@ -0,0 +1,38 @@
+ from_cbor - JSON for Modern C++
deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Changed to consume input adapters, removed start_index parameter, and added strict parameter in version 3.0.0.
Added allow_exceptions parameter in version 3.2.0.
Added tag_handler parameter in version 3.9.0.
Deprecation
Overload (2) replaces calls to from_cbor with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_cbor(ptr,len,...); with from_cbor(ptr,ptr+len,...);.
Overload (2) replaces calls to from_cbor with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_cbor({ptr,ptr+len},...); with from_cbor(ptr,ptr+len,...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/from_msgpack/index.html b/api/basic_json/from_msgpack/index.html
new file mode 100644
index 000000000..c79ef4abf
--- /dev/null
+++ b/api/basic_json/from_msgpack/index.html
@@ -0,0 +1,35 @@
+ from_msgpack - JSON for Modern C++
deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Changed to consume input adapters, removed start_index parameter, and added strict parameter in version 3.0.0.
Added allow_exceptions parameter in version 3.2.0.
Deprecation
Overload (2) replaces calls to from_msgpack with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_msgpack(ptr,len,...); with from_msgpack(ptr,ptr+len,...);.
Overload (2) replaces calls to from_cbor with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_msgpack({ptr,ptr+len},...); with from_msgpack(ptr,ptr+len,...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/from_ubjson/index.html b/api/basic_json/from_ubjson/index.html
new file mode 100644
index 000000000..5f9211b38
--- /dev/null
+++ b/api/basic_json/from_ubjson/index.html
@@ -0,0 +1,35 @@
+ from_ubjson - JSON for Modern C++
deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Added allow_exceptions parameter in version 3.2.0.
Deprecation
Overload (2) replaces calls to from_ubjson with a pointer and a length as first two parameters, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_ubjson(ptr,len,...); with from_ubjson(ptr,ptr+len,...);.
Overload (2) replaces calls to from_ubjson with a pair of iterators as their first parameter, which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like from_ubjson({ptr,ptr+len},...); with from_ubjson(ptr,ptr+len,...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/front/index.html b/api/basic_json/front/index.html
new file mode 100644
index 000000000..6fb61d035
--- /dev/null
+++ b/api/basic_json/front/index.html
@@ -0,0 +1,38 @@
+ front - JSON for Modern C++
In case of a structured type (array or object), a reference to the first element is returned. In case of number, string, boolean, or binary values, a reference to the value is returned.
\ No newline at end of file
diff --git a/api/basic_json/get/index.html b/api/basic_json/get/index.html
new file mode 100644
index 000000000..a8581b713
--- /dev/null
+++ b/api/basic_json/get/index.html
@@ -0,0 +1,106 @@
+ get - JSON for Modern C++
Explicit type conversion between the JSON value and a compatible value which is CopyConstructible and DefaultConstructible. The value is converted by calling the json_serializer<ValueType>from_json() method.
The example below shows several conversions from JSON values to other types. There a few things to note: (1) Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard std::vector<short>, (3) A JSON object can be converted to C++ associative containers such as std::unordered_map<std::string, json>.
The example below shows how pointers to internal values of a JSON value can be requested. Note that no type conversions are made and a #cpp nullptr is returned if the value and the requested pointer type does not match.
\ No newline at end of file
diff --git a/api/basic_json/get_allocator/index.html b/api/basic_json/get_allocator/index.html
new file mode 100644
index 000000000..0e87399bc
--- /dev/null
+++ b/api/basic_json/get_allocator/index.html
@@ -0,0 +1,21 @@
+ get_allocator - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/get_binary/index.html b/api/basic_json/get_binary/index.html
new file mode 100644
index 000000000..d86dbe747
--- /dev/null
+++ b/api/basic_json/get_binary/index.html
@@ -0,0 +1,21 @@
+ get_binary - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/get_ptr/index.html b/api/basic_json/get_ptr/index.html
new file mode 100644
index 000000000..331495e7c
--- /dev/null
+++ b/api/basic_json/get_ptr/index.html
@@ -0,0 +1,29 @@
+ get_ptr - JSON for Modern C++
The example below shows how pointers to internal values of a JSON value can be requested. Note that no type conversions are made and a nullptr is returned if the value and the requested pointer type does not match.
\ No newline at end of file
diff --git a/api/basic_json/get_ref/index.html b/api/basic_json/get_ref/index.html
new file mode 100644
index 000000000..731c687db
--- /dev/null
+++ b/api/basic_json/get_ref/index.html
@@ -0,0 +1,35 @@
+ get_ref - JSON for Modern C++
Throws type_error.303 if the requested reference type does not match the stored JSON value type; example: "incompatible ReferenceType for get_ref, actual type is binary".
\ No newline at end of file
diff --git a/api/basic_json/get_to/index.html b/api/basic_json/get_to/index.html
new file mode 100644
index 000000000..b270402ba
--- /dev/null
+++ b/api/basic_json/get_to/index.html
@@ -0,0 +1,78 @@
+ get_to - JSON for Modern C++
Explicit type conversion between the JSON value and a compatible value. The value is filled into the input parameter by calling the json_serializer<ValueType>from_json() method.
The example below shows several conversions from JSON values to other types. There a few things to note: (1) Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard std::vector<short>, (3) A JSON object can be converted to C++ associative containers such as #cpp std::unordered_map<std::string, json>.
\ No newline at end of file
diff --git a/api/basic_json/index.html b/api/basic_json/index.html
new file mode 100644
index 000000000..72d0f3b8f
--- /dev/null
+++ b/api/basic_json/index.html
@@ -0,0 +1,81 @@
+ Overview - JSON for Modern C++
StandardLayoutType: JSON values have standard layout: All non-static data members are private and standard layout types, the class has no virtual functions or (virtual) base classes.
\ No newline at end of file
diff --git a/api/basic_json/input_format_t/index.html b/api/basic_json/input_format_t/index.html
new file mode 100644
index 000000000..ae51e0ebd
--- /dev/null
+++ b/api/basic_json/input_format_t/index.html
@@ -0,0 +1,126 @@
+ input_format_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/insert/index.html b/api/basic_json/insert/index.html
new file mode 100644
index 000000000..a131c49bb
--- /dev/null
+++ b/api/basic_json/insert/index.html
@@ -0,0 +1,119 @@
+ insert - JSON for Modern C++
Throws type_error.309 if called on JSON values other than arrays; example: "cannot use insert() with string"
Throws invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: "iterator does not fit current value"
The function can throw the following exceptions:
Throws type_error.309 if called on JSON values other than arrays; example: "cannot use insert() with string"
Throws invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: "iterator does not fit current value"
The function can throw the following exceptions:
Throws type_error.309 if called on JSON values other than arrays; example: "cannot use insert() with string"
Throws invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: "iterator does not fit current value"
Throws invalid_iterator.210 if first and last do not belong to the same JSON value; example: "iterators do not fit"
Throws invalid_iterator.211 if first or last are iterators into container for which insert is called; example: "passed iterators may not belong to container"
The function can throw the following exceptions:
Throws type_error.309 if called on JSON values other than arrays; example: "cannot use insert() with string"
Throws invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: "iterator does not fit current value"
The function can throw the following exceptions:
Throws type_error.309 if called on JSON values other than objects; example: "cannot use insert() with string"
Throws invalid_iterator.202 if called on an iterator which does not belong to the current JSON value; example: "iterator does not fit current value"
Throws invalid_iterator.210 if first and last do not belong to the same JSON value; example: "iterators do not fit"
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON array
+jsonv={1,2,3,4};
+
+// insert number 10 before number 3
+autonew_pos=v.insert(v.begin()+2,10);
+
+// output new array and result of insert call
+std::cout<<*new_pos<<'\n';
+std::cout<<v<<'\n';
+}
+
Output:
10
+[1,2,10,3,4]
+
Example (2): insert copies of element into array
The example shows how insert() is used.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON array
+jsonv={1,2,3,4};
+
+// insert number 7 copies of number 7 before number 3
+autonew_pos=v.insert(v.begin()+2,7,7);
+
+// output new array and result of insert call
+std::cout<<*new_pos<<'\n';
+std::cout<<v<<'\n';
+}
+
Output:
7
+[1,2,7,7,7,7,7,7,7,3,4]
+
Example (3): insert range of elements into array
The example shows how insert() is used.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON array
+jsonv={1,2,3,4};
+
+// create a JSON array to copy values from
+jsonv2={"one","two","three","four"};
+
+// insert range from v2 before the end of array v
+autonew_pos=v.insert(v.end(),v2.begin(),v2.end());
+
+// output new array and result of insert call
+std::cout<<*new_pos<<'\n';
+std::cout<<v<<'\n';
+}
+
Output:
"one"
+[1,2,3,4,"one","two","three","four"]
+
Example (4): insert elements from initializer list into array
The example shows how insert() is used.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON array
+jsonv={1,2,3,4};
+
+// insert range from v2 before the end of array v
+autonew_pos=v.insert(v.end(),{7,8,9});
+
+// output new array and result of insert call
+std::cout<<*new_pos<<'\n';
+std::cout<<v<<'\n';
+}
+
Output:
7
+[1,2,3,4,7,8,9]
+
Example (5): insert range of elements into object
The example shows how insert() is used.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create two JSON objects
+jsonj1={{"one","eins"},{"two","zwei"}};
+jsonj2={{"eleven","elf"},{"seventeen","siebzehn"}};
+
+// output objects
+std::cout<<j1<<'\n';
+std::cout<<j2<<'\n';
+
+// insert range from j2 to j1
+j1.insert(j2.begin(),j2.end());
+
+// output result of insert call
+std::cout<<j1<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/invalid_iterator/index.html b/api/basic_json/invalid_iterator/index.html
new file mode 100644
index 000000000..2e6d0e409
--- /dev/null
+++ b/api/basic_json/invalid_iterator/index.html
@@ -0,0 +1,25 @@
+ invalid_iterator - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_array/index.html b/api/basic_json/is_array/index.html
new file mode 100644
index 000000000..c4e2f11ea
--- /dev/null
+++ b/api/basic_json/is_array/index.html
@@ -0,0 +1,41 @@
+ is_array - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_binary/index.html b/api/basic_json/is_binary/index.html
new file mode 100644
index 000000000..a0d481cb3
--- /dev/null
+++ b/api/basic_json/is_binary/index.html
@@ -0,0 +1,41 @@
+ is_binary - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_boolean/index.html b/api/basic_json/is_boolean/index.html
new file mode 100644
index 000000000..a18832fe4
--- /dev/null
+++ b/api/basic_json/is_boolean/index.html
@@ -0,0 +1,41 @@
+ is_boolean - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_discarded/index.html b/api/basic_json/is_discarded/index.html
new file mode 100644
index 000000000..bc73e7bb6
--- /dev/null
+++ b/api/basic_json/is_discarded/index.html
@@ -0,0 +1,43 @@
+ is_discarded - JSON for Modern C++
Discarded values are never compared equal with operator==. That is, checking whether a JSON value j is discarded will only work via:
j.is_discarded()
+
because
j==json::value_t::discarded
+
will always be false.
Removal during parsing with callback functions
When a value is discarded by a callback function (see parser_callback_t) during parsing, then it is removed when it is part of a structured value. For instance, if the second value of an array is discarded, instead of [null,discarded,false], the array [null,false] is returned. Only if the top-level value is discarded, the return value of the parse call is discarded.
This function will always be false for JSON values after parsing. That is, discarded values can only occur during parsing, but will be removed when inside a structured value or replaced by null in other cases.
\ No newline at end of file
diff --git a/api/basic_json/is_null/index.html b/api/basic_json/is_null/index.html
new file mode 100644
index 000000000..1a10dba24
--- /dev/null
+++ b/api/basic_json/is_null/index.html
@@ -0,0 +1,41 @@
+ is_null - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_number/index.html b/api/basic_json/is_number/index.html
new file mode 100644
index 000000000..372cce19f
--- /dev/null
+++ b/api/basic_json/is_number/index.html
@@ -0,0 +1,45 @@
+ is_number - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_number_float/index.html b/api/basic_json/is_number_float/index.html
new file mode 100644
index 000000000..4d6addad1
--- /dev/null
+++ b/api/basic_json/is_number_float/index.html
@@ -0,0 +1,41 @@
+ is_number_float - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_number_integer/index.html b/api/basic_json/is_number_integer/index.html
new file mode 100644
index 000000000..3416b079c
--- /dev/null
+++ b/api/basic_json/is_number_integer/index.html
@@ -0,0 +1,41 @@
+ is_number_integer - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_number_unsigned/index.html b/api/basic_json/is_number_unsigned/index.html
new file mode 100644
index 000000000..48efd697d
--- /dev/null
+++ b/api/basic_json/is_number_unsigned/index.html
@@ -0,0 +1,41 @@
+ is_number_unsigned - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_object/index.html b/api/basic_json/is_object/index.html
new file mode 100644
index 000000000..eca2a1612
--- /dev/null
+++ b/api/basic_json/is_object/index.html
@@ -0,0 +1,41 @@
+ is_object - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_primitive/index.html b/api/basic_json/is_primitive/index.html
new file mode 100644
index 000000000..a47e60e1b
--- /dev/null
+++ b/api/basic_json/is_primitive/index.html
@@ -0,0 +1,45 @@
+ is_primitive - JSON for Modern C++
JSON can represent four primitive types (strings, numbers, booleans, and null) and two structured types (objects and arrays).
This library extends primitive types to binary types, because binary types are roughly comparable to strings. Hence, is_primitive() returns true for binary values.
\ No newline at end of file
diff --git a/api/basic_json/is_string/index.html b/api/basic_json/is_string/index.html
new file mode 100644
index 000000000..4861342c4
--- /dev/null
+++ b/api/basic_json/is_string/index.html
@@ -0,0 +1,41 @@
+ is_string - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/is_structured/index.html b/api/basic_json/is_structured/index.html
new file mode 100644
index 000000000..b6034d559
--- /dev/null
+++ b/api/basic_json/is_structured/index.html
@@ -0,0 +1,45 @@
+ is_structured - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/items/index.html b/api/basic_json/items/index.html
new file mode 100644
index 000000000..9c39221c6
--- /dev/null
+++ b/api/basic_json/items/index.html
@@ -0,0 +1,50 @@
+ items - JSON for Modern C++
This function allows accessing iterator::key() and iterator::value() during range-based for loops. In these loops, a reference to the JSON values is returned, so there is no access to the underlying iterator.
When iterating over an array, key() will return the index of the element as string (see example). For primitive types (e.g., numbers), key() returns an empty string.
Added items and deprecated iterator_wrapper in version 3.1.0.
Added structured binding support in version 3.5.0.
Deprecation
This function replaces the static function iterator_wrapper which was introduced in version 1.0.0, but has been deprecated in version 3.1.0. Function iterator_wrapper will be removed in version 4.0.0. Please replace all occurrences of iterator_wrapper(j) with j.items().
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/json_base_class_t/index.html b/api/basic_json/json_base_class_t/index.html
new file mode 100644
index 000000000..3eb012332
--- /dev/null
+++ b/api/basic_json/json_base_class_t/index.html
@@ -0,0 +1,94 @@
+ json_base_class_t - JSON for Modern C++
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), or other application-specific code.
The type CustomBaseClass has to be a default-constructible class. basic_json only supports copy/move construction/assignment if CustomBaseClass does so as well.
\ No newline at end of file
diff --git a/api/basic_json/json_serializer/index.html b/api/basic_json/json_serializer/index.html
new file mode 100644
index 000000000..4ff083e66
--- /dev/null
+++ b/api/basic_json/json_serializer/index.html
@@ -0,0 +1,57 @@
+ json_serializer - JSON for Modern C++
The example below shows how a conversion of a non-default-constructible type is implemented via a specialization of the adl_serializer.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+namespacens
+{
+// a simple struct to model a person (not default constructible)
+structperson
+{
+person(std::stringn,std::stringa,intaa)
+:name(std::move(n)),address(std::move(a)),age(aa)
+{}
+
+std::stringname;
+std::stringaddress;
+intage;
+};
+}// namespace ns
+
+namespacenlohmann
+{
+template<>
+structadl_serializer<ns::person>
+{
+staticns::personfrom_json(constjson&j)
+{
+return{j.at("name"),j.at("address"),j.at("age")};
+}
+
+// Here's the catch! You must provide a to_json method! Otherwise, you
+// will not be able to convert person to json, since you fully
+// specialized adl_serializer on that type
+staticvoidto_json(json&j,ns::personp)
+{
+j["name"]=p.name;
+j["address"]=p.address;
+j["age"]=p.age;
+}
+};
+}// namespace nlohmann
+
+intmain()
+{
+jsonj;
+j["name"]="Ned Flanders";
+j["address"]="744 Evergreen Terrace";
+j["age"]=60;
+
+autop=j.get<ns::person>();
+
+std::cout<<p.name<<" ("<<p.age<<") lives in "<<p.address<<std::endl;
+}
+
\ No newline at end of file
diff --git a/api/basic_json/max_size/index.html b/api/basic_json/max_size/index.html
new file mode 100644
index 000000000..c4ce33927
--- /dev/null
+++ b/api/basic_json/max_size/index.html
@@ -0,0 +1,34 @@
+ max_size - JSON for Modern C++
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.
This function does not return the maximal length of a string stored as JSON value -- it returns the maximal number of string elements the JSON value can store which is 1.
\ No newline at end of file
diff --git a/api/basic_json/merge_patch/index.html b/api/basic_json/merge_patch/index.html
new file mode 100644
index 000000000..6b65ecee6
--- /dev/null
+++ b/api/basic_json/merge_patch/index.html
@@ -0,0 +1,67 @@
+ merge_patch - JSON for Modern C++
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 current JSON value.
\ No newline at end of file
diff --git a/api/basic_json/meta/index.html b/api/basic_json/meta/index.html
new file mode 100644
index 000000000..4ed2ad67d
--- /dev/null
+++ b/api/basic_json/meta/index.html
@@ -0,0 +1,30 @@
+ meta - JSON for Modern C++
Information on the used compiler. It is an object with the following keys: c++ (the used C++ standard), family (the compiler family; possible values are clang, icc, gcc, ilecpp, msvc, pgcpp, sunpro, and unknown), and version (the compiler version).
copyright
The copyright line for the library as string.
name
The name of the library as string.
platform
The used platform as string. Possible values are win32, linux, apple, unix, and unknown.
url
The URL of the project as string.
version
The version of the library. It is an object with the following keys: major, minor, and patch as defined by Semantic Versioning, and string (the version string).
\ No newline at end of file
diff --git a/api/basic_json/number_float_t/index.html b/api/basic_json/number_float_t/index.html
new file mode 100644
index 000000000..6e82c4126
--- /dev/null
+++ b/api/basic_json/number_float_t/index.html
@@ -0,0 +1,13 @@
+ number_float_t - JSON for Modern C++
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.
To store floating-point numbers in C++, a type is defined by the template parameter NumberFloatType which chooses the type to use.
The restrictions about leading zeros is not enforced in C++. Instead, leading zeros in floating-point literals will be ignored. Internally, the value will be stored as decimal number. For instance, the C++ floating-point literal 01.2 will be serialized to 1.2. During deserialization, leading zeros yield an error.
Not-a-number (NaN) values will be serialized to null.
This specification allows implementations to set limits on the range and precision of numbers accepted. Since software that implements IEEE 754-2008 binary64 (double precision) numbers is generally available and widely used, good interoperability can be achieved by implementations that expect no more precision or range than these provide, in the sense that implementations will approximate JSON numbers within the expected precision.
This implementation does exactly follow this approach, as it uses double precision floating-point numbers. Note values smaller than -1.79769313486232e+308 and values greater than 1.79769313486232e+308 will be stored as NaN internally and be serialized to null.
\ No newline at end of file
diff --git a/api/basic_json/number_integer_t/index.html b/api/basic_json/number_integer_t/index.html
new file mode 100644
index 000000000..cbe012c3b
--- /dev/null
+++ b/api/basic_json/number_integer_t/index.html
@@ -0,0 +1,13 @@
+ number_integer_t - JSON for Modern C++
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.
To store integer numbers in C++, a type is defined by the template parameter NumberIntegerType which chooses the type to use.
The restrictions about leading zeros is not enforced in C++. Instead, leading zeros in integer literals lead to an interpretation as octal number. Internally, the value will be stored as decimal number. For instance, the C++ integer literal 010 will be serialized to 8. During deserialization, leading zeros yield an error.
Not-a-number (NaN) values will be serialized to null.
An implementation may set limits on the range and precision of numbers.
When the default type is used, the maximal integer number that can be stored is 9223372036854775807 (INT64_MAX) and the minimal integer number that can be stored is -9223372036854775808 (INT64_MIN). Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will be automatically be stored as number_unsigned_t or number_float_t.
Note that when such software is used, numbers that are integers and are in the range [-2^{53}+1, 2^{53}-1] are interoperable in the sense that implementations will agree exactly on their numeric values.
As this range is a subrange of the exactly supported range [INT64_MIN, INT64_MAX], this class's integer type is interoperable.
\ No newline at end of file
diff --git a/api/basic_json/number_unsigned_t/index.html b/api/basic_json/number_unsigned_t/index.html
new file mode 100644
index 000000000..2b550aaa6
--- /dev/null
+++ b/api/basic_json/number_unsigned_t/index.html
@@ -0,0 +1,13 @@
+ number_unsigned_t - JSON for Modern C++
The representation of numbers is similar to that used in most programming languages. A number is represented in base 10 using decimal digits. It contains an integer component that may be prefixed with an optional minus sign, which may be followed by a fraction part and/or an exponent part. Leading zeros are not allowed. (...) Numeric values that cannot be represented in the grammar below (such as Infinity and NaN) are not permitted.
This description includes both integer and floating-point numbers. However, C++ allows more precise storage if it is known whether the number is a signed integer, an unsigned integer or a floating-point number. Therefore, three different types, number_integer_t, number_unsigned_t and number_float_t are used.
To store unsigned integer numbers in C++, a type is defined by the template parameter NumberUnsignedType which chooses the type to use.
The restrictions about leading zeros is not enforced in C++. Instead, leading zeros in integer literals lead to an interpretation as octal number. Internally, the value will be stored as decimal number. For instance, the C++ integer literal 010 will be serialized to 8. During deserialization, leading zeros yield an error.
Not-a-number (NaN) values will be serialized to null.
An implementation may set limits on the range and precision of numbers.
When the default type is used, the maximal integer number that can be stored is 18446744073709551615 (UINT64_MAX) and the minimal integer number that can be stored is 0. Integer numbers that are out of range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers will be automatically be stored as number_integer_t or number_float_t.
Note that when such software is used, numbers that are integers and are in the range \f[-2^{53}+1, 2^{53}-1]\f are interoperable in the sense that implementations will agree exactly on their numeric values.
As this range is a subrange (when considered in conjunction with the number_integer_t type) of the exactly supported range [0, UINT64_MAX], this class's integer type is interoperable.
\ No newline at end of file
diff --git a/api/basic_json/object/index.html b/api/basic_json/object/index.html
new file mode 100644
index 000000000..ecbd1537d
--- /dev/null
+++ b/api/basic_json/object/index.html
@@ -0,0 +1,34 @@
+ object - JSON for Modern C++
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 {} is created.
Throws type_error.301 if init is not a list of pairs whose first elements are strings. In this case, no object can be created. When such a value is passed to basic_json(initializer_list_t, bool, value_t), an array would have been created from the passed initializer list init. See example below.
This function is only added for symmetry reasons. In contrast to the related function array(initializer_list_t), there are no cases which can only be expressed by this function. That is, any initializer list init can also be passed to the initializer list constructor basic_json(initializer_list_t, bool, value_t).
The following code shows an example for the object function.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create JSON objects
+jsonj_no_init_list=json::object();
+jsonj_empty_init_list=json::object({});
+jsonj_list_of_pairs=json::object({{"one",1},{"two",2}});
+
+// serialize the JSON objects
+std::cout<<j_no_init_list<<'\n';
+std::cout<<j_empty_init_list<<'\n';
+std::cout<<j_list_of_pairs<<'\n';
+
+// example for an exception
+try
+{
+// can only create an object from a list of pairs
+jsonj_invalid_object=json::object({{"one",1,2}});
+}
+catch(json::type_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+}
+
\ No newline at end of file
diff --git a/api/basic_json/object_comparator_t/index.html b/api/basic_json/object_comparator_t/index.html
new file mode 100644
index 000000000..04f78aea6
--- /dev/null
+++ b/api/basic_json/object_comparator_t/index.html
@@ -0,0 +1,17 @@
+ object_comparator_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/object_t/index.html b/api/basic_json/object_t/index.html
new file mode 100644
index 000000000..67e3b664b
--- /dev/null
+++ b/api/basic_json/object_t/index.html
@@ -0,0 +1,31 @@
+ object_t - JSON for Modern C++
An object is an unordered collection of zero or more name/value pairs, where a name is a string and a value is a string, number, boolean, null, object, or array.
To store objects in C++, a type is defined by the template parameters described below.
The choice of object_t influences the behavior of the JSON class. With the default type, objects have the following behavior:
When all names are unique, objects will be interoperable in the sense that all software implementations receiving that object will agree on the name-value mappings.
When the names within an object are not unique, it is unspecified which one of the values for a given key will be chosen. For instance, {"key":2,"key":1} could be equal to either {"key":1} or {"key":2}.
Internally, name/value pairs are stored in lexicographical order of the names. Objects will also be serialized (see dump) in this order. For instance, {"b":1,"a":2} and {"a":2,"b":1} will be stored and serialized as {"a":2,"b":1}.
When comparing objects, the order of the name/value pairs is irrelevant. This makes objects interoperable in the sense that they will not be affected by these differences. For instance, {"b":1,"a":2} and {"a":2,"b":1} will be treated as equal.
An implementation may set limits on the maximum depth of nesting.
In this class, the object's limit of nesting is not explicitly constrained. However, a maximum depth of nesting may be introduced by the compiler or runtime environment. A theoretical limit can be queried by calling the max_size function of a JSON object.
The order name/value pairs are added to the object is not preserved by the library. Therefore, iterating an object may return name/value pairs in a different order than they were originally stored. In fact, keys will be traversed in alphabetical order as std::map with std::less is used by default. Please note this behavior conforms to RFC 8259, because any order implements the specified "unordered" nature of JSON objects.
\ No newline at end of file
diff --git a/api/basic_json/operator+=/index.html b/api/basic_json/operator+=/index.html
new file mode 100644
index 000000000..4ac143316
--- /dev/null
+++ b/api/basic_json/operator+=/index.html
@@ -0,0 +1,99 @@
+ operator+= - JSON for Modern C++
Appends the given element val to the end of the JSON array. If the function is called on a JSON null value, an empty array is created before appending val.
Inserts the given element val to the JSON object. If the function is called on a JSON null value, an empty object is created before inserting val.
This function allows using operator+= with an initializer list. In case
the current value is an object,
the initializer list init contains only two elements, and
the first element of init is a string,
init is converted into an object element and added using operator+=(const typename object_t::value_type&). Otherwise, init is converted to a JSON value and added using operator+=(basic_json&&).
All functions can throw the following exception: - Throws type_error.308 when called on a type other than JSON array or null; example: "cannot use operator+=() with number"
(3) This function is required to resolve an ambiguous overload error, because pairs like {"key", "value"} can be both interpreted as object_t::value_type or std::initializer_list<basic_json>, see #235 for more information.
The example shows how push_back() and += can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object.
\ No newline at end of file
diff --git a/api/basic_json/operator=/index.html b/api/basic_json/operator=/index.html
new file mode 100644
index 000000000..34c476fa7
--- /dev/null
+++ b/api/basic_json/operator=/index.html
@@ -0,0 +1,27 @@
+ operator= - JSON for Modern C++
Copy assignment operator. Copies a JSON value via the "copy and swap" strategy: It is expressed in terms of the copy constructor, destructor, and the swap() member function.
The code below shows and example for the copy assignment. It creates a copy of value a which is then swapped with b. Finally, the copy of a (which is the null value after the swap) is destroyed.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create JSON values
+jsona=23;
+jsonb=42;
+
+// copy-assign a to b
+b=a;
+
+// serialize the JSON arrays
+std::cout<<a<<'\n';
+std::cout<<b<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/operator[]/index.html b/api/basic_json/operator[]/index.html
new file mode 100644
index 000000000..191c55977
--- /dev/null
+++ b/api/basic_json/operator[]/index.html
@@ -0,0 +1,286 @@
+ operator[] - JSON for Modern C++
Returns a reference to the array element at specified location idx.
Returns a reference to the object element with specified key key. The non-const qualified overload takes the key by value.
See 2. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
Returns a reference to the element with specified JSON pointer ptr.
If the element with key idx does not exist, the behavior is undefined.
If the element with key key does not exist, the behavior is undefined and is guarded by a runtime assertion!
The non-const version may add values: If idx is beyond the range of the array (i.e., idx >= size()), then the array is silently filled up with null values to make idx a valid reference to the last stored element. In case the value was null before, it is converted to an array.
If key is not found in the object, then it is silently added to the object and filled with a null value to make key a valid reference. In case the value was null before, it is converted to an object.
See 2.
null values are created in arrays and objects if necessary.
In particular:
If the JSON pointer points to an object key that does not exist, it is created and filled with a null value before a reference to it is returned.
If the JSON pointer points to an array index that does not exist, it is created and filled with a null value before a reference to it is returned. All indices between the current maximum and the given index are also filled with null.
The special value - is treated as a synonym for the index past the end.
Example: (3) access specified object element using string_view (const)
The example below shows how object elements can be read using the [] operator.
#include<iostream>
+#include<string_view>
+#include<nlohmann/json.hpp>
+
+usingnamespacestd::string_view_literals;
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON object
+constjsonobject=
+{
+{"one",1},{"two",2},{"three",2.9}
+};
+
+// output element with key "two"
+std::cout<<object["two"sv]<<'\n';
+}
+
Output:
2
+
Example: (4) access specified element via JSON Pointer
The example below shows how values can be read and written using JSON Pointers.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+usingnamespacenlohmann::literals;
+
+intmain()
+{
+// create a JSON value
+jsonj=
+{
+{"number",1},{"string","foo"},{"array",{1,2}}
+};
+
+// read-only access
+
+// output element with JSON pointer "/number"
+std::cout<<j["/number"_json_pointer]<<'\n';
+// output element with JSON pointer "/string"
+std::cout<<j["/string"_json_pointer]<<'\n';
+// output element with JSON pointer "/array"
+std::cout<<j["/array"_json_pointer]<<'\n';
+// output element with JSON pointer "/array/1"
+std::cout<<j["/array/1"_json_pointer]<<'\n';
+
+// writing access
+
+// change the string
+j["/string"_json_pointer]="bar";
+// output the changed string
+std::cout<<j["string"]<<'\n';
+
+// "change" a nonexisting object entry
+j["/boolean"_json_pointer]=true;
+// output the changed object
+std::cout<<j<<'\n';
+
+// change an array element
+j["/array/1"_json_pointer]=21;
+// "change" an array element with nonexisting index
+j["/array/4"_json_pointer]=44;
+// output the changed array
+std::cout<<j["array"]<<'\n';
+
+// "change" the array element past the end
+j["/array/-"_json_pointer]=55;
+// output the changed array
+std::cout<<j["array"]<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/operator_ValueType/index.html b/api/basic_json/operator_ValueType/index.html
new file mode 100644
index 000000000..4397577a9
--- /dev/null
+++ b/api/basic_json/operator_ValueType/index.html
@@ -0,0 +1,79 @@
+ operator ValueType - JSON for Modern C++
Implicit type conversion between the JSON value and a compatible value. The call is realized by calling get(). See Notes for the meaning of JSON_EXPLICIT.
Implicit conversions will be switched off by default in the next major release of the library. That is, JSON_EXPLICIT will be set to explicit by default.
You can prepare existing code by already defining JSON_USE_IMPLICIT_CONVERSIONS to 0 and replace any implicit conversions with calls to get.
The example below shows several conversions from JSON values to other types. There are a few things to note: (1) Floating-point numbers can be converted to integers, (2) A JSON array can be converted to a standard std::vector<short>, (3) A JSON object can be converted to C++ associative containers such as std::unordered_map<std::string, json>.
#include<iostream>
+#include<unordered_map>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create a JSON value with different types
+jsonjson_types=
+{
+{"boolean",true},
+{
+"number",{
+{"integer",42},
+{"floating-point",17.23}
+}
+},
+{"string","Hello, world!"},
+{"array",{1,2,3,4,5}},
+{"null",nullptr}
+};
+
+// use implicit conversions
+boolv1=json_types["boolean"];
+intv2=json_types["number"]["integer"];
+shortv3=json_types["number"]["integer"];
+floatv4=json_types["number"]["floating-point"];
+intv5=json_types["number"]["floating-point"];
+std::stringv6=json_types["string"];
+std::vector<short>v7=json_types["array"];
+std::unordered_map<std::string,json>v8=json_types;
+
+// print the conversion results
+std::cout<<v1<<'\n';
+std::cout<<v2<<' '<<v3<<'\n';
+std::cout<<v4<<' '<<v5<<'\n';
+std::cout<<v6<<'\n';
+
+for(autoi:v7)
+{
+std::cout<<i<<' ';
+}
+std::cout<<"\n\n";
+
+for(autoi:v8)
+{
+std::cout<<i.first<<": "<<i.second<<'\n';
+}
+
+// example for an exception
+try
+{
+boolv1=json_types["string"];
+}
+catch(json::type_error&e)
+{
+std::cout<<e.what()<<'\n';
+}
+}
+
\ No newline at end of file
diff --git a/api/basic_json/operator_eq/index.html b/api/basic_json/operator_eq/index.html
new file mode 100644
index 000000000..e1663f863
--- /dev/null
+++ b/api/basic_json/operator_eq/index.html
@@ -0,0 +1,118 @@
+ operator== - JSON for Modern C++
Compares two JSON values for equality according to the following rules:
Two JSON values are equal if (1) neither value is discarded, or (2) they are of the same type and their stored values are the same according to their respective operator==.
Integer and floating-point numbers are automatically converted before comparison.
Compares a JSON value and a scalar or a scalar and a JSON value for equality by converting the scalar to a JSON value and comparing both JSON values according to 1.
NaN values are unordered within the domain of numbers. The following comparisons all yield false:
Comparing a NaN with itself.
Comparing a NaN with another NaN.
Comparing a NaN and any other number.
JSON null values are all equal.
Discarded values never compare equal to themselves.
Comparing floating-point numbers
Floating-point numbers inside JSON values numbers are compared with json::number_float_t::operator== which is double::operator== by default. To compare floating-point while respecting an epsilon, an alternative comparison function could be used, for instance
Or you can self-defined operator equal function like this:
boolmy_equal(const_referencelhs,const_referencerhs)
+{
+constautolhs_typelhs.type();
+constautorhs_typerhs.type();
+if(lhs_type==rhs_type)
+{
+switch(lhs_type)
+// self_defined case
+casevalue_t::number_float:
+returnstd::abs(lhs-rhs)<=std::numeric_limits<float>::epsilon();
+// other cases remain the same with the original
+...
+}
+...
+}
+
Comparing different basic_json specializations
Comparing different basic_json specializations can have surprising effects. For instance, the result of comparing the JSON objects
\ No newline at end of file
diff --git a/api/basic_json/operator_ge/index.html b/api/basic_json/operator_ge/index.html
new file mode 100644
index 000000000..59e51c486
--- /dev/null
+++ b/api/basic_json/operator_ge/index.html
@@ -0,0 +1,37 @@
+ operator>= - JSON for Modern C++
Compares whether one JSON value lhs is greater than or equal to another JSON value rhs according to the following rules:
The comparison always yields false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.
Otherwise, returns the result of !(lhs<rhs) (see operator<).
Compares whether a JSON value is greater than or equal to a scalar or a scalar is greater than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
\ No newline at end of file
diff --git a/api/basic_json/operator_gt/index.html b/api/basic_json/operator_gt/index.html
new file mode 100644
index 000000000..f04882edf
--- /dev/null
+++ b/api/basic_json/operator_gt/index.html
@@ -0,0 +1,37 @@
+ operator> - JSON for Modern C++
Compares whether one JSON value lhs is greater than another JSON value rhs according to the following rules:
The comparison always yields false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.
Otherwise, returns the result of !(lhs<=rhs) (see operator<=).
Compares wether a JSON value is greater than a scalar or a scalar is greater than a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
Compares whether one JSON value lhs is less than or equal to another JSON value rhs according to the following rules:
The comparison always yields false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.
Otherwise, returns the result of !(rhs<lhs) (see operator<).
Compares wether a JSON value is less than or equal to a scalar or a scalar is less than or equal to a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
Compares whether one JSON value lhs is less than another JSON value rhs according to the following rules:
If either operand is discarded, the comparison yields false.
If both operands have the same type, the values are compared using their respective operator<.
Integer and floating-point numbers are automatically converted before comparison.
In case lhs and rhs have different types, the values are ignored and the order of the types is considered, which is:
null
boolean
number (all types)
object
array
string
binary For instance, any boolean value is considered less than any string.
Compares wether a JSON value is less than a scalar or a scalar is less than a JSON value by converting the scalar to a JSON value and comparing both JSON values according to 1.
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
Operator overload resolution
Since C++20 overload resolution will consider the rewritten candidate generated from operator<=>.
Compares two JSON values for inequality according to the following rules:
The comparison always yields false if (1) either operand is discarded, or (2) either operand is NaN and the other operand is either NaN or any other number.
Otherwise, returns the result of !(lhs==rhs) (until C++20) or !(*this==rhs) (since C++20).
Compares a JSON value and a scalar or a scalar and a JSON value for inequality by converting the scalar to a JSON value and comparing both JSON values according to 1.
NaN values are unordered within the domain of numbers. The following comparisons all yield false: 1. Comparing a NaN with itself. 2. Comparing a NaN with another NaN. 3. Comparing a NaN and any other number.
\ No newline at end of file
diff --git a/api/basic_json/operator_spaceship/index.html b/api/basic_json/operator_spaceship/index.html
new file mode 100644
index 000000000..cb2188128
--- /dev/null
+++ b/api/basic_json/operator_spaceship/index.html
@@ -0,0 +1,98 @@
+ operator - JSON for Modern C++
3-way compares two JSON values producing a result of type std::partial_ordering according to the following rules:
Two JSON values compare with a result of std::partial_ordering::unordered if either value is discarded.
If both JSON values are of the same type, the result is produced by 3-way comparing their stored values using their respective operator<=>.
Integer and floating-point numbers are converted to their common type and then 3-way compared using their respective operator<=>. For instance, comparing an integer and a floating-point value will 3-way compare the first value converted to floating-point with the second value.
Otherwise, yields a result by comparing the type (see value_t).
3-way compares a JSON value and a scalar or a scalar and a JSON value by converting the scalar to a JSON value and 3-way comparing both JSON values (see 1).
\ No newline at end of file
diff --git a/api/basic_json/operator_value_t/index.html b/api/basic_json/operator_value_t/index.html
new file mode 100644
index 000000000..33635648a
--- /dev/null
+++ b/api/basic_json/operator_value_t/index.html
@@ -0,0 +1,48 @@
+ operator value_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/other_error/index.html b/api/basic_json/other_error/index.html
new file mode 100644
index 000000000..2b2cbd68f
--- /dev/null
+++ b/api/basic_json/other_error/index.html
@@ -0,0 +1,34 @@
+ other_error - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/out_of_range/index.html b/api/basic_json/out_of_range/index.html
new file mode 100644
index 000000000..6cbba03b9
--- /dev/null
+++ b/api/basic_json/out_of_range/index.html
@@ -0,0 +1,24 @@
+ out_of_range - JSON for Modern C++
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.
\ No newline at end of file
diff --git a/api/basic_json/parse/index.html b/api/basic_json/parse/index.html
new file mode 100644
index 000000000..8242ec25c
--- /dev/null
+++ b/api/basic_json/parse/index.html
@@ -0,0 +1,336 @@
+ parse - JSON for Modern C++
The value_type of the iterator must be an integral type with size of 1, 2 or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
Deserialized JSON value; in case of a parse error and allow_exceptions set to false, the return value will be value_t::discarded. The latter can be checked with is_discarded.
Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the parser callback function cb or reading from (1) the input i or (2) the iterator range [first, last] has a super-linear complexity.
The example below demonstrates the parse() function reading from a contiguous container.
#include<iostream>
+#include<iomanip>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// a JSON text given as std::vector
+std::vector<std::uint8_t>text={'[','1',',','2',',','3',']','\0'};
+
+// parse and serialize JSON
+jsonj_complete=json::parse(text);
+std::cout<<std::setw(4)<<j_complete<<"\n\n";
+}
+
Output:
[
+1,
+2,
+3
+]
+
Parsing from a non null-terminated string
The example below demonstrates the parse() function reading from a string that is not null-terminated.
#include<iostream>
+#include<iomanip>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// a JSON text given as string that is not null-terminated
+constchar*ptr="[1,2,3]another value";
+
+// parse and serialize JSON
+jsonj_complete=json::parse(ptr,ptr+7);
+std::cout<<std::setw(4)<<j_complete<<"\n\n";
+}
+
Output:
[
+1,
+2,
+3
+]
+
Parsing from an iterator pair
The example below demonstrates the parse() function reading from an iterator pair.
#include<iostream>
+#include<iomanip>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// a JSON text given an input with other values
+std::vector<std::uint8_t>input={'[','1',',','2',',','3',']','o','t','h','e','r'};
+
+// parse and serialize JSON
+jsonj_complete=json::parse(input.begin(),input.begin()+7);
+std::cout<<std::setw(4)<<j_complete<<"\n\n";
+}
+
Output:
[
+1,
+2,
+3
+]
+
Effect of allow_exceptions parameter
The example below demonstrates the effect of the allow_exceptions parameter in the ´parse()` function.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// an invalid JSON text
+std::stringtext=R"(
+ {
+ "key": "value without closing quotes
+ }
+)";
+
+// parse with exceptions
+try
+{
+jsonj=json::parse(text);
+}
+catch(json::parse_error&e)
+{
+std::cout<<e.what()<<std::endl;
+}
+
+// parse without exceptions
+jsonj=json::parse(text,nullptr,false);
+
+if(j.is_discarded())
+{
+std::cout<<"the input is invalid JSON"<<std::endl;
+}
+else
+{
+std::cout<<"the input is valid JSON: "<<j<<std::endl;
+}
+}
+
Output:
[json.exception.parse_error.101]parseerroratline4,column0:syntaxerrorwhileparsingvalue-invalidstring:controlcharacterU+000A(LF)mustbeescapedto\u000Aor\n;lastread:'"value without closing quotes<U+000A>'
+the input is invalid JSON
+
Overload for contiguous containers (1) added in version 2.0.3.
Ignoring comments via ignore_comments added in version 3.9.0.
Deprecation
Overload (2) replaces calls to parse with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like parse({ptr,ptr+len},...); with parse(ptr,ptr+len,...);.
You should be warned by your compiler with a -Wdeprecated-declarations warning if you are using a deprecated function.
\ No newline at end of file
diff --git a/api/basic_json/parse_error/index.html b/api/basic_json/parse_error/index.html
new file mode 100644
index 000000000..45a4ee9b2
--- /dev/null
+++ b/api/basic_json/parse_error/index.html
@@ -0,0 +1,25 @@
+ parse_error - JSON for Modern C++
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 the byte index of the last read character in the input file (see note below).
For an input with n bytes, 1 is the index of the first character and n+1 is the index of the terminating null byte or the end of file. This also holds true when reading a byte vector for binary formats.
\ No newline at end of file
diff --git a/api/basic_json/parse_event_t/index.html b/api/basic_json/parse_event_t/index.html
new file mode 100644
index 000000000..e052dd42b
--- /dev/null
+++ b/api/basic_json/parse_event_t/index.html
@@ -0,0 +1,9 @@
+ parse_event_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/parser_callback_t/index.html b/api/basic_json/parser_callback_t/index.html
new file mode 100644
index 000000000..2a8539aa7
--- /dev/null
+++ b/api/basic_json/parser_callback_t/index.html
@@ -0,0 +1,87 @@
+ parser_callback_t - JSON for Modern C++
With a parser callback function, the result of parsing a JSON text can be influenced. When passed to parse, it is called on certain events (passed as parse_event_t via parameter event) with a set recursion depth depth and context JSON value parsed. The return value of the callback function is a boolean indicating whether the element that emitted the callback shall be kept or not.
We distinguish six scenarios (determined by the event type) in which the callback function can be called. The following table describes the values of the parameters depth, event, and parsed.
parameter event
description
parameter depth
parameter parsed
parse_event_t::object_start
the parser read { and started to process a JSON object
depth of the parent of the JSON object
a JSON value with type discarded
parse_event_t::key
the parser read a key of a value in an object
depth of the currently parsed JSON object
a JSON string containing the key
parse_event_t::object_end
the parser read } and finished processing a JSON object
depth of the parent of the JSON object
the parsed JSON object
parse_event_t::array_start
the parser read [ and started to process a JSON array
depth of the parent of the JSON array
a JSON value with type discarded
parse_event_t::array_end
the parser read ] and finished processing a JSON array
depth of the parent of the JSON array
the parsed JSON array
parse_event_t::value
the parser finished reading a JSON value
depth of the value
the parsed JSON value
Discarding a value (i.e., returning false) has different effects depending on the context in which function was called:
Discarded values in structured types are skipped. That is, the parser will behave as if the discarded value was never read.
In case a value outside a structured type is skipped, it is replaced with null. This case happens if the top-level element is skipped.
Whether the JSON value which called the function during parsing should be kept (true) or not (false). In the latter case, it is either skipped completely or replaced by an empty discarded object.
\ No newline at end of file
diff --git a/api/basic_json/patch/index.html b/api/basic_json/patch/index.html
new file mode 100644
index 000000000..53bcb030f
--- /dev/null
+++ b/api/basic_json/patch/index.html
@@ -0,0 +1,46 @@
+ patch - JSON for Modern C++
JSON Patch 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 by executing all operations from the patch.
Linear in the size of the JSON value and the length of the JSON patch. As usually only a fraction of the JSON value is affected by the patch, the complexity can usually be neglected.
The application of a patch is atomic: Either all operations succeed and the patched document is returned or an exception is thrown. In any case, the original value is not changed: the patch is applied to a copy of the value.
\ No newline at end of file
diff --git a/api/basic_json/patch_inplace/index.html b/api/basic_json/patch_inplace/index.html
new file mode 100644
index 000000000..dfdcaf88a
--- /dev/null
+++ b/api/basic_json/patch_inplace/index.html
@@ -0,0 +1,50 @@
+ patch_inplace - JSON for Modern C++
JSON Patch 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 by executing all operations from the patch. This function applies a JSON patch in place and returns void.
Linear in the size of the JSON value and the length of the JSON patch. As usually only a fraction of the JSON value is affected by the patch, the complexity can usually be neglected.
Unlike patch, patch_inplace applies the operation "in place" and no copy of the JSON value is created. That makes it faster for large documents by avoiding the copy. However, the JSON value might be corrupted if the function throws an exception.
\ No newline at end of file
diff --git a/api/basic_json/push_back/index.html b/api/basic_json/push_back/index.html
new file mode 100644
index 000000000..e2025d404
--- /dev/null
+++ b/api/basic_json/push_back/index.html
@@ -0,0 +1,99 @@
+ push_back - JSON for Modern C++
Appends the given element val to the end of the JSON array. If the function is called on a JSON null value, an empty array is created before appending val.
Inserts the given element val to the JSON object. If the function is called on a JSON null value, an empty object is created before inserting val.
This function allows using push_back with an initializer list. In case
the current value is an object,
the initializer list init contains only two elements, and
the first element of init is a string,
init is converted into an object element and added using push_back(const typename object_t::value_type&). Otherwise, init is converted to a JSON value and added using push_back(basic_json&&).
All functions can throw the following exception: - Throws type_error.308 when called on a type other than JSON array or null; example: "cannot use push_back() with number"
(3) This function is required to resolve an ambiguous overload error, because pairs like {"key", "value"} can be both interpreted as object_t::value_type or std::initializer_list<basic_json>, see #235 for more information.
The example shows how push_back() and += can be used to add elements to a JSON object. Note how the null value was silently converted to a JSON object.
\ No newline at end of file
diff --git a/api/basic_json/rbegin/index.html b/api/basic_json/rbegin/index.html
new file mode 100644
index 000000000..6a4782de2
--- /dev/null
+++ b/api/basic_json/rbegin/index.html
@@ -0,0 +1,20 @@
+ rbegin - JSON for Modern C++
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to the reverse-beginning
+json::reverse_iteratorit=array.rbegin();
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/rend/index.html b/api/basic_json/rend/index.html
new file mode 100644
index 000000000..4fc79c111
--- /dev/null
+++ b/api/basic_json/rend/index.html
@@ -0,0 +1,23 @@
+ rend - JSON for Modern C++
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.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create an array value
+jsonarray={1,2,3,4,5};
+
+// get an iterator to the reverse-end
+json::reverse_iteratorit=array.rend();
+
+// increment the iterator to point to the first element
+--it;
+
+// serialize the element that the iterator points to
+std::cout<<*it<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/sax_parse/index.html b/api/basic_json/sax_parse/index.html
new file mode 100644
index 000000000..6679d74f5
--- /dev/null
+++ b/api/basic_json/sax_parse/index.html
@@ -0,0 +1,184 @@
+ sax_parse - JSON for Modern C++
The value_type of the iterator must be an integral type with size of 1, 2 or 4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
The SAX event lister must follow the interface of json_sax.
Linear in the length of the input. The parser is a predictive LL(1) parser. The complexity can be higher if the SAX consumer sax has a super-linear complexity.
Ignoring comments via ignore_comments added in version 3.9.0.
Deprecation
Overload (2) replaces calls to sax_parse with a pair of iterators as their first parameter which has been deprecated in version 3.8.0. This overload will be removed in version 4.0.0. Please replace all calls like sax_parse({ptr,ptr+len}); with sax_parse(ptr,ptr+len);.
\ No newline at end of file
diff --git a/api/basic_json/size/index.html b/api/basic_json/size/index.html
new file mode 100644
index 000000000..5719c6857
--- /dev/null
+++ b/api/basic_json/size/index.html
@@ -0,0 +1,40 @@
+ size - JSON for Modern C++
This function does not return the length of a string stored as JSON value -- it returns the number of elements in the JSON value which is 1 in the case of a string.
\ No newline at end of file
diff --git a/api/basic_json/std_hash/index.html b/api/basic_json/std_hash/index.html
new file mode 100644
index 000000000..f7ec20a08
--- /dev/null
+++ b/api/basic_json/std_hash/index.html
@@ -0,0 +1,31 @@
+ std::hash<basic_json> - JSON for Modern C++
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 null, 0, 0U, and false, etc.
\ No newline at end of file
diff --git a/api/basic_json/std_swap/index.html b/api/basic_json/std_swap/index.html
new file mode 100644
index 000000000..fccd24bf7
--- /dev/null
+++ b/api/basic_json/std_swap/index.html
@@ -0,0 +1,29 @@
+ std::swap<basic_json> - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/string_t/index.html b/api/basic_json/string_t/index.html
new file mode 100644
index 000000000..01335d098
--- /dev/null
+++ b/api/basic_json/string_t/index.html
@@ -0,0 +1,13 @@
+ string_t - JSON for Modern C++
A string is a sequence of zero or more Unicode characters.
To store objects in C++, a type is defined by the template parameter described below. Unicode values are split by the JSON class into byte-sized characters during deserialization.
Strings are stored in UTF-8 encoding. Therefore, functions like std::string::size() or std::string::length() return the number of bytes in the string rather than the number of characters or glyphs.
Software implementations are typically required to test names of object members for equality. Implementations that transform the textual representation into sequences of Unicode code units and then perform the comparison numerically, code unit by code unit, are interoperable in the sense that implementations will agree in all cases on equality or inequality of two strings. For example, implementations that compare strings with escaped characters unconverted may incorrectly find that "a\\b" and "a\u005Cb" are not equal.
This implementation is interoperable as it does compare strings code unit by code unit.
\ No newline at end of file
diff --git a/api/basic_json/swap/index.html b/api/basic_json/swap/index.html
new file mode 100644
index 000000000..8c3951c16
--- /dev/null
+++ b/api/basic_json/swap/index.html
@@ -0,0 +1,129 @@
+ swap - JSON for Modern C++
Exchanges the contents of the JSON value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
Exchanges the contents of the JSON value from left with those of right. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. Implemented as a friend function callable via ADL.
Exchanges the contents of a JSON array with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
Exchanges the contents of a JSON object with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
Exchanges the contents of a JSON string with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
Exchanges the contents of a binary value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated.
Exchanges the contents of a binary value with those of other. Does not invoke any move, copy, or swap operations on individual elements. All iterators and references remain valid. The past-the-end iterator is invalidated. Unlike version (6), no binary subtype is involved.
\ No newline at end of file
diff --git a/api/basic_json/to_bjdata/index.html b/api/basic_json/to_bjdata/index.html
new file mode 100644
index 000000000..862252dca
--- /dev/null
+++ b/api/basic_json/to_bjdata/index.html
@@ -0,0 +1,79 @@
+ to_bjdata - JSON for Modern C++
Serializes a given JSON value j to a byte vector using the BJData (Binary JData) serialization format. BJData aims to be more compact than JSON itself, yet more efficient to parse.
Returns a byte vector containing the BJData serialization.
Writes the BJData serialization to an output adapter.
The exact mapping and its limitations is described on a dedicated page.
\ No newline at end of file
diff --git a/api/basic_json/to_bson/index.html b/api/basic_json/to_bson/index.html
new file mode 100644
index 000000000..d26b6c65a
--- /dev/null
+++ b/api/basic_json/to_bson/index.html
@@ -0,0 +1,30 @@
+ to_bson - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/to_cbor/index.html b/api/basic_json/to_cbor/index.html
new file mode 100644
index 000000000..3ae64d114
--- /dev/null
+++ b/api/basic_json/to_cbor/index.html
@@ -0,0 +1,30 @@
+ to_cbor - JSON for Modern C++
Serializes a given JSON value j to a byte vector using the CBOR (Concise Binary Object Representation) serialization format. CBOR is a binary serialization format which aims to be more compact than JSON itself, yet more efficient to parse.
Returns a byte vector containing the CBOR serialization.
Writes the CBOR serialization to an output adapter.
The exact mapping and its limitations is described on a dedicated page.
\ No newline at end of file
diff --git a/api/basic_json/to_msgpack/index.html b/api/basic_json/to_msgpack/index.html
new file mode 100644
index 000000000..c65256ac0
--- /dev/null
+++ b/api/basic_json/to_msgpack/index.html
@@ -0,0 +1,30 @@
+ to_msgpack - JSON for Modern C++
Serializes a given JSON value j to a byte vector using the MessagePack serialization format. MessagePack is a binary serialization format which aims to be more compact than JSON itself, yet more efficient to parse.
Returns a byte vector containing the MessagePack serialization.
Writes the MessagePack serialization to an output adapter.
The exact mapping and its limitations is described on a dedicated page.
\ No newline at end of file
diff --git a/api/basic_json/to_string/index.html b/api/basic_json/to_string/index.html
new file mode 100644
index 000000000..42c7b664d
--- /dev/null
+++ b/api/basic_json/to_string/index.html
@@ -0,0 +1,31 @@
+ to_string - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/to_ubjson/index.html b/api/basic_json/to_ubjson/index.html
new file mode 100644
index 000000000..7c8c11863
--- /dev/null
+++ b/api/basic_json/to_ubjson/index.html
@@ -0,0 +1,79 @@
+ to_ubjson - JSON for Modern C++
Serializes a given JSON value j to a byte vector using the UBJSON (Universal Binary JSON) serialization format. UBJSON aims to be more compact than JSON itself, yet more efficient to parse.
Returns a byte vector containing the UBJSON serialization.
Writes the UBJSON serialization to an output adapter.
The exact mapping and its limitations is described on a dedicated page.
\ No newline at end of file
diff --git a/api/basic_json/type/index.html b/api/basic_json/type/index.html
new file mode 100644
index 000000000..da29e3a19
--- /dev/null
+++ b/api/basic_json/type/index.html
@@ -0,0 +1,38 @@
+ type - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/type_error/index.html b/api/basic_json/type_error/index.html
new file mode 100644
index 000000000..410b6c7d9
--- /dev/null
+++ b/api/basic_json/type_error/index.html
@@ -0,0 +1,24 @@
+ type_error - JSON for Modern C++
This exception is thrown in case of a type error; that is, a library function is executed on a JSON value whose type does not match the expected semantics.
\ No newline at end of file
diff --git a/api/basic_json/type_name/index.html b/api/basic_json/type_name/index.html
new file mode 100644
index 000000000..531dd8788
--- /dev/null
+++ b/api/basic_json/type_name/index.html
@@ -0,0 +1,37 @@
+ type_name - JSON for Modern C++
The following code exemplifies type_name() for all JSON types.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+// create JSON values
+jsonj_null;
+jsonj_boolean=true;
+jsonj_number_integer=-17;
+jsonj_number_unsigned=42u;
+jsonj_number_float=23.42;
+jsonj_object={{"one",1},{"two",2}};
+jsonj_array={1,2,4,8,16};
+jsonj_string="Hello, world";
+
+// call type_name()
+std::cout<<j_null<<" is a "<<j_null.type_name()<<'\n';
+std::cout<<j_boolean<<" is a "<<j_boolean.type_name()<<'\n';
+std::cout<<j_number_integer<<" is a "<<j_number_integer.type_name()<<'\n';
+std::cout<<j_number_unsigned<<" is a "<<j_number_unsigned.type_name()<<'\n';
+std::cout<<j_number_float<<" is a "<<j_number_float.type_name()<<'\n';
+std::cout<<j_object<<" is an "<<j_object.type_name()<<'\n';
+std::cout<<j_array<<" is an "<<j_array.type_name()<<'\n';
+std::cout<<j_string<<" is a "<<j_string.type_name()<<'\n';
+}
+
\ No newline at end of file
diff --git a/api/basic_json/unflatten/index.html b/api/basic_json/unflatten/index.html
new file mode 100644
index 000000000..b9f3747d0
--- /dev/null
+++ b/api/basic_json/unflatten/index.html
@@ -0,0 +1,46 @@
+ unflatten - JSON for Modern C++
The function restores the arbitrary nesting of a JSON value that has been flattened before using the flatten() function. The JSON value must meet certain constraints:
Empty objects and arrays are flattened by flatten() to null values and can not unflattened to their original type. Apart from this example, for a JSON value j, the following is always true: j==j.flatten().unflatten().
\ No newline at end of file
diff --git a/api/basic_json/update/index.html b/api/basic_json/update/index.html
new file mode 100644
index 000000000..b08a54005
--- /dev/null
+++ b/api/basic_json/update/index.html
@@ -0,0 +1,113 @@
+ update - JSON for Modern C++
\ No newline at end of file
diff --git a/api/basic_json/value/index.html b/api/basic_json/value/index.html
new file mode 100644
index 000000000..b5fb4c444
--- /dev/null
+++ b/api/basic_json/value/index.html
@@ -0,0 +1,121 @@
+ value - JSON for Modern C++
See 1. This overload is only available if KeyType is comparable with typenameobject_t::key_type and typenameobject_comparator_t::is_transparent denotes a type.
Returns either a copy of an object's element at the specified JSON pointer ptr or a given default value if no value at ptr exists.
Unlike at, this function does not throw if the given key/ptr was not found.
Unlike operator[], this function does not implicitly add an element to the position defined by key/ptr key. This function is furthermore also applicable to const objects.
type compatible to JSON values, for instance int for JSON integer numbers, bool for JSON booleans, or std::vector types for JSON arrays. Note the type of the expected value at key/ptr and the default value default_value must be compatible.
\ No newline at end of file
diff --git a/api/basic_json/value_t/index.html b/api/basic_json/value_t/index.html
new file mode 100644
index 000000000..faf067ce1
--- /dev/null
+++ b/api/basic_json/value_t/index.html
@@ -0,0 +1,49 @@
+ value_t - JSON for Modern C++
number_float_t for floating-point numbers or to approximate integers which do not fit into the limits of their respective type
Comparison operators
operator< and operator<=> (since C++20) are overloaded and compare according to the ordering described above. Until C++20 all other relational and equality operators yield results according to the integer value of each enumerator. Since C++20 some compilers consider the rewritten candidates generated from operator<=> during overload resolution, while others do not. For predictable and portable behavior use:
operator< or operator<=> when wanting to compare according to the order described above
operator== or operator!= when wanting to compare according to each enumerators integer value
\ No newline at end of file
diff --git a/api/basic_json/~basic_json/index.html b/api/basic_json/~basic_json/index.html
new file mode 100644
index 000000000..6c8e70daa
--- /dev/null
+++ b/api/basic_json/~basic_json/index.html
@@ -0,0 +1,2 @@
+ (Destructor) - JSON for Modern C++
\ No newline at end of file
diff --git a/api/byte_container_with_subtype/byte_container_with_subtype/index.html b/api/byte_container_with_subtype/byte_container_with_subtype/index.html
new file mode 100644
index 000000000..cf68697b6
--- /dev/null
+++ b/api/byte_container_with_subtype/byte_container_with_subtype/index.html
@@ -0,0 +1,37 @@
+ (constructor) - JSON for Modern C++
\ No newline at end of file
diff --git a/api/byte_container_with_subtype/clear_subtype/index.html b/api/byte_container_with_subtype/clear_subtype/index.html
new file mode 100644
index 000000000..d411b0af2
--- /dev/null
+++ b/api/byte_container_with_subtype/clear_subtype/index.html
@@ -0,0 +1,25 @@
+ clear_subtype - JSON for Modern C++
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.
\ No newline at end of file
diff --git a/api/byte_container_with_subtype/has_subtype/index.html b/api/byte_container_with_subtype/has_subtype/index.html
new file mode 100644
index 000000000..aaa6dbfb3
--- /dev/null
+++ b/api/byte_container_with_subtype/has_subtype/index.html
@@ -0,0 +1,23 @@
+ has_subtype - JSON for Modern C++
\ No newline at end of file
diff --git a/api/byte_container_with_subtype/index.html b/api/byte_container_with_subtype/index.html
new file mode 100644
index 000000000..6fd55c14b
--- /dev/null
+++ b/api/byte_container_with_subtype/index.html
@@ -0,0 +1,3 @@
+ Overview - JSON for Modern C++
This type extends the template parameter BinaryType provided to basic_json with a subtype used by BSON and MessagePack. This type exists so that the user does not have to specify a type themselves with a specific naming scheme in order to override the binary type.
\ No newline at end of file
diff --git a/api/byte_container_with_subtype/set_subtype/index.html b/api/byte_container_with_subtype/set_subtype/index.html
new file mode 100644
index 000000000..841381bb3
--- /dev/null
+++ b/api/byte_container_with_subtype/set_subtype/index.html
@@ -0,0 +1,26 @@
+ set_subtype - JSON for Modern C++
\ No newline at end of file
diff --git a/api/byte_container_with_subtype/subtype/index.html b/api/byte_container_with_subtype/subtype/index.html
new file mode 100644
index 000000000..772b17d1e
--- /dev/null
+++ b/api/byte_container_with_subtype/subtype/index.html
@@ -0,0 +1,26 @@
+ subtype - JSON for Modern C++
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.
The example below demonstrates how the subtype can be retrieved with subtype. Note how subtype_type(-1) is returned for container c1.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+// define a byte container based on std::vector
+usingbyte_container_with_subtype=nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>>;
+
+intmain()
+{
+std::vector<std::uint8_t>bytes={{0xca,0xfe,0xba,0xbe}};
+
+// create container
+autoc1=byte_container_with_subtype(bytes);
+
+// create container with subtype
+autoc2=byte_container_with_subtype(bytes,42);
+
+std::cout<<"c1.subtype() = "<<c1.subtype()
+<<"\nc2.subtype() = "<<c2.subtype()<<std::endl;
+
+// in case no subtype is set, return special value
+assert(c1.subtype()==static_cast<byte_container_with_subtype::subtype_type>(-1));
+}
+
\ No newline at end of file
diff --git a/api/json/index.html b/api/json/index.html
new file mode 100644
index 000000000..11bfaa3c2
--- /dev/null
+++ b/api/json/index.html
@@ -0,0 +1,68 @@
+ json - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/back/index.html b/api/json_pointer/back/index.html
new file mode 100644
index 000000000..2c292baa3
--- /dev/null
+++ b/api/json_pointer/back/index.html
@@ -0,0 +1,19 @@
+ back - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/empty/index.html b/api/json_pointer/empty/index.html
new file mode 100644
index 000000000..1979bde5c
--- /dev/null
+++ b/api/json_pointer/empty/index.html
@@ -0,0 +1,26 @@
+ empty - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/index.html b/api/json_pointer/index.html
new file mode 100644
index 000000000..40ffb732e
--- /dev/null
+++ b/api/json_pointer/index.html
@@ -0,0 +1,3 @@
+ Overview - JSON for Modern C++
A JSON pointer defines a string syntax for identifying a specific value within a JSON document. It can be used with functions at and operator[]. Furthermore, JSON pointers are the base for JSON patches.
the string type used for the reference tokens making up the JSON pointer
Deprecation
For backwards compatibility RefStringType may also be a specialization of basic_json in which case string_t will be deduced as basic_json::string_t. This feature is deprecated and may be removed in a future major version.
\ No newline at end of file
diff --git a/api/json_pointer/json_pointer/index.html b/api/json_pointer/json_pointer/index.html
new file mode 100644
index 000000000..ec16df09b
--- /dev/null
+++ b/api/json_pointer/json_pointer/index.html
@@ -0,0 +1,52 @@
+ (Constructor) - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/operator_eq/index.html b/api/json_pointer/operator_eq/index.html
new file mode 100644
index 000000000..6e2bac635
--- /dev/null
+++ b/api/json_pointer/operator_eq/index.html
@@ -0,0 +1,85 @@
+ operator== - JSON for Modern C++
Compares two JSON pointers for equality by comparing their reference tokens.
Compares a JSON pointer and a string or a string and a JSON pointer for equality by converting the string to a JSON pointer and comparing the JSON pointers according to 1.
\ No newline at end of file
diff --git a/api/json_pointer/operator_ne/index.html b/api/json_pointer/operator_ne/index.html
new file mode 100644
index 000000000..c931ff044
--- /dev/null
+++ b/api/json_pointer/operator_ne/index.html
@@ -0,0 +1,75 @@
+ operator!= - JSON for Modern C++
Compares two JSON pointers for inequality by comparing their reference tokens.
Compares a JSON pointer and a string or a string and a JSON pointer for inequality by converting the string to a JSON pointer and comparing the JSON pointers according to 1.
\ No newline at end of file
diff --git a/api/json_pointer/operator_slash/index.html b/api/json_pointer/operator_slash/index.html
new file mode 100644
index 000000000..52739e7e9
--- /dev/null
+++ b/api/json_pointer/operator_slash/index.html
@@ -0,0 +1,31 @@
+ operator/ - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/operator_slasheq/index.html b/api/json_pointer/operator_slasheq/index.html
new file mode 100644
index 000000000..e8160baa7
--- /dev/null
+++ b/api/json_pointer/operator_slasheq/index.html
@@ -0,0 +1,36 @@
+ operator/= - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/parent_pointer/index.html b/api/json_pointer/parent_pointer/index.html
new file mode 100644
index 000000000..eeb485805
--- /dev/null
+++ b/api/json_pointer/parent_pointer/index.html
@@ -0,0 +1,23 @@
+ parent_pointer - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/pop_back/index.html b/api/json_pointer/pop_back/index.html
new file mode 100644
index 000000000..78e30717f
--- /dev/null
+++ b/api/json_pointer/pop_back/index.html
@@ -0,0 +1,27 @@
+ pop_back - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/push_back/index.html b/api/json_pointer/push_back/index.html
new file mode 100644
index 000000000..40d592516
--- /dev/null
+++ b/api/json_pointer/push_back/index.html
@@ -0,0 +1,29 @@
+ push_back - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/string_t/index.html b/api/json_pointer/string_t/index.html
new file mode 100644
index 000000000..a1bfab6ce
--- /dev/null
+++ b/api/json_pointer/string_t/index.html
@@ -0,0 +1,17 @@
+ string_t - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_pointer/to_string/index.html b/api/json_pointer/to_string/index.html
new file mode 100644
index 000000000..c9450525b
--- /dev/null
+++ b/api/json_pointer/to_string/index.html
@@ -0,0 +1,49 @@
+ to_string - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/binary/index.html b/api/json_sax/binary/index.html
new file mode 100644
index 000000000..13accd254
--- /dev/null
+++ b/api/json_sax/binary/index.html
@@ -0,0 +1,119 @@
+ binary - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/boolean/index.html b/api/json_sax/boolean/index.html
new file mode 100644
index 000000000..2cae0e533
--- /dev/null
+++ b/api/json_sax/boolean/index.html
@@ -0,0 +1,170 @@
+ boolean - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/end_array/index.html b/api/json_sax/end_array/index.html
new file mode 100644
index 000000000..1bd171b09
--- /dev/null
+++ b/api/json_sax/end_array/index.html
@@ -0,0 +1,170 @@
+ end_array - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/end_object/index.html b/api/json_sax/end_object/index.html
new file mode 100644
index 000000000..6949732a2
--- /dev/null
+++ b/api/json_sax/end_object/index.html
@@ -0,0 +1,170 @@
+ end_object - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/index.html b/api/json_sax/index.html
new file mode 100644
index 000000000..07e06bb1f
--- /dev/null
+++ b/api/json_sax/index.html
@@ -0,0 +1,3 @@
+ Overview - JSON for Modern C++
This class describes the SAX interface used by sax_parse. Each function is called in different situations while the input is parsed. The boolean return value informs the parser whether to continue processing the input.
\ No newline at end of file
diff --git a/api/json_sax/key/index.html b/api/json_sax/key/index.html
new file mode 100644
index 000000000..53ad61cec
--- /dev/null
+++ b/api/json_sax/key/index.html
@@ -0,0 +1,170 @@
+ key - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/null/index.html b/api/json_sax/null/index.html
new file mode 100644
index 000000000..2ff60ec48
--- /dev/null
+++ b/api/json_sax/null/index.html
@@ -0,0 +1,170 @@
+ null - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/number_float/index.html b/api/json_sax/number_float/index.html
new file mode 100644
index 000000000..59f582e10
--- /dev/null
+++ b/api/json_sax/number_float/index.html
@@ -0,0 +1,170 @@
+ number_float - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/number_integer/index.html b/api/json_sax/number_integer/index.html
new file mode 100644
index 000000000..146fce1c7
--- /dev/null
+++ b/api/json_sax/number_integer/index.html
@@ -0,0 +1,170 @@
+ number_integer - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/number_unsigned/index.html b/api/json_sax/number_unsigned/index.html
new file mode 100644
index 000000000..55824c726
--- /dev/null
+++ b/api/json_sax/number_unsigned/index.html
@@ -0,0 +1,170 @@
+ number_unsigned - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/parse_error/index.html b/api/json_sax/parse_error/index.html
new file mode 100644
index 000000000..d803be9b9
--- /dev/null
+++ b/api/json_sax/parse_error/index.html
@@ -0,0 +1,172 @@
+ parse_error - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/start_array/index.html b/api/json_sax/start_array/index.html
new file mode 100644
index 000000000..12b8e7130
--- /dev/null
+++ b/api/json_sax/start_array/index.html
@@ -0,0 +1,170 @@
+ start_array - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/start_object/index.html b/api/json_sax/start_object/index.html
new file mode 100644
index 000000000..cbba53d06
--- /dev/null
+++ b/api/json_sax/start_object/index.html
@@ -0,0 +1,170 @@
+ start_object - JSON for Modern C++
\ No newline at end of file
diff --git a/api/json_sax/string/index.html b/api/json_sax/string/index.html
new file mode 100644
index 000000000..f0db13366
--- /dev/null
+++ b/api/json_sax/string/index.html
@@ -0,0 +1,170 @@
+ string - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/index.html b/api/macros/index.html
new file mode 100644
index 000000000..2ff6dfff1
--- /dev/null
+++ b/api/macros/index.html
@@ -0,0 +1 @@
+ Overview - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/json_assert/index.html b/api/macros/json_assert/index.html
new file mode 100644
index 000000000..dfa4334c5
--- /dev/null
+++ b/api/macros/json_assert/index.html
@@ -0,0 +1,27 @@
+ JSON_ASSERT - JSON for Modern C++
The library uses numerous assertions to guarantee invariants and to abort in case of otherwise undefined behavior (e.g., when calling operator[] with a missing object key on a const object). See page runtime assertions for more information.
Defining the macro to code that does not call std::abort may leave the library in an undefined state.
\ No newline at end of file
diff --git a/api/macros/json_diagnostics/index.html b/api/macros/json_diagnostics/index.html
new file mode 100644
index 000000000..a776aa1d9
--- /dev/null
+++ b/api/macros/json_diagnostics/index.html
@@ -0,0 +1,47 @@
+ JSON_DIAGNOSTICS - JSON for Modern C++
When enabled, exception messages contain a JSON Pointer to the JSON value that triggered the exception. Note that enabling this macro increases the size of every JSON value by one pointer and adds some runtime overhead.
As of version 3.11.0, this macro is no longer required to be defined consistently throughout a codebase to avoid One Definition Rule (ODR) violations, as the value of this macro is encoded in the namespace, resulting in distinct symbol names.
This allows different parts of a codebase to use different versions or configurations of this library without causing improper behavior.
Where possible, it is still recommended that all code define this the same way for maximum interoperability.
CMake option
Diagnostic messages can also be controlled with the CMake option JSON_Diagnostics (OFF by default) which defines JSON_DIAGNOSTICS accordingly.
\ No newline at end of file
diff --git a/api/macros/json_disable_enum_serialization/index.html b/api/macros/json_disable_enum_serialization/index.html
new file mode 100644
index 000000000..9e2de1d78
--- /dev/null
+++ b/api/macros/json_disable_enum_serialization/index.html
@@ -0,0 +1,92 @@
+ JSON_DISABLE_ENUM_SERIALIZATION - JSON for Modern C++
#define JSON_DISABLE_ENUM_SERIALIZATION /* value */
+
When defined to 1, default serialization and deserialization functions for enums are excluded and have to be provided by the user, for example, using NLOHMANN_JSON_SERIALIZE_ENUM (see arbitrary type conversions for more details).
Parsing or serializing an enum will result in a compiler error.
Enum serialization can also be controlled with the CMake option JSON_DisableEnumSerialization (OFF by default) which defines JSON_DISABLE_ENUM_SERIALIZATION accordingly.
The code below forces the library not to create default serialization/deserialization functions from_json and to_json, meaning the code below does not compile.
#define JSON_DISABLE_ENUM_SERIALIZATION 1
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+enumclassChoice
+{
+first,
+second,
+};
+
+intmain()
+{
+// normally invokes to_json serialization function but with JSON_DISABLE_ENUM_SERIALIZATION defined, it does not
+constjsonj=Choice::first;
+
+// normally invokes from_json parse function but with JSON_DISABLE_ENUM_SERIALIZATION defined, it does not
+Choicech=j.get<Choice>();
+}
+
Example 2: Serialize enum macro
The code below forces the library not to create default serialization/deserialization functions from_json and to_json, but uses NLOHMANN_JSON_SERIALIZE_ENUM to parse and serialize the enum.
#define JSON_DISABLE_ENUM_SERIALIZATION 1
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+enumclassChoice
+{
+first,
+second,
+};
+
+NLOHMANN_JSON_SERIALIZE_ENUM(Choice,
+{
+{Choice::first,"first"},
+{Choice::second,"second"},
+})
+
+intmain()
+{
+// uses user-defined to_json function defined by macro
+constjsonj=Choice::first;
+
+// uses user-defined from_json function defined by macro
+Choicech=j.get<Choice>();
+}
+
Example 3: User-defined serialization/deserialization functions
The code below forces the library not to create default serialization/deserialization functions from_json and to_json, but uses user-defined functions to parse and serialize the enum.
\ No newline at end of file
diff --git a/api/macros/json_has_cpp_11/index.html b/api/macros/json_has_cpp_11/index.html
new file mode 100644
index 000000000..3a1fe652a
--- /dev/null
+++ b/api/macros/json_has_cpp_11/index.html
@@ -0,0 +1,9 @@
+ JSON_HAS_CPP_20 - JSON for Modern C++
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 these new features, the library implements some preprocessor checks to determine the C++ standard. By defining any of these symbols, the internal check is overridden and the provided C++ version is unconditionally assumed. This can be helpful for compilers that only implement parts of the standard and would be detected incorrectly.
\ No newline at end of file
diff --git a/api/macros/json_has_filesystem/index.html b/api/macros/json_has_filesystem/index.html
new file mode 100644
index 000000000..bb721ae66
--- /dev/null
+++ b/api/macros/json_has_filesystem/index.html
@@ -0,0 +1,7 @@
+ JSON_HAS_FILESYSTEM - JSON for Modern C++
#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. As compiler support for filesystem is limited, the library tries to detect whether <filesystem>/std::filesystem (JSON_HAS_FILESYSTEM) or <experimental/filesystem>/std::experimental::filesystem (JSON_HAS_EXPERIMENTAL_FILESYSTEM) should be used. To override the built-in check, define JSON_HAS_FILESYSTEM or JSON_HAS_EXPERIMENTAL_FILESYSTEM to 1.
The default value is detected based on the preprocessor macros __cpp_lib_filesystem, __cpp_lib_experimental_filesystem, __has_include(<filesystem>), or __has_include(<experimental/filesystem>).
\ No newline at end of file
diff --git a/api/macros/json_has_ranges/index.html b/api/macros/json_has_ranges/index.html
new file mode 100644
index 000000000..ad8ce41e1
--- /dev/null
+++ b/api/macros/json_has_ranges/index.html
@@ -0,0 +1,6 @@
+ JSON_HAS_RANGES - JSON for Modern C++
This macro indicates whether the standard library has any support for ranges. Implies support for concepts. Possible values are 1 when supported or 0 when unsupported.
\ No newline at end of file
diff --git a/api/macros/json_has_three_way_comparison/index.html b/api/macros/json_has_three_way_comparison/index.html
new file mode 100644
index 000000000..7641ffadf
--- /dev/null
+++ b/api/macros/json_has_three_way_comparison/index.html
@@ -0,0 +1,6 @@
+ JSON_HAS_THREE_WAY_COMPARISON - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/json_no_io/index.html b/api/macros/json_no_io/index.html
new file mode 100644
index 000000000..0cb9817c4
--- /dev/null
+++ b/api/macros/json_no_io/index.html
@@ -0,0 +1,7 @@
+ JSON_NO_IO - JSON for Modern C++
When defined, headers <cstdio>, <ios>, <iosfwd>, <istream>, and <ostream> are not included and parse functions relying on these headers are excluded. This is relevant for environments where these I/O functions are disallowed for security reasons (e.g., Intel Software Guard Extensions (SGX)).
\ No newline at end of file
diff --git a/api/macros/json_noexception/index.html b/api/macros/json_noexception/index.html
new file mode 100644
index 000000000..731d714a3
--- /dev/null
+++ b/api/macros/json_noexception/index.html
@@ -0,0 +1,7 @@
+ JSON_NOEXCEPTION - JSON for Modern C++
Exceptions can be switched off by defining the symbol JSON_NOEXCEPTION. When defining JSON_NOEXCEPTION, try is replaced by if(true), catch is replaced by if(false), and throw is replaced by std::abort().
The same effect is achieved by setting the compiler flag -fno-exceptions.
\ No newline at end of file
diff --git a/api/macros/json_skip_library_version_check/index.html b/api/macros/json_skip_library_version_check/index.html
new file mode 100644
index 000000000..82b06db9a
--- /dev/null
+++ b/api/macros/json_skip_library_version_check/index.html
@@ -0,0 +1,4 @@
+ JSON_SKIP_LIBRARY_VERSION_CHECK - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/json_skip_unsupported_compiler_check/index.html b/api/macros/json_skip_unsupported_compiler_check/index.html
new file mode 100644
index 000000000..7168cf43a
--- /dev/null
+++ b/api/macros/json_skip_unsupported_compiler_check/index.html
@@ -0,0 +1,7 @@
+ JSON_SKIP_UNSUPPORTED_COMPILER_CHECK - JSON for Modern C++
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 features are not used.
\ No newline at end of file
diff --git a/api/macros/json_throw_user/index.html b/api/macros/json_throw_user/index.html
new file mode 100644
index 000000000..9a58d2b6e
--- /dev/null
+++ b/api/macros/json_throw_user/index.html
@@ -0,0 +1,24 @@
+ JSON_TRY_USER - JSON for Modern C++
// (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.
This macro overrides catch calls inside the library. The argument is the type of the exception to catch. As of version 3.8.0, the library only catches std::out_of_range exceptions internally to rethrow them as json::out_of_range exceptions. The macro is always followed by a scope.
This macro overrides throw calls inside the library. The argument is the exception to be thrown. Note that JSON_THROW_USER should leave the current scope (e.g., by throwing or aborting), as continuing after it may yield undefined behavior.
This macro overrides try calls inside the library. It has no arguments and is always followed by a scope.
When exceptions are switched off, the try block is executed unconditionally, and throwing exceptions is replaced by calling std::abort to make reaching the throw branch abort the process.
#define JSON_THROW_USER(exception) std::abort()
+#define JSON_TRY_USER if (true)
+#define JSON_CATCH_USER(exception) if (false)
+
\ No newline at end of file
diff --git a/api/macros/json_use_global_udls/index.html b/api/macros/json_use_global_udls/index.html
new file mode 100644
index 000000000..d16d86191
--- /dev/null
+++ b/api/macros/json_use_global_udls/index.html
@@ -0,0 +1,32 @@
+ JSON_USE_GLOBAL_UDLS - JSON for Modern C++
The user-defined string literals will be removed from the global namespace in the next major release of the library.
To prepare existing code, define JSON_USE_GLOBAL_UDLS to 0 and bring the string literals into scope where needed. Refer to any of the string literals for details.
CMake option
The placement of user-defined string literals can also be controlled with the CMake option JSON_GlobalUDLs (ON by default) which defines JSON_USE_GLOBAL_UDLS accordingly.
The code below shows how UDLs need to be brought into scope before using _json when JSON_USE_GLOBAL_UDLS is defined to 0.
#define JSON_USE_GLOBAL_UDLS 0
+#include<nlohmann/json.hpp>
+
+#include<iostream>
+
+intmain()
+{
+// auto j = "42"_json; // This line would fail to compile,
+// because the UDLs are not in the global namespace
+
+// Bring the UDLs into scope
+usingnamespacenlohmann::json_literals;
+
+autoj="42"_json;
+
+std::cout<<j<<std::endl;
+}
+
\ No newline at end of file
diff --git a/api/macros/json_use_implicit_conversions/index.html b/api/macros/json_use_implicit_conversions/index.html
new file mode 100644
index 000000000..e7025ec7c
--- /dev/null
+++ b/api/macros/json_use_implicit_conversions/index.html
@@ -0,0 +1,7 @@
+ JSON_USE_IMPLICIT_CONVERSIONS - JSON for Modern C++
#define JSON_USE_IMPLICIT_CONVERSIONS /* value */
+
When defined to 0, implicit conversions are switched off. By default, implicit conversions are switched on. The value directly affects operator ValueType.
Implicit conversions will be switched off by default in the next major release of the library.
You can prepare existing code by already defining JSON_USE_IMPLICIT_CONVERSIONS to 0 and replace any implicit conversions with calls to get.
CMake option
Implicit conversions can also be controlled with the CMake option JSON_ImplicitConversions (ON by default) which defines JSON_USE_IMPLICIT_CONVERSIONS accordingly.
\ No newline at end of file
diff --git a/api/macros/json_use_legacy_discarded_value_comparison/index.html b/api/macros/json_use_legacy_discarded_value_comparison/index.html
new file mode 100644
index 000000000..6e1920cc3
--- /dev/null
+++ b/api/macros/json_use_legacy_discarded_value_comparison/index.html
@@ -0,0 +1,7 @@
+ JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON - JSON for Modern C++
When targeting C++20 or above, enabling the legacy comparison behavior is strongly discouraged.
The 3-way comparison operator (<=>) will always give the correct result (std::partial_ordering::unordered) regardless of the value of JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON.
Overloads for the equality and relational operators emulate the legacy behavior.
Code outside your control may use either 3-way comparison or the equality and relational operators, resulting in inconsistent and unpredictable behavior.
See operator<=> for more information on 3-way comparison.
Deprecation
The legacy comparison behavior is deprecated and may be removed in a future major version release.
New code should not depend on it and existing code should try to remove or rewrite expressions relying on it.
CMake option
Legacy comparison can also be controlled with the CMake option JSON_LegacyDiscardedValueComparison (OFF by default) which defines JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON accordingly.
\ No newline at end of file
diff --git a/api/macros/nlohmann_define_type_intrusive/index.html b/api/macros/nlohmann_define_type_intrusive/index.html
new file mode 100644
index 000000000..718aeb526
--- /dev/null
+++ b/api/macros/nlohmann_define_type_intrusive/index.html
@@ -0,0 +1,214 @@
+ NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT - JSON for Modern C++
These macros can be used to simplify the serialization/deserialization of types if you want to use a JSON object as serialization and want to use the member variable names as object keys in that object. The macro is to be defined inside the class/struct to create code for. Unlike NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE, it can access private members. The first parameter is the name of the class/struct, and all remaining parameters name the members.
Will use at during deserialization and will throw out_of_range.403 if a key is missing in the JSON object.
Will use value during deserialization and fall back to the default value for the respective type of the member variable if a key in the JSON object is missing. The generated from_json() function default constructs an object and uses its values as the defaults when calling the value function.
The macro must be used inside the type (class/struct).
Implementation limits
The current implementation is limited to at most 64 member variables. If you want to serialize/deserialize types with more than 64 member variables, you need to define the to_json/from_json functions manually.
ns::person is default-constructible. This is a requirement for using the macro.
ns::person has private member variables. This makes NLOHMANN_DEFINE_TYPE_INTRUSIVE applicable, but not NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE.
The macro NLOHMANN_DEFINE_TYPE_INTRUSIVE is used inside the class.
A missing key "age" in the deserialization yields an exception. To fall back to the default value, NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT can be used.
ns::person is default-constructible. This is a requirement for using the macro.
ns::person has private member variables. This makes NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT applicable, but not NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT.
The macro NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT is used inside the class.
A missing key "age" in the deserialization does not yield an exception. Instead, the default value -1 is used.
\ No newline at end of file
diff --git a/api/macros/nlohmann_define_type_non_intrusive/index.html b/api/macros/nlohmann_define_type_non_intrusive/index.html
new file mode 100644
index 000000000..07a7e70f8
--- /dev/null
+++ b/api/macros/nlohmann_define_type_non_intrusive/index.html
@@ -0,0 +1,196 @@
+ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT - JSON for Modern C++
These macros can be used to simplify the serialization/deserialization of types if you want to use a JSON object as serialization and want to use the member variable names as object keys in that object. The macro is to be defined outside the class/struct to create code for, but inside its namespace. Unlike NLOHMANN_DEFINE_TYPE_INTRUSIVE, it cannot access private members. The first parameter is the name of the class/struct, and all remaining parameters name the members.
Will use at during deserialization and will throw out_of_range.403 if a key is missing in the JSON object.
Will use value during deserialization and fall back to the default value for the respective type of the member variable if a key in the JSON object is missing. The generated from_json() function default constructs an object and uses its values as the defaults when calling the value function.
The macro must be used outside the type (class/struct).
The passed members must be public.
Implementation limits
The current implementation is limited to at most 64 member variables. If you want to serialize/deserialize types with more than 64 member variables, you need to define the to_json/from_json functions manually.
ns::person is default-constructible. This is a requirement for using the macro.
ns::person has only public member variables. This makes NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE applicable.
The macro NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE is used outside the class, but inside its namespace ns.
A missing key "age" in the deserialization yields an exception. To fall back to the default value, NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT can be used.
\ No newline at end of file
diff --git a/api/macros/nlohmann_json_namespace/index.html b/api/macros/nlohmann_json_namespace/index.html
new file mode 100644
index 000000000..7b5ed9d7e
--- /dev/null
+++ b/api/macros/nlohmann_json_namespace/index.html
@@ -0,0 +1,17 @@
+ NLOHMANN_JSON_NAMESPACE - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/nlohmann_json_namespace_begin/index.html b/api/macros/nlohmann_json_namespace_begin/index.html
new file mode 100644
index 000000000..02b086388
--- /dev/null
+++ b/api/macros/nlohmann_json_namespace_begin/index.html
@@ -0,0 +1,43 @@
+ NLOHMANN_JSON_NAMESPACE_END - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/nlohmann_json_namespace_no_version/index.html b/api/macros/nlohmann_json_namespace_no_version/index.html
new file mode 100644
index 000000000..15a3955de
--- /dev/null
+++ b/api/macros/nlohmann_json_namespace_no_version/index.html
@@ -0,0 +1,17 @@
+ NLOHMANN_JSON_NAMESPACE_NO_VERSION - JSON for Modern C++
\ No newline at end of file
diff --git a/api/macros/nlohmann_json_serialize_enum/index.html b/api/macros/nlohmann_json_serialize_enum/index.html
new file mode 100644
index 000000000..c07b0e786
--- /dev/null
+++ b/api/macros/nlohmann_json_serialize_enum/index.html
@@ -0,0 +1,104 @@
+ NLOHMANN_JSON_SERIALIZE_ENUM - JSON for Modern C++
By default, enum values are serialized to JSON as integers. In some cases this could result in undesired behavior. If an enum is modified or re-ordered after data has been serialized to JSON, the later de-serialized JSON data may be undefined or a different enum value than was originally intended.
The NLOHMANN_JSON_SERIALIZE_ENUM allows to define a user-defined serialization for every enumerator.
The macro must be used inside the namespace of the enum.
Important notes
When using get<ENUM_TYPE>(), undefined JSON values will default to the first specified conversion. Select this default pair carefully. See example 1 below.
If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the list will be returned when converting to or from JSON. See example 2 below.
Example 2: Multiple conversions for one enumerator
The example shows how to use multiple conversions for a single enumerator. In the example, Color::red will always be serialized to "red", because the first occurring conversion. The second conversion, however, offers an alternative deserialization from "rot" to Color::red.
\ No newline at end of file
diff --git a/api/macros/nlohmann_json_version_major/index.html b/api/macros/nlohmann_json_version_major/index.html
new file mode 100644
index 000000000..1d9e69e01
--- /dev/null
+++ b/api/macros/nlohmann_json_version_major/index.html
@@ -0,0 +1,17 @@
+ NLOHMANN_JSON_VERSION_PATCH - JSON for Modern C++
The example below shows how NLOHMANN_JSON_VERSION_MAJOR, NLOHMANN_JSON_VERSION_MINOR, and NLOHMANN_JSON_VERSION_PATCH are defined by the library.
#include<iostream>
+#include<nlohmann/json.hpp>
+
+usingjson=nlohmann::json;
+
+intmain()
+{
+std::cout<<"JSON for Modern C++ version "
+<<NLOHMANN_JSON_VERSION_MAJOR<<"."
+<<NLOHMANN_JSON_VERSION_MINOR<<"."
+<<NLOHMANN_JSON_VERSION_PATCH<<std::endl;
+}
+
\ No newline at end of file
diff --git a/api/operator_gtgt/index.html b/api/operator_gtgt/index.html
new file mode 100644
index 000000000..17a104849
--- /dev/null
+++ b/api/operator_gtgt/index.html
@@ -0,0 +1,41 @@
+ operator>>(basic_json) - JSON for Modern C++
This function replaces function std::istream&operator<<(basic_json&j,std::istream&i) which has been deprecated in version 3.0.0. It will be removed in version 4.0.0. Please replace calls like j<<i; with i>>j;.
\ No newline at end of file
diff --git a/api/operator_literal_json/index.html b/api/operator_literal_json/index.html
new file mode 100644
index 000000000..082e11097
--- /dev/null
+++ b/api/operator_literal_json/index.html
@@ -0,0 +1,24 @@
+ operator""_json - JSON for Modern C++
This operator implements a user-defined string literal for JSON objects. It can be used by adding _json to a string literal and returns a json object if no parse error occurred.
It is recommended to bring the operator into scope using any of the following lines:
\ No newline at end of file
diff --git a/api/operator_literal_json_pointer/index.html b/api/operator_literal_json_pointer/index.html
new file mode 100644
index 000000000..5d7218d91
--- /dev/null
+++ b/api/operator_literal_json_pointer/index.html
@@ -0,0 +1,22 @@
+ operator""_json_pointer - JSON for Modern C++
This operator implements a user-defined string literal for JSON Pointers. It can be used by adding _json_pointer to a string literal and returns a json_pointer object if no parse error occurred.
It is recommended to bring the operator into scope using any of the following lines:
\ No newline at end of file
diff --git a/api/operator_ltlt/index.html b/api/operator_ltlt/index.html
new file mode 100644
index 000000000..f66b1aedd
--- /dev/null
+++ b/api/operator_ltlt/index.html
@@ -0,0 +1,60 @@
+ operator<<(json_pointer) - JSON for Modern C++
Serialize the given JSON value j to the output stream o. The JSON value will be serialized using the dump member function.
The indentation of the output can be controlled with the member variable width of the output stream o. For instance, using the manipulator std::setw(4) on o sets the indentation level to 4 and the serialization result is the same as calling dump(4).
The indentation character can be controlled with the member variable fill of the output stream o. For instance, the manipulator std::setfill('\\t') sets indentation to use a tab character rather than the default space character.
Write a string representation of the given JSON pointer ptr to the output stream o. The string representation is obtained using the to_string member function.
Throws type_error.316 if a string stored inside the JSON value is not UTF-8 encoded. Note that unlike the dump member functions, no error_handler can be set.
Function std::ostream&operator<<(std::ostream&o,constbasic_json&j) replaces function std::ostream&operator>>(constbasic_json&j,std::ostream&o) which has been deprecated in version 3.0.0. It will be removed in version 4.0.0. Please replace calls like j>>o; with o<<j;.
Added in version 1.0.0. Added support for indentation character and deprecated std::ostream&operator>>(constbasic_json&j,std::ostream&o) in version 3.0.0.
\ No newline at end of file
diff --git a/api/ordered_json/index.html b/api/ordered_json/index.html
new file mode 100644
index 000000000..1e347fc14
--- /dev/null
+++ b/api/ordered_json/index.html
@@ -0,0 +1,21 @@
+ ordered_json - JSON for Modern C++
\ No newline at end of file
diff --git a/api/ordered_map/index.html b/api/ordered_map/index.html
new file mode 100644
index 000000000..02240d5da
--- /dev/null
+++ b/api/ordered_map/index.html
@@ -0,0 +1,54 @@
+ ordered_map - JSON for Modern C++
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { h } from \"~/utilities\"\n\nimport { renderTooltip } from \"../tooltip\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render an annotation\n *\n * @param id - Annotation identifier\n * @param prefix - Tooltip identifier prefix\n *\n * @returns Element\n */\nexport function renderAnnotation(\n id: string | number, prefix?: string\n): HTMLElement {\n prefix = prefix ? `${prefix}_annotation_${id}` : undefined\n\n /* Render tooltip with anchor, if given */\n if (prefix) {\n const anchor = prefix ? `#${prefix}` : undefined\n return (\n \n )\n } else {\n return (\n \n )\n }\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { translation } from \"~/_\"\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a 'copy-to-clipboard' button\n *\n * @param id - Unique identifier\n *\n * @returns Element\n */\nexport function renderClipboardButton(id: string): HTMLElement {\n return (\n code`}\n >\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { ComponentChild } from \"preact\"\n\nimport { configuration, feature, translation } from \"~/_\"\nimport {\n SearchDocument,\n SearchMetadata,\n SearchResultItem\n} from \"~/integrations/search\"\nimport { h, truncate } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Render flag\n */\nconst enum Flag {\n TEASER = 1, /* Render teaser */\n PARENT = 2 /* Render as parent */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper function\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a search document\n *\n * @param document - Search document\n * @param flag - Render flags\n *\n * @returns Element\n */\nfunction renderSearchDocument(\n document: SearchDocument & SearchMetadata, flag: Flag\n): HTMLElement {\n const parent = flag & Flag.PARENT\n const teaser = flag & Flag.TEASER\n\n /* Render missing query terms */\n const missing = Object.keys(document.terms)\n .filter(key => !document.terms[key])\n .reduce((list, key) => [\n ...list, {key}, \" \"\n ], [])\n .slice(0, -1)\n\n /* Assemble query string for highlighting */\n const url = new URL(document.location)\n if (feature(\"search.highlight\"))\n url.searchParams.set(\"h\", Object.entries(document.terms)\n .filter(([, match]) => match)\n .reduce((highlight, [value]) => `${highlight} ${value}`.trim(), \"\")\n )\n\n /* Render article or section, depending on flags */\n const { tags } = configuration()\n return (\n \n \n {parent > 0 && }\n
\n }\n \n \n )\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a search result\n *\n * @param result - Search result\n *\n * @returns Element\n */\nexport function renderSearchResultItem(\n result: SearchResultItem\n): HTMLElement {\n const threshold = result[0].score\n const docs = [...result]\n\n /* Find and extract parent article */\n const parent = docs.findIndex(doc => !doc.location.includes(\"#\"))\n const [article] = docs.splice(parent, 1)\n\n /* Determine last index above threshold */\n let index = docs.findIndex(doc => doc.score < threshold)\n if (index === -1)\n index = docs.length\n\n /* Partition sections */\n const best = docs.slice(0, index)\n const more = docs.slice(index)\n\n /* Render children */\n const children = [\n renderSearchDocument(article, Flag.PARENT | +(!parent && index === 0)),\n ...best.map(section => renderSearchDocument(section, Flag.TEASER)),\n ...more.length ? [\n \n \n {more.length > 0 && more.length === 1\n ? translation(\"search.result.more.one\")\n : translation(\"search.result.more.other\", more.length)\n }\n \n {...more.map(section => renderSearchDocument(section, Flag.TEASER))}\n \n ] : []\n ]\n\n /* Render search result */\n return (\n
\n {children}\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { SourceFacts } from \"~/components\"\nimport { h, round } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render repository facts\n *\n * @param facts - Repository facts\n *\n * @returns Element\n */\nexport function renderSourceFacts(facts: SourceFacts): HTMLElement {\n return (\n
\n {typeof value === \"number\" ? round(value) : value}\n
\n ))}\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Tabbed control type\n */\ntype TabbedControlType =\n | \"prev\"\n | \"next\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render control for content tabs\n *\n * @param type - Control type\n *\n * @returns Element\n */\nexport function renderTabbedControl(\n type: TabbedControlType\n): HTMLElement {\n const classes = `tabbed-control tabbed-control--${type}`\n return (\n
\n \n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a table inside a wrapper to improve scrolling on mobile\n *\n * @param table - Table element\n *\n * @returns Element\n */\nexport function renderTable(table: HTMLElement): HTMLElement {\n return (\n
\n
\n {table}\n
\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { configuration, translation } from \"~/_\"\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Version\n */\nexport interface Version {\n version: string /* Version identifier */\n title: string /* Version title */\n aliases: string[] /* Version aliases */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a version\n *\n * @param version - Version\n *\n * @returns Element\n */\nfunction renderVersion(version: Version): HTMLElement {\n const config = configuration()\n\n /* Ensure trailing slash - see https://bit.ly/3rL5u3f */\n const url = new URL(`../${version.version}/`, config.base)\n return (\n
\n )\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a version selector\n *\n * @param versions - Versions\n * @param active - Active version\n *\n * @returns Element\n */\nexport function renderVersionSelector(\n versions: Version[], active: Version\n): HTMLElement {\n return (\n
\n \n {active.title}\n \n
\n {versions.map(renderVersion)}\n
\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n animationFrameScheduler,\n auditTime,\n combineLatest,\n debounceTime,\n defer,\n delay,\n filter,\n finalize,\n fromEvent,\n map,\n merge,\n switchMap,\n take,\n takeLast,\n takeUntil,\n tap,\n throttleTime,\n withLatestFrom\n} from \"rxjs\"\n\nimport {\n ElementOffset,\n getActiveElement,\n getElementSize,\n watchElementContentOffset,\n watchElementFocus,\n watchElementOffset,\n watchElementVisibility\n} from \"~/browser\"\n\nimport { Component } from \"../../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Annotation\n */\nexport interface Annotation {\n active: boolean /* Annotation is active */\n offset: ElementOffset /* Annotation offset */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n target$: Observable /* Location target observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch annotation\n *\n * @param el - Annotation element\n * @param container - Containing element\n *\n * @returns Annotation observable\n */\nexport function watchAnnotation(\n el: HTMLElement, container: HTMLElement\n): Observable {\n const offset$ = defer(() => combineLatest([\n watchElementOffset(el),\n watchElementContentOffset(container)\n ]))\n .pipe(\n map(([{ x, y }, scroll]): ElementOffset => {\n const { width, height } = getElementSize(el)\n return ({\n x: x - scroll.x + width / 2,\n y: y - scroll.y + height / 2\n })\n })\n )\n\n /* Actively watch annotation on focus */\n return watchElementFocus(el)\n .pipe(\n switchMap(active => offset$\n .pipe(\n map(offset => ({ active, offset })),\n take(+!active || Infinity)\n )\n )\n )\n}\n\n/**\n * Mount annotation\n *\n * @param el - Annotation element\n * @param container - Containing element\n * @param options - Options\n *\n * @returns Annotation component observable\n */\nexport function mountAnnotation(\n el: HTMLElement, container: HTMLElement, { target$ }: MountOptions\n): Observable> {\n const [tooltip, index] = Array.from(el.children)\n\n /* Mount component on subscription */\n return defer(() => {\n const push$ = new Subject()\n const done$ = push$.pipe(takeLast(1))\n push$.subscribe({\n\n /* Handle emission */\n next({ offset }) {\n el.style.setProperty(\"--md-tooltip-x\", `${offset.x}px`)\n el.style.setProperty(\"--md-tooltip-y\", `${offset.y}px`)\n },\n\n /* Handle complete */\n complete() {\n el.style.removeProperty(\"--md-tooltip-x\")\n el.style.removeProperty(\"--md-tooltip-y\")\n }\n })\n\n /* Start animation only when annotation is visible */\n watchElementVisibility(el)\n .pipe(\n takeUntil(done$)\n )\n .subscribe(visible => {\n el.toggleAttribute(\"data-md-visible\", visible)\n })\n\n /* Toggle tooltip presence to mitigate empty lines when copying */\n merge(\n push$.pipe(filter(({ active }) => active)),\n push$.pipe(debounceTime(250), filter(({ active }) => !active))\n )\n .subscribe({\n\n /* Handle emission */\n next({ active }) {\n if (active)\n el.prepend(tooltip)\n else\n tooltip.remove()\n },\n\n /* Handle complete */\n complete() {\n el.prepend(tooltip)\n }\n })\n\n /* Toggle tooltip visibility */\n push$\n .pipe(\n auditTime(16, animationFrameScheduler)\n )\n .subscribe(({ active }) => {\n tooltip.classList.toggle(\"md-tooltip--active\", active)\n })\n\n /* Track relative origin of tooltip */\n push$\n .pipe(\n throttleTime(125, animationFrameScheduler),\n filter(() => !!el.offsetParent),\n map(() => el.offsetParent!.getBoundingClientRect()),\n map(({ x }) => x)\n )\n .subscribe({\n\n /* Handle emission */\n next(origin) {\n if (origin)\n el.style.setProperty(\"--md-tooltip-0\", `${-origin}px`)\n else\n el.style.removeProperty(\"--md-tooltip-0\")\n },\n\n /* Handle complete */\n complete() {\n el.style.removeProperty(\"--md-tooltip-0\")\n }\n })\n\n /* Allow to copy link without scrolling to anchor */\n fromEvent(index, \"click\")\n .pipe(\n takeUntil(done$),\n filter(ev => !(ev.metaKey || ev.ctrlKey))\n )\n .subscribe(ev => ev.preventDefault())\n\n /* Allow to open link in new tab or blur on close */\n fromEvent(index, \"mousedown\")\n .pipe(\n takeUntil(done$),\n withLatestFrom(push$)\n )\n .subscribe(([ev, { active }]) => {\n\n /* Open in new tab */\n if (ev.button !== 0 || ev.metaKey || ev.ctrlKey) {\n ev.preventDefault()\n\n /* Close annotation */\n } else if (active) {\n ev.preventDefault()\n\n /* Focus parent annotation, if any */\n const parent = el.parentElement!.closest(\".md-annotation\")\n if (parent instanceof HTMLElement)\n parent.focus()\n else\n getActiveElement()?.blur()\n }\n })\n\n /* Open and focus annotation on location target */\n target$\n .pipe(\n takeUntil(done$),\n filter(target => target === tooltip),\n delay(125)\n )\n .subscribe(() => el.focus())\n\n /* Create and return component */\n return watchAnnotation(el, container)\n .pipe(\n tap(state => push$.next(state)),\n finalize(() => push$.complete()),\n map(state => ({ ref: el, ...state }))\n )\n })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n EMPTY,\n Observable,\n Subject,\n defer,\n finalize,\n merge,\n share,\n takeLast,\n takeUntil\n} from \"rxjs\"\n\nimport {\n getElement,\n getElements,\n getOptionalElement\n} from \"~/browser\"\nimport { renderAnnotation } from \"~/templates\"\n\nimport { Component } from \"../../../_\"\nimport {\n Annotation,\n mountAnnotation\n} from \"../_\"\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Find all annotation markers in the given code block\n *\n * @param container - Containing element\n *\n * @returns Annotation markers\n */\nfunction findAnnotationMarkers(container: HTMLElement): Text[] {\n const markers: Text[] = []\n for (const el of getElements(\".c, .c1, .cm\", container)) {\n const nodes: Text[] = []\n\n /* Find all text nodes in current element */\n const it = document.createNodeIterator(el, NodeFilter.SHOW_TEXT)\n for (let node = it.nextNode(); node; node = it.nextNode())\n nodes.push(node as Text)\n\n /* Find all markers in each text node */\n for (let text of nodes) {\n let match: RegExpExecArray | null\n\n /* Split text at marker and add to list */\n while ((match = /(\\(\\d+\\))(!)?/.exec(text.textContent!))) {\n const [, id, force] = match\n if (typeof force === \"undefined\") {\n const marker = text.splitText(match.index)\n text = marker.splitText(id.length)\n markers.push(marker)\n\n /* Replace entire text with marker */\n } else {\n text.textContent = id\n markers.push(text)\n break\n }\n }\n }\n }\n return markers\n}\n\n/**\n * Swap the child nodes of two elements\n *\n * @param source - Source element\n * @param target - Target element\n */\nfunction swap(source: HTMLElement, target: HTMLElement): void {\n target.append(...Array.from(source.childNodes))\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount annotation list\n *\n * This function analyzes the containing code block and checks for markers\n * referring to elements in the given annotation list. If no markers are found,\n * the list is left untouched. Otherwise, list elements are rendered as\n * annotations inside the code block.\n *\n * @param el - Annotation list element\n * @param container - Containing element\n * @param options - Options\n *\n * @returns Annotation component observable\n */\nexport function mountAnnotationList(\n el: HTMLElement, container: HTMLElement, { target$, print$ }: MountOptions\n): Observable> {\n\n /* Compute prefix for tooltip anchors */\n const parent = container.closest(\"[id]\")\n const prefix = parent?.id\n\n /* Find and replace all markers with empty annotations */\n const annotations = new Map()\n for (const marker of findAnnotationMarkers(container)) {\n const [, id] = marker.textContent!.match(/\\((\\d+)\\)/)!\n if (getOptionalElement(`li:nth-child(${id})`, el)) {\n annotations.set(id, renderAnnotation(id, prefix))\n marker.replaceWith(annotations.get(id)!)\n }\n }\n\n /* Keep list if there are no annotations to render */\n if (annotations.size === 0)\n return EMPTY\n\n /* Mount component on subscription */\n return defer(() => {\n const done$ = new Subject()\n\n /* Retrieve container pairs for swapping */\n const pairs: [HTMLElement, HTMLElement][] = []\n for (const [id, annotation] of annotations)\n pairs.push([\n getElement(\".md-typeset\", annotation),\n getElement(`li:nth-child(${id})`, el)\n ])\n\n /* Handle print mode - see https://bit.ly/3rgPdpt */\n print$\n .pipe(\n takeUntil(done$.pipe(takeLast(1)))\n )\n .subscribe(active => {\n el.hidden = !active\n\n /* Show annotations in code block or list (print) */\n for (const [inner, child] of pairs)\n if (!active)\n swap(child, inner)\n else\n swap(inner, child)\n })\n\n /* Create and return component */\n return merge(...[...annotations]\n .map(([, annotation]) => (\n mountAnnotation(annotation, container, { target$ })\n ))\n )\n .pipe(\n finalize(() => done$.complete()),\n share()\n )\n })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n map,\n of,\n shareReplay,\n tap\n} from \"rxjs\"\n\nimport { watchScript } from \"~/browser\"\nimport { h } from \"~/utilities\"\n\nimport { Component } from \"../../../_\"\n\nimport themeCSS from \"./index.css\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mermaid diagram\n */\nexport interface Mermaid {}\n\n/* ----------------------------------------------------------------------------\n * Data\n * ------------------------------------------------------------------------- */\n\n/**\n * Mermaid instance observable\n */\nlet mermaid$: Observable\n\n/**\n * Global sequence number for diagrams\n */\nlet sequence = 0\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Fetch Mermaid script\n *\n * @returns Mermaid scripts observable\n */\nfunction fetchScripts(): Observable {\n return typeof mermaid === \"undefined\" || mermaid instanceof Element\n ? watchScript(\"https://unpkg.com/mermaid@9.1.7/dist/mermaid.min.js\")\n : of(undefined)\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount Mermaid diagram\n *\n * @param el - Code block element\n *\n * @returns Mermaid diagram component observable\n */\nexport function mountMermaid(\n el: HTMLElement\n): Observable> {\n el.classList.remove(\"mermaid\") // Hack: mitigate https://bit.ly/3CiN6Du\n mermaid$ ||= fetchScripts()\n .pipe(\n tap(() => mermaid.initialize({\n startOnLoad: false,\n themeCSS,\n sequence: {\n actorFontSize: \"16px\", // Hack: mitigate https://bit.ly/3y0NEi3\n messageFontSize: \"16px\",\n noteFontSize: \"16px\"\n }\n })),\n map(() => undefined),\n shareReplay(1)\n )\n\n /* Render diagram */\n mermaid$.subscribe(() => {\n el.classList.add(\"mermaid\") // Hack: mitigate https://bit.ly/3CiN6Du\n const id = `__mermaid_${sequence++}`\n const host = h(\"div\", { class: \"mermaid\" })\n mermaid.mermaidAPI.render(id, el.textContent, (svg: string) => {\n\n /* Create a shadow root and inject diagram */\n const shadow = host.attachShadow({ mode: \"closed\" })\n shadow.innerHTML = svg\n\n /* Replace code block with diagram */\n el.replaceWith(host)\n })\n })\n\n /* Create and return component */\n return mermaid$\n .pipe(\n map(() => ({ ref: el }))\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n defer,\n filter,\n finalize,\n map,\n merge,\n tap\n} from \"rxjs\"\n\nimport { Component } from \"../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Details\n */\nexport interface Details {\n action: \"open\" | \"close\" /* Details state */\n reveal?: boolean /* Details is revealed */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch options\n */\ninterface WatchOptions {\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/**\n * Mount options\n */\ninterface MountOptions {\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch details\n *\n * @param el - Details element\n * @param options - Options\n *\n * @returns Details observable\n */\nexport function watchDetails(\n el: HTMLDetailsElement, { target$, print$ }: WatchOptions\n): Observable {\n let open = true\n return merge(\n\n /* Open and focus details on location target */\n target$\n .pipe(\n map(target => target.closest(\"details:not([open])\")!),\n filter(details => el === details),\n map(() => ({\n action: \"open\", reveal: true\n }) as Details)\n ),\n\n /* Open details on print and close afterwards */\n print$\n .pipe(\n filter(active => active || !open),\n tap(() => open = el.open),\n map(active => ({\n action: active ? \"open\" : \"close\"\n }) as Details)\n )\n )\n}\n\n/**\n * Mount details\n *\n * This function ensures that `details` tags are opened on anchor jumps and\n * prior to printing, so the whole content of the page is visible.\n *\n * @param el - Details element\n * @param options - Options\n *\n * @returns Details component observable\n */\nexport function mountDetails(\n el: HTMLDetailsElement, options: MountOptions\n): Observable> {\n return defer(() => {\n const push$ = new Subject()\n push$.subscribe(({ action, reveal }) => {\n el.toggleAttribute(\"open\", action === \"open\")\n if (reveal)\n el.scrollIntoView()\n })\n\n /* Create and return component */\n return watchDetails(el, options)\n .pipe(\n tap(state => push$.next(state)),\n finalize(() => push$.complete()),\n map(state => ({ ref: el, ...state }))\n )\n })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { Observable, of } from \"rxjs\"\n\nimport { renderTable } from \"~/templates\"\nimport { h } from \"~/utilities\"\n\nimport { Component } from \"../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Data table\n */\nexport interface DataTable {}\n\n/* ----------------------------------------------------------------------------\n * Data\n * ------------------------------------------------------------------------- */\n\n/**\n * Sentinel for replacement\n */\nconst sentinel = h(\"table\")\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount data table\n *\n * This function wraps a data table in another scrollable container, so it can\n * be smoothly scrolled on smaller screen sizes and won't break the layout.\n *\n * @param el - Data table element\n *\n * @returns Data table component observable\n */\nexport function mountDataTable(\n el: HTMLElement\n): Observable> {\n el.replaceWith(sentinel)\n sentinel.replaceWith(renderTable(el))\n\n /* Create and return component */\n return of({ ref: el })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n animationFrameScheduler,\n asyncScheduler,\n auditTime,\n combineLatest,\n defer,\n finalize,\n fromEvent,\n map,\n merge,\n skip,\n startWith,\n subscribeOn,\n takeLast,\n takeUntil,\n tap,\n withLatestFrom\n} from \"rxjs\"\n\nimport { feature } from \"~/_\"\nimport {\n Viewport,\n getElement,\n getElementContentOffset,\n getElementContentSize,\n getElementOffset,\n getElementSize,\n getElements,\n watchElementContentOffset,\n watchElementSize\n} from \"~/browser\"\nimport { renderTabbedControl } from \"~/templates\"\n\nimport { Component } from \"../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Content tabs\n */\nexport interface ContentTabs {\n active: HTMLLabelElement /* Active tab label */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n viewport$: Observable /* Viewport observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch content tabs\n *\n * @param el - Content tabs element\n *\n * @returns Content tabs observable\n */\nexport function watchContentTabs(\n el: HTMLElement\n): Observable {\n const inputs = getElements(\":scope > input\", el)\n const initial = inputs.find(input => input.checked) || inputs[0]\n return merge(...inputs.map(input => fromEvent(input, \"change\")\n .pipe(\n map(() => getElement(`label[for=\"${input.id}\"]`))\n )\n ))\n .pipe(\n startWith(getElement(`label[for=\"${initial.id}\"]`)),\n map(active => ({ active }))\n )\n}\n\n/**\n * Mount content tabs\n *\n * This function scrolls the active tab into view. While this functionality is\n * provided by browsers as part of `scrollInfoView`, browsers will always also\n * scroll the vertical axis, which we do not want. Thus, we decided to provide\n * this functionality ourselves.\n *\n * @param el - Content tabs element\n * @param options - Options\n *\n * @returns Content tabs component observable\n */\nexport function mountContentTabs(\n el: HTMLElement, { viewport$ }: MountOptions\n): Observable> {\n\n /* Render content tab previous button for pagination */\n const prev = renderTabbedControl(\"prev\")\n el.append(prev)\n\n /* Render content tab next button for pagination */\n const next = renderTabbedControl(\"next\")\n el.append(next)\n\n /* Mount component on subscription */\n const container = getElement(\".tabbed-labels\", el)\n return defer(() => {\n const push$ = new Subject()\n const done$ = push$.pipe(takeLast(1))\n combineLatest([push$, watchElementSize(el)])\n .pipe(\n auditTime(1, animationFrameScheduler),\n takeUntil(done$)\n )\n .subscribe({\n\n /* Handle emission */\n next([{ active }, size]) {\n const offset = getElementOffset(active)\n const { width } = getElementSize(active)\n\n /* Set tab indicator offset and width */\n el.style.setProperty(\"--md-indicator-x\", `${offset.x}px`)\n el.style.setProperty(\"--md-indicator-width\", `${width}px`)\n\n /* Scroll container to active content tab */\n const content = getElementContentOffset(container)\n if (\n offset.x < content.x ||\n offset.x + width > content.x + size.width\n )\n container.scrollTo({\n left: Math.max(0, offset.x - 16),\n behavior: \"smooth\"\n })\n },\n\n /* Handle complete */\n complete() {\n el.style.removeProperty(\"--md-indicator-x\")\n el.style.removeProperty(\"--md-indicator-width\")\n }\n })\n\n /* Hide content tab buttons on borders */\n combineLatest([\n watchElementContentOffset(container),\n watchElementSize(container)\n ])\n .pipe(\n takeUntil(done$)\n )\n .subscribe(([offset, size]) => {\n const content = getElementContentSize(container)\n prev.hidden = offset.x < 16\n next.hidden = offset.x > content.width - size.width - 16\n })\n\n /* Paginate content tab container on click */\n merge(\n fromEvent(prev, \"click\").pipe(map(() => -1)),\n fromEvent(next, \"click\").pipe(map(() => +1))\n )\n .pipe(\n takeUntil(done$)\n )\n .subscribe(direction => {\n const { width } = getElementSize(container)\n container.scrollBy({\n left: width * direction,\n behavior: \"smooth\"\n })\n })\n\n /* Set up linking of content tabs, if enabled */\n if (feature(\"content.tabs.link\"))\n push$.pipe(\n skip(1),\n withLatestFrom(viewport$)\n )\n .subscribe(([{ active }, { offset }]) => {\n const tab = active.innerText.trim()\n if (active.hasAttribute(\"data-md-switching\")) {\n active.removeAttribute(\"data-md-switching\")\n\n /* Determine viewport offset of active tab */\n } else {\n const y = el.offsetTop - offset.y\n\n /* Passively activate other tabs */\n for (const set of getElements(\"[data-tabs]\"))\n for (const input of getElements(\n \":scope > input\", set\n )) {\n const label = getElement(`label[for=\"${input.id}\"]`)\n if (\n label !== active &&\n label.innerText.trim() === tab\n ) {\n label.setAttribute(\"data-md-switching\", \"\")\n input.click()\n break\n }\n }\n\n /* Bring active tab into view */\n window.scrollTo({\n top: el.offsetTop - y\n })\n\n /* Persist active tabs in local storage */\n const tabs = __md_get(\"__tabs\") || []\n __md_set(\"__tabs\", [...new Set([tab, ...tabs])])\n }\n })\n\n /* Create and return component */\n return watchContentTabs(el)\n .pipe(\n tap(state => push$.next(state)),\n finalize(() => push$.complete()),\n map(state => ({ ref: el, ...state }))\n )\n })\n .pipe(\n subscribeOn(asyncScheduler)\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { Observable, merge } from \"rxjs\"\n\nimport { Viewport, getElements } from \"~/browser\"\n\nimport { Component } from \"../../_\"\nimport { Annotation } from \"../annotation\"\nimport {\n CodeBlock,\n Mermaid,\n mountCodeBlock,\n mountMermaid\n} from \"../code\"\nimport {\n Details,\n mountDetails\n} from \"../details\"\nimport {\n DataTable,\n mountDataTable\n} from \"../table\"\nimport {\n ContentTabs,\n mountContentTabs\n} from \"../tabs\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Content\n */\nexport type Content =\n | Annotation\n | ContentTabs\n | CodeBlock\n | Mermaid\n | DataTable\n | Details\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n viewport$: Observable /* Viewport observable */\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount content\n *\n * This function mounts all components that are found in the content of the\n * actual article, including code blocks, data tables and details.\n *\n * @param el - Content element\n * @param options - Options\n *\n * @returns Content component observable\n */\nexport function mountContent(\n el: HTMLElement, { viewport$, target$, print$ }: MountOptions\n): Observable> {\n return merge(\n\n /* Code blocks */\n ...getElements(\"pre:not(.mermaid) > code\", el)\n .map(child => mountCodeBlock(child, { target$, print$ })),\n\n /* Mermaid diagrams */\n ...getElements(\"pre.mermaid\", el)\n .map(child => mountMermaid(child)),\n\n /* Data tables */\n ...getElements(\"table:not([class])\", el)\n .map(child => mountDataTable(child)),\n\n /* Details */\n ...getElements(\"details\", el)\n .map(child => mountDetails(child, { target$, print$ })),\n\n /* Content tabs */\n ...getElements(\"[data-tabs]\", el)\n .map(child => mountContentTabs(child, { viewport$ }))\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n defer,\n delay,\n finalize,\n map,\n merge,\n of,\n switchMap,\n tap\n} from \"rxjs\"\n\nimport { getElement } from \"~/browser\"\n\nimport { Component } from \"../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Dialog\n */\nexport interface Dialog {\n message: string /* Dialog message */\n active: boolean /* Dialog is active */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch options\n */\ninterface WatchOptions {\n alert$: Subject /* Alert subject */\n}\n\n/**\n * Mount options\n */\ninterface MountOptions {\n alert$: Subject /* Alert subject */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch dialog\n *\n * @param _el - Dialog element\n * @param options - Options\n *\n * @returns Dialog observable\n */\nexport function watchDialog(\n _el: HTMLElement, { alert$ }: WatchOptions\n): Observable
