Skip to content

basic_json::sax_parse

// (1)
template <typename InputType, typename SAX>
static bool sax_parse(InputType&& i,
                      SAX* sax,
                      input_format_t format = input_format_t::json,
                      const bool strict = true,
                      const bool ignore_comments = false);

// (2)
template<class IteratorType, class SAX>
static bool sax_parse(IteratorType first, IteratorType last,
                      SAX* sax,
                      input_format_t format = input_format_t::json,
                      const bool strict = true,
                      const bool ignore_comments = false);

Read from input and generate SAX events

  1. Read from a compatible input.
  2. Read from a pair of character iterators

    The value_type of the iterator must be a 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.

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
  • an object obj for which begin(obj) and end(obj) produces a valid pair of iterators.
IteratorType
Description
SAX
Description

Parameters

i (in)
Input to parse from.
sax (in)
SAX event listener
format (in)
the format to parse (JSON, CBOR, MessagePack, or UBJSON) (optional, input_format_t::json by default), see input_format_t for more information
strict (in)
whether the input has to be consumed completely (optional, true by default)
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

return value of the last processed SAX event

Exception safety

Complexity

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.

Notes

A UTF-8 byte order mark is silently ignored.

Examples

Example

The example below demonstrates the sax_parse() function reading from string and processing the events with a user-defined SAX event consumer.

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

using json = nlohmann::json;

// a simple event consumer that collects string representations of the passed
// values; not inheriting from json::json_sax_t is not required, but can
// help not to forget a required function
class sax_event_consumer : public json::json_sax_t
{
  public:
    std::vector<std::string> events;

    bool null() override
    {
        events.push_back("value: null");
        return true;
    }

    bool boolean(bool val) override
    {
        events.push_back("value: " + std::string(val ? "true" : "false"));
        return true;
    }

    bool number_integer(number_integer_t val) override
    {
        events.push_back("value: " + std::to_string(val));
        return true;
    }

    bool number_unsigned(number_unsigned_t val) override
    {
        events.push_back("value: " + std::to_string(val));
        return true;
    }

    bool number_float(number_float_t val, const string_t& s) override
    {
        events.push_back("value: " + s);
        return true;
    }

    bool string(string_t& val) override
    {
        events.push_back("value: " + val);
        return true;
    }

    bool start_object(std::size_t elements) override
    {
        events.push_back("start: object");
        return true;
    }

    bool end_object() override
    {
        events.push_back("end: object");
        return true;
    }

    bool start_array(std::size_t elements) override
    {
        events.push_back("start: array");
        return true;
    }

    bool end_array() override
    {
        events.push_back("end: array");
        return true;
    }

    bool key(string_t& val) override
    {
        events.push_back("key: " + val);
        return true;
    }

    bool binary(json::binary_t& val) override
    {
        events.push_back("binary");
        return true;
    }

    bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex) override
    {
        events.push_back("error: " + std::string(ex.what()));
        return false;
    }
};

int main()
{
    // a JSON text
    auto text = R"(
    {
        "Image": {
            "Width":  800,
            "Height": 600,
            "Title":  "View from 15th Floor",
            "Thumbnail": {
                "Url":    "http://www.example.com/image/481989943",
                "Height": 125,
                "Width":  100
            },
            "Animated" : false,
            "IDs": [116, 943, 234, 38793],
            "Distance": 12.723374634
        }
    }
    )";

    // create a SAX event consumer object
    sax_event_consumer sec;

    // parse and serialize JSON
    bool result = json::sax_parse(text, &sec);

    // output the recorded events
    for (auto& event : sec.events)
    {
        std::cout << "(" << event << ") ";
    }

    // output the result of sax_parse
    std::cout << "\nresult: " << std::boolalpha << result << std::endl;
}

Output:

(start: object) (key: Image) (start: object) (key: Width) (value: 800) (key: Height) (value: 600) (key: Title) (value: View from 15th Floor) (key: Thumbnail) (start: object) (key: Url) (value: http://www.example.com/image/481989943) (key: Height) (value: 125) (key: Width) (value: 100) (end: object) (key: Animated) (value: false) (key: IDs) (start: array) (value: 116) (value: 943) (value: 234) (value: 38793) (end: array) (key: Distance) (value: 12.723374634) (end: object) (end: object) 
result: true

Version history

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