nlohmann::basic_json::accept¶

// (1)
template<typename InputType>
static bool accept(InputType&& i,
                   const bool ignore_comments = false);

// (2)
template<typename IteratorType>
static bool accept(IteratorType first, IteratorType last,
                   const bool ignore_comments = false);

Checks whether the input is valid JSON.

1. Reads from a compatible input.

2. Reads from a pair of character iterators

   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.

Template parameters¶

InputType

A compatible input, for instance:

• an std::istream object
• a FILE pointer
• a C-style array of characters
• a pointer to a null-terminated string of single byte characters
• a std::string
• an object obj for which begin(obj) and end(obj) produces a valid pair of iterators.

IteratorType

a compatible iterator type, for instance.

• a pair of std::string::iterator or std::vector<std::uint8_t>::iterator
• a pair of pointers such as ptr and ptr + len

Parameters¶

i (in)

Input to parse from.

ignore_comments (in)

whether comments should be ignored and treated like whitespace (true) or yield a parse error (false); (optional, false by default)

first (in)

iterator to start of character range

last (in)

iterator to end of character range

Return value¶

Whether the input is valid JSON.

Exception safety¶

Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

Complexity¶

Linear in the length of the input. The parser is a predictive LL(1) parser.

Notes¶

(1) A UTF-8 byte order mark is silently ignored.

Examples¶

#include <iostream>
#include <iomanip>
#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main()
{
    // a valid JSON text
    auto valid_text = R"(
    {
        "numbers": [1, 2, 3]
    }
    )";

    // an invalid JSON text
    auto invalid_text = R"(
    {
        "strings": ["extra", "comma", ]
    }
    )";

    std::cout << std::boolalpha
              << json::accept(valid_text) << ' '
              << json::accept(invalid_text) << '\n';
}

true false

See also¶

• parse - deserialize from a compatible input
• operator>> - deserialize from stream

Version history¶

• Added in version 3.0.0.
• Ignoring comments via ignore_comments added in version 3.9.0.