Mapping with varying data types

[sm9cc]

Hello,

I'm currently working on a project that involves mapping JSON data to class/struct members. However, I've come across a few scenarios where the data types in my classes/structs don't always match the JSON structure. Instead of creating multiple classes/structs for different JSON layouts, I'm attempting to consolidate them into one structure.

I've written some example code to illustrate what I'm trying to achieve. If it's not currently possible to accomplish this, I would greatly appreciate any ideas or suggestions for a clean alternative approach. Additionally, I'm curious if there's potential for this feature to be added in the future.

Thanks in advance!

[stephenberry]

Mapping a quoted number to an integer is simple. To parse "age": "52", you just need to register your integer with glz::quoted

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

Mapping the date_of_birth is a little more complex:

struct Person {
   std::string name{};
   int age{};
   std::string city{};
   std::string residence{};
   
   void getAge(const std::string birthdateStr) {
       std::tm birthdate = {};
       std::istringstream ss(birthdateStr);
       ss >> std::get_time(&birthdate, "%d/%m/%Y");
       
       if (ss.fail()) {
          std::cout << "Failed to parse birthdate: " << birthdateStr << "\n";
       }
       
       const auto birth       = std::chrono::system_clock::from_time_t(std::mktime(&birthdate));
       const auto age_seconds = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now() - birth);
       
       age = static_cast<int>(age_seconds.count()) / (60 * 60 * 24 * 365);
   }
};

template <>
struct glz::meta<Person> {
    using T                     = Person;
    static constexpr auto value =
        glz::object(
            "name", &T::name, "full_name", &T::name,
            "age", &T::age, "years_old", &T::age, "date_of_birth", invoke<&T::getAge>(),
            "city", &T::city, "residence", &T::residence
        );
};

suite function_call = [] {
   "function_call"_test = [] {
      Person obj{};
      std::string s = R"({
            "full_name": "Brian Smith",
            "date_of_birth": ["01/01/1990"],
            "residence": "San Francisco"
        })";
      expect(!glz::read_json(obj, s));
      expect(obj.age == 33);
   };
};

Note that getAge needs to be a member function with a void return. You could also use a std::function and capture age in a lambda. The inputs right now do not support references, so I had to change the function input to const std::string, but that can probably be fixed in the future. Finally, the invoker currently expects function inputs to be in a JSON array. So, I had to add brackets [] for the code to currently work. I could add support to invoke without brackets if there is only one input.

Let me know your thoughts!

[sm9cc]

It's great to see that custom callbacks are supported.

Mapping a quoted number to an integer is simple. To parse "age": "52", you just need to register your integer with glz::quoted

Is it feasible to map both quoted and unquoted values to the same JSON key concurrently, or is there an alternative involving function templates for the callbacks? I'm currently working on deserializing JSON data from both the AUR API and Arch Repo API into the same class. However, I'm encountering challenges because the JSON formats from these APIs are quite different from each other.

In the first example, you'll notice that OutOfDate is represented as an integer (epoch time). However, in the second example, the equivalent value, flag_date, is represented as a string in (ISO format). Ultimately, my objective is to deserialize both representations into the same class with all time formats uniformly converted to std::chrono::system_clock::time_point.

The inputs right now do not support references

No problems, I can work with that!

Finally, the invoker currently expects function inputs to be in a JSON array
I could add support to invoke without brackets if there is only one input

Yes please, that would be a great help!

I hope that addressing these niche use cases won't be overly burdensome.

Originally, I was using the RapidJson library and manually parsing the JSON data. However, I encountered persistent segfaults that I couldn't resolve. So, I opted to explore deserialization using this library.

If needed, I can resort to manual parsing / using generic Json, but this approach would result in significantly slower performance and mean missing out on the benefits provided by this speedy library.

Your work is greatly appreciated, thanks again!

[sm9cc]

For more context, here is how I was originally doing this - 1 2

Thanks

[stephenberry]

I'll just note that if you can use std::variant<std::string, int>, this is also supported in glaze.

[stephenberry]

@sm9cc The latest release (1.5.0) adds a new custom read/write approach. Look at the release information or the README.md

[sm9cc]

I'll just note that if you can use std::variant<std::string, int>, this is also supported in glaze.

That is what I did end up using, thanks

@sm9cc The latest release (1.5.0) adds a new custom read/write approach. Look at the release information or the README.md

Very nice, I'll see how I can make use of that.

Anyway, I shall close this discussion as solved now and here is the full implementation of what I ended up doing - JsonMeta.hpp

Thanks for all of your help!