Skipping redundant JSON objects?

[matttyson]

I'm dealing with a REST endpoint that wraps everything in a worthless response top level object wrapper.

Consider the following JSON:

{
  "response": {
    "data": "Hello, World!",
    "foo": 123,
    "bar": true
  }
}

Currently I'm doing this to get the data I want:

struct mydata {
    std::string data;
    int64_t foo;
    bool bar;
};

struct response {
    mydata stuff;
};

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

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


void parse(std::string_view buffer) {
    response resp;

    glz::parse_error pe = glz::read < glz::opts{}, response > (resp, bufer);
}

As you can see there's a superfluous response struct which really adds no value and doesn't need to be there. Is there a more elegant way to get to the real data without having to explicitly write a struct to process the response object?

Is it possible to tell Glaze to start parsing inside the response object ?

[stephenberry]

There exists glz::skip{} to simply skip values that you don't care about. The README has some basic documentation on glz::skip, but you just put in in your meta like "response", skip{}

[matttyson]

Hi Stephen, Thanks for your reply.
 
Sorry, I don't think I was very clear. I did see skip in the README. I don't want to skip over the response object. I want the contents of response, but the requirement to parse the top level response object adds a layer of indirection I don't need.

While the JSON I get sent looks like this:

{
  "response": {
    "data": "Hello, World!",
    "foo": 123,
    "bar": true
  }
}

I want to parse it as if it looks like this:

{
  "data": "Hello, World!",
  "foo": 123,
  "bar": true
}

The remote endpoint wraps the messages in a response object that doesn't really do anything of value and I'd like to start the parsing inside the response object.

That way I don't need to write the response struct in my example above and can just parse with the mydata struct.

If this isn't possible that's fine, I figured I'd ask before trying something else.

Cheers,
Matt.

[stephenberry]

Thanks for your clarification. The support you want doesn't exist right now, but I think it would be worth adding. You could parse the response to a glz::raw_json and then parse it into your sub struct, but this would require double parsing and probably isn't what you want.

[matttyson]

Not a problem. Thanks for taking the time to answer!

[justend29]

@matttyson
To avoid always having to access through member response, you could transform the expected to get the member you want:

#include <glaze/core/common.hpp>
#include <glaze/core/meta.hpp>
#include <glaze/json/read.hpp>
#include <string_view>

struct Response {
  std::string data{};
  std::int64_t foo{};
  bool bar{};
};

struct Reply {
  Response response{};
};

template <> struct glz::meta<Response> {
  using T = Response;
  static constexpr auto value = object("data", &T::data, //
                                       "foo", &T::foo,   //
                                       "bar", &T::bar    //
  );
};

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

int main() {

  constexpr std::string_view rest_reply = R"({
    "response": {
      "data": "Hello, World!",
      "foo": 123,
      "bar": true
    }
  })";
 
  // note the transform
  const auto resp =
      glz::read_json<Reply>(rest_reply).transform([](Reply&& reply) {
        return std::move(reply.response);
      });
  assert(resp.has_value());
  assert(resp->data == "Hello, World!");
  assert(resp->foo == 123u);
  assert(resp->bar == true);
}

[matttyson]

Ah, that's clever. I didn't know about transform. I'll have to look at that in more detail.

What I've noticed is the JSON I'm sent is always minified, so I can just take a string_view that chops off N bytes from the front to skip the 'response' and then 1 byte from the end to get the closing brace, which gives me what I want.

It's probably not the approach I would take for serious production code, but what I'm doing isn't serious code, so no biggie if it breaks and I have to fix it later.

EG
{"response":{"data":"Hello, World!","foo":123,"bar":true}}

Advance the pointer 12 bytes from the start, and subtract an extra byte from the length and you get.

{"data":"Hello, World!","foo":123,"bar":true}

I guess one thing that I didn't consider is that Glaze forces a 1:1 mapping between C++ structs and the JSON you're parsing. If the upstream API designer made (what I consider) to be bad choices in their API design, that propagates into my C++ code.

It's not a massive problem but it caught me by surprise when I was writing the parsers. Normally when writing simdjson I'd transform the response into something (that I considered to be) more sensible, but I got stuck on how to do that with Glaze.

[stephenberry]

I'll also note that you can use pointers to remap, so you can have Response* and the memory layout doesn't need to match the JSON. For exposing nested objects at a higher level you can use lambda functions. So, there are a number of ways to remap without having to allocate in the same layout.