basic_json::parser_callback_t: Maintain state across events

[georgios-v]

Currently the parse callback method has extremely limited usability: namely to enforce a json schema with no contextual knowledge.

If the callback method could be extended to maintain any type of state across events, it could be used for a large number of extra tasks, like enforcing uniqueness for keys or values.

Take for example:

{
    "items": [
        {
            "key": "one"
        },
        {
            "key": "one"
        }
    ]
}

Currently a custom parser is required to detect the duplicate values. However maintaining a simple list of passed values could accomplish this with a single pass of the document during parsing.

So I propose to create a new type of callback with signature as:

template<typename BasicJsonType, typename ParseState>
using parser_callback_t =
    std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed, ParseState &state)>;

[nlohmann]

I'm afraid that changing parser_callback_t would break existing implementations. But can't you maintain the state inside the callback function?

[georgios-v]

The only way to maintain the state inside the callback is to use either global or static variables. both are worst choices than a double pass over the document.

Moreover, I'm not proposing to change parser_callback_t, rather add a second overloaded definition.

There are also alternatives to maintain backwards compatibility with a single definition; like a neutral default value for the new parameter, i.e. make it shared_ptr with the default being nullptr, make it std::optional with default value being std::nullopt etc...

[nlohmann]

You can maintain the state inside a functor. Here is a small example that maintains the number of seen values as state and drops every second value.

#include <iostream>
#include "json.hpp"

using json = nlohmann::json;

class callback_with_state {
  public:
    // callback matching the parser_callback_t signature
    bool operator()(int depth, json::parse_event_t event, json& parsed) {
        if (event == json::parse_event_t::value && ++count % 2 == 0) {
            return false;
        }

        return true;
    }
    
  private:
    // some state
    int count = 0;
};

int main()
{
    callback_with_state cbs;
    json j = json::parse("[1,2,3,4,5,6]", cbs);
    std::cout << j << std::endl;
}

Output:

[1,3,5]