problem with 'null' values

[scalpel4k]

I have the following code

struct A{
 std::optional<int> i;
};

struct B {
 A a;
};

auto toString() {
  B b;
  return glz::write<glz::opts{
        .format = glz::JSON, .skip_null_members = 1, .prettify = 1, .validate_skipped = 0}>(b);
}

struct A has a custom serializer that extracts the value of A::i, so the result should look like this

{ "a" : 1 }

So far so good, this is working. But when A::i has no value I want the entry to be skipped, so I'm using .skip_null_members = 1 as an option to the write method. However, I always end up getting an entry with a 'null' value.

I know the problem comes from the combination of those 2 objects. Is there a way to eliminate empty values right in the custom serializers?

thx Michi

[scalpel4k]

@stephenberry I've tried to understand the problem a bit better. When running my code in question I can see that the serializer calls the custom writer from the branch where object_info.maybe_skipped is false (write.hpp line 1570, version 4.0.1).

I can't (want to) make my wrapper optional because it would make the API of my data classes quite clunky.

Instead I was thinking if it would be possible to introduce a setting in the glz::meta<> where the user could specify some of the glz::opts like maybe_skipped or error_on_unknown_keys

Do you thinks that this could be a solution for the problem?

thx Michi

[stephenberry]

Hmm, care to explain the method redefinition a bit more?

[scalpel4k]

A minimum example could look like this

template<KvpSchema S>
struct KVP {
  operator typename S::type_t() {
    return val.value();
  }

  operator bool() {
    return val.has_value();
  }

  std::optional<S::type_t> val;
};

S::type_t can be all sorts of things, also bool ....

[stephenberry]

Oh, interesting. What function do you normally use to check for a value, something like has_value()? We could potentially make a concept for a different API than a typical nullable type in C++.

[scalpel4k]

now we're talking ;-)

Personally I think that glz::meta would be the perfect place to specify things like that.

What do you think about this?

template<>
struct meta<T>
{
    static constexpr auto maybe_skipped = true;
};

Of course, making a concept that requires has_value() could also be used .... And yes, I currently have a has_value() method.

[stephenberry]

The glz::meta shouldn't be necessary. If we can just determine that the custom type is nullable, how to check for nullability, and how to get the value, then we should be good.

I think this pull request adds what you need: #1460

There are some basic unit tests to show similar behavior to what you have. Let me know your thoughts. You could try using this branch on your code.