template<template< typename U, typename V, typename...Args > class ObjectType = std::map, template< typename U, typename...Args > class ArrayType = std::vector, class StringType = std::string, class BooleanType = bool, class NumberIntegerType = std::int64_t, class NumberUnsignedType = std::uint64_t, class NumberFloatType = double, template< typename U > class AllocatorType = std::allocator, template< typename T, typename SFINAE=void > class JSONSerializer = adl_serializer>
template<class ContiguousContainer , typename std::enable_if< not std::is_pointer< ContiguousContainer >::value andstd::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(std::begin(std::declval< ContiguousContainer const >()))>::iterator_category >::value, int >::type = 0>
This function reads from a container with contiguous storage of 1-byte values. Compatible container types include std::vector
, std::string
, std::array
, and std::initializer_list
. User-defined containers can be used as long as they implement random-access iterators and a contiguous storage.
- Precondition
- The container storage is contiguous. Violating this precondition yields undefined behavior. This precondition is enforced with an assertion.
-
Each element of the container has a size of 1 byte. Violating this precondition yields undefined behavior. This precondition is enforced with a static assertion.
- Warning
- There is no way to enforce all preconditions at compile-time. If the function is called with a noncompliant container and with assertions switched off, the behavior is undefined and will most likely yield segmentation violation.
- Template Parameters
-
ContiguousContainer | container type with contiguous storage |
- Parameters
-
[in] | c | container to read from |
[in] | cb | a parser callback function of type parser_callback_t which is used to control the deserialization by filtering unwanted values (optional) |
- Returns
- result of the deserialization
- Complexity
- 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 has a super-linear complexity.
- Note
- A UTF-8 byte order mark is silently ignored.
- Example
- The example below demonstrates the
parse()
function reading from a contiguous container. 8 std::vector<uint8_t> text = {
'[',
'1',
',',
'2',
',',
'3',
']',
'\0'};
12 std::cout << std::setw(4) << j_complete <<
"\n\n";
basic_json<> json
default JSON class
static basic_json parse(T(&array)[N], const parser_callback_t cb=nullptr)
deserialize from an array
Output (play with this example online): [
1,
2,
3
]
The example code above can be translated withg++ -std=c++11 -Isrc doc/examples/parse__contiguouscontainer__parser_callback_t.cpp -o parse__contiguouscontainer__parser_callback_t
- Since
- version 2.0.3
Definition at line 6484 of file json.hpp.