How to read portion object from unknown JSON string?

[sweihub]

Hi

I am reading through the README, however, I do not find an official way to read portion object from JSON string. The JSON pointer syntax dose not read a key from a unknow JSON message.

The common use case is to implement a API, we need to decide the message type, and then deserialize, for example

{
    "action": "PUT",
    "data": {
        "x": 100,
        "y": 200
    }
}

Expected way

std::string action = glz::read_json_whatever<std::string>("/path/to/action",  buffer);
if (action == "DELETE") {
    // Now we know the message type
    auto bomb = glz::read_json<bomb_t>(buffer);
}

Workaround (simdjson)

Using the simdjson on-demand API, I hope glaze can also have this.

#include <iostream>
#include "simdjson.h"

using namespace simdjson;

int main(void) {
    ondemand::parser parser;
    std::string_view action;

    std::string buffer = R"( { "action": "GET", "data": { "x": 10, "y": 200 }})";
    auto json = padded_string(buffer);
    auto request = parser.iterate(json);
    auto error = request.at_pointer("/action").get_string().get(action);

    if (action == "GET") {
        printf("TODO: deserialize with glaze as GET\n");
    }

    return 0;
}

[sweihub]

Thanks for the thoughtful reply, BTW I never know there's a glz::json_t variant.

Since I am reluctant to integrate extra JSON libraries, So I will go with string pattern matching. Different JSON messages are so common in a websocket stream, so we have to decide the message types and deserialize them.

{"action":"subscribe", "symbols": ["BTCUSDT", "ETHUSDT"]}
{"action":"trade", "data": {"symbol": "ETHUSDT", "price": "123.4","volume":100}}

Substring matching

auto buffer = "{...}";
if (buffer.starts_with("{\"action\":\"subscribe\"")) {
    auto subscribe = glz::read_json<subscribe_t>(buffer);
}

Thanks anyway, I will stay tune to the project.

[stephenberry]

@sweihub
#150 has been merged with main. This adds the ability to generally parse a targeted value.

Your example problem can now be solved as follows:

struct xy_t {
   int x{};
   int y{};
};

template <>
struct glz::meta<xy_t> {
   using T = xy_t;
   static constexpr auto value = object("x", &T::x, "y", &T::y);
};

struct bomb_t {
   xy_t data{};
};

template <>
struct glz::meta<bomb_t> {
   using T = bomb_t;
   static constexpr auto value = object("action", skip{}, "data", &T::data);
};

In use:

std::string buffer = R"( { "action": "DELETE", "data": { "x": 10, "y": 200 }})";
      
auto action = glz::get_sv_json<"/action">(buffer);

expect(action == R"("DELETE")");
if (action == R"("DELETE")") {
   auto bomb = glz::read_json<bomb_t>(buffer);
   expect(bomb.data.x == 10);
   expect(bomb.data.y == 200);
}

Notice that "action" is registered with a skip type, which tells the parser to just skip this value because you've already handled it. You could add action as a std::string to your bomb_t, and it would populate the action on parse, but this skip approach is just a bit faster if you've already handled the action.

glz::get_sv_json gets the targeted value as a std::string_view, so notice the extra quotes needed when checking the value. This is to get the best performance possible. If you wanted to check against "DELETE" as a string without quotes then you could call: auto action = glz::get_as_json<std::string, "/action">(buffer);
glz::get_as_json will actually parse into the desired type, which then would allow you to check the action as follows:

if (action == "DELETE")

I hope all this makes sense, feel free to ask questions. We'll be adding documentation for these functions in the future.

[sweihub]

#I never thought that you guys move so quickly, that really makes sense, I don't need an extra JSON library now , just stick to glaze. This is very useful for handling the JSON RPC protocol.

Discuss

1. About quotes

I agree with performance considerations, glz::get_sv_json will return a quoted string (for above case "DELETE"), since you already return a std::string_view, why not removing the quotes for convenience? Such as

void main() 
{
    auto action = R"("DELETE")";
    auto sv = std::string_view(action + 1, strlen(action) - 2);
    assert(sv == "DELETE");
    std::cout << sv << std::endl;
}

2. About name

Would you consider a more general name for glz::get_sv_json, such as glz::get_value, glz::get_raw_value... anyway, this is your decision, not a big deal. glz::get_as_json is really awsome, I will play with it asap

Thanks!

[stephenberry]

1. We don't strip the quotes because they are important to know how to parse the value in a subsequent step. This is just a string_view to a value, so it could be an entire object or array, and in those cases I don't think we would want to strip the {} or []. So, it seems to be logical to not strip the "".

2. There is actually a function called glz::get_view_json, which returns a std::span based on the buffer type. The function glz::get_sv_json just converts this span into a string_view for easier use. The reasons we append _json to these function names is that we're going to add these to the binary format as well (so we'll have glz::get_view_binary, etc.). I just think glz::get_value_json might be more confusing than glz::get_view_json, especially when we would then need to change glz::get_sv_json to something like glz::get_value_sv_json. But, if you have other naming suggests, I'm open to consider.

[sweihub]

I just tested the new feature glz::get_sv_json, now I am comfort of using it.

struct xy_t {
  int x{};
  int y{};
};

template <> struct glz::meta<xy_t> {
  using T = xy_t;
  static constexpr auto value = object("x", &T::x, "y", &T::y);
};

struct bomb_t {
    xy_t data{};
    int weight = 1000;
};

template <> struct glz::meta<bomb_t> {
  using T = bomb_t;
  static constexpr auto value = object("weight", &T::weight, "data", &T::data, "action", skip{});
};

void test_glaze() {
  std::string buffer = R"({"weight": 3000, "data": { "x": 10, "y": 200 }, "action": "DESTROY"})";

  auto action = glz::get_as_json<std::string, "/action">(buffer);
  assert(action == "DESTROY");

  if (action == "DESTROY") {
    auto bomb = glz::read_json<bomb_t>(buffer);
    assert(bomb.data.x == 10);
    assert(bomb.data.y == 200);   
    std::cout << "bomb.weight: " << bomb.weight << std::endl;    
  }
}