custom optional support (#2390)

* custom optional support

* Update reflect.hpp

* is_custom_field_null

* Update nullable_lambda_test.cpp

Author: stephenberry

include/glaze/beve/write.hpp

@@ -1319,6 +1319,12 @@ namespace glz
                         }
                      }
                   }
+                  else if constexpr (is_specialization_v<val_t, custom_t> && Options.skip_null_members &&
+                                     custom_getter_returns_nullable<val_t>()) {
+                     if (!is_custom_field_null<T, I>(value, t, ctx)) {
+                        ++member_count;
+                     }
+                  }
                   else {
                      ++member_count;
                   }
@@ -1385,6 +1391,12 @@ namespace glz
                         }
                      }
                   }
+                  else if constexpr (is_specialization_v<val_t, custom_t> && Options.skip_null_members &&
+                                     custom_getter_returns_nullable<val_t>()) {
+                     if (is_custom_field_null<T, I>(value, t, ctx)) {
+                        return;
+                     }
+                  }
 
                   static constexpr sv key = reflect<T>::keys[I];
                   to<BEVE, std::remove_cvref_t<decltype(key)>>::template no_header_cx<key.size()>(key, ctx, b, ix);

include/glaze/cbor/write.hpp

@@ -682,6 +682,12 @@ namespace glz
                         }
                      }
                   }
+                  else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
+                                     custom_getter_returns_nullable<val_t>()) {
+                     if (!is_custom_field_null<T, I>(value, t, ctx)) {
+                        ++member_count;
+                     }
+                  }
                   else {
                      ++member_count;
                   }
@@ -733,6 +739,12 @@ namespace glz
                         }
                      }
                   }
+                  else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
+                                     custom_getter_returns_nullable<val_t>()) {
+                     if (is_custom_field_null<T, I>(value, t, ctx)) {
+                        return;
+                     }
+                  }
 
                   static constexpr sv key = reflect<T>::keys[I];
                   // Write key as text string

include/glaze/core/reflect.hpp

@@ -380,6 +380,54 @@ namespace glz
    template <class T, size_t I>
    using field_t = std::remove_cvref_t<refl_t<T, I>>;
 
+   // Check if a custom_t getter (To) returns a nullable type
+   template <class V>
+   consteval bool custom_getter_returns_nullable()
+   {
+      if constexpr (!is_specialization_v<V, custom_t>) {
+         return false;
+      }
+      else {
+         using To = typename V::to_t;
+         using ParentT = std::remove_reference_t<decltype(std::declval<V&>().val)>;
+
+         if constexpr (std::is_member_pointer_v<To>) {
+            if constexpr (std::is_member_function_pointer_v<To>) {
+               using Ret = std::decay_t<typename return_type<To>::type>;
+               return null_t<Ret>;
+            }
+            else if constexpr (std::is_member_object_pointer_v<To>) {
+               using Value = std::decay_t<decltype(std::declval<ParentT&>().*(std::declval<To>()))>;
+               if constexpr (is_specialization_v<Value, std::function>) {
+                  using Ret = std::decay_t<typename function_traits<Value>::result_type>;
+                  return null_t<Ret>;
+               }
+               else {
+                  return null_t<Value>;
+               }
+            }
+            else {
+               return false;
+            }
+         }
+         else if constexpr (std::invocable<To, ParentT&>) {
+            using Ret = std::decay_t<std::invoke_result_t<To, ParentT&>>;
+            return null_t<Ret>;
+         }
+         else if constexpr (std::invocable<To, const ParentT&>) {
+            using Ret = std::decay_t<std::invoke_result_t<To, const ParentT&>>;
+            return null_t<Ret>;
+         }
+         else if constexpr (std::invocable<To, ParentT&, context&>) {
+            using Ret = std::decay_t<std::invoke_result_t<To, ParentT&, context&>>;
+            return null_t<Ret>;
+         }
+         else {
+            return false;
+         }
+      }
+   }
+
    template <auto Opts, class T>
    inline constexpr bool maybe_skipped = [] {
       if constexpr (reflect<T>::size > 0) {
@@ -393,7 +441,9 @@ namespace glz
             return [&]<size_t... I>(std::index_sequence<I...>) {
                return ((always_skipped<field_t<T, I>> ||
                         (!write_function_pointers && is_member_function_pointer<field_t<T, I>>) ||
-                        null_t<field_t<T, I>>) ||
+                        null_t<field_t<T, I>> ||
+                        (is_specialization_v<field_t<T, I>, custom_t> &&
+                         custom_getter_returns_nullable<field_t<T, I>>())) ||
                        ...);
             }(std::make_index_sequence<N>{});
          }
@@ -474,6 +524,68 @@ namespace glz
       return false;
    }
 
+   // Runtime check: invoke a custom_t getter and return whether the result is null
+   template <class V>
+   bool custom_getter_is_null(V&& custom_val, auto&& ctx)
+   {
+      using CV = std::remove_cvref_t<V>;
+      using To = typename CV::to_t;
+
+      auto check_null = [](auto&& result) {
+         using Ret = std::decay_t<decltype(result)>;
+         if constexpr (nullable_value_t<Ret>) {
+            return !result.has_value();
+         }
+         else {
+            return !bool(result);
+         }
+      };
+
+      if constexpr (std::is_member_pointer_v<To>) {
+         if constexpr (std::is_member_function_pointer_v<To>) {
+            return check_null((custom_val.val.*(custom_val.to))());
+         }
+         else if constexpr (std::is_member_object_pointer_v<To>) {
+            auto& to_val = custom_val.val.*(custom_val.to);
+            using Func = std::decay_t<decltype(to_val)>;
+            if constexpr (is_specialization_v<Func, std::function>) {
+               return check_null(to_val());
+            }
+            else {
+               return check_null(to_val);
+            }
+         }
+         else {
+            return false;
+         }
+      }
+      else if constexpr (std::invocable<To, decltype(custom_val.val)>) {
+         return check_null(std::invoke(custom_val.to, custom_val.val));
+      }
+      else if constexpr (std::invocable<To, decltype(custom_val.val), std::remove_reference_t<decltype(ctx)>&>) {
+         return check_null(std::invoke(custom_val.to, custom_val.val, ctx));
+      }
+      else {
+         return false;
+      }
+   }
+
+   // Check if a custom_t field at index I is null, given the parent value and tie.
+   // Used by JSON/CBOR/BEVE write paths to skip null custom getter results.
+   template <class T, size_t I, class Value, class Tie, class Ctx>
+   bool is_custom_field_null(Value&& value, Tie&& t, Ctx&& ctx)
+   {
+      decltype(auto) custom_val = [&]() -> decltype(auto) {
+         if constexpr (reflectable<T>) {
+            return get_member(value, get<I>(t));
+         }
+         else {
+            return get_member(value, get<I>(reflect<T>::values));
+         }
+      }();
+      return custom_getter_is_null(custom_val, ctx);
+   }
+
    template <class T, auto Opts>
    constexpr auto required_fields()
    {

include/glaze/json/write.hpp

@@ -2192,6 +2192,10 @@ namespace glz
                            if (is_null) return;
                         }
                      }
+                     else if constexpr (is_specialization_v<val_t, custom_t> && Opts.skip_null_members &&
+                                        custom_getter_returns_nullable<val_t>()) {
+                        if (is_custom_field_null<T, I>(value, t, ctx)) return;
+                     }
 
                      if constexpr (Opts.prettify) {
                         if (!ensure_space(ctx, b, ix + padding + ctx.depth)) [[unlikely]] {

tests/json_test/nullable_lambda_test.cpp

@@ -2,6 +2,10 @@
 // can be properly skipped when they return null values
 
 #include "glaze/glaze.hpp"
+#include "glaze/beve/read.hpp"
+#include "glaze/beve/write.hpp"
+#include "glaze/cbor/read.hpp"
+#include "glaze/cbor/write.hpp"
 #include "ut/ut.hpp"
 
 using namespace ut;
@@ -109,4 +113,131 @@ suite nullable_lambda_optional_tests = [] {
    };
 };
 
+// Test with glz::custom and optional return type (GitHub issue #2386)
+struct my_struct_custom_optional
+{
+   int value = 42;
+};
+
+template <>
+struct glz::meta<my_struct_custom_optional>
+{
+   using T = my_struct_custom_optional;
+   static constexpr auto set_status = [](T& s, std::optional<std::string> val) {
+      if (val.has_value()) {
+         s.value = 50;
+      }
+      else {
+         s.value = 0;
+      }
+   };
+   static constexpr auto get_status = [](auto& s) -> std::optional<std::string> {
+      if (s.value > 50) {
+         return "high";
+      }
+      else {
+         return std::nullopt;
+      }
+   };
+   static constexpr auto value = glz::object("value", &T::value, "status", glz::custom<set_status, get_status>);
+};
+
+suite custom_nullable_optional_tests = [] {
+   "custom getter returns nullopt - should skip field"_test = [] {
+      my_struct_custom_optional obj{};
+      obj.value = 42; // getter returns nullopt
+
+      std::string buffer;
+      expect(not glz::write_json(obj, buffer));
+
+      // The "status" field should be omitted
+      expect(buffer == R"({"value":42})") << "Got: " << buffer;
+   };
+
+   "custom getter returns optional value - should write field"_test = [] {
+      my_struct_custom_optional obj{};
+      obj.value = 100; // getter returns "high"
+
+      std::string buffer;
+      expect(not glz::write_json(obj, buffer));
+
+      // The "status" field should be present
+      expect(buffer == R"({"value":100,"status":"high"})") << "Got: " << buffer;
+   };
+
+   "custom getter with skip_null_members false"_test = [] {
+      constexpr auto opts = glz::opts{.skip_null_members = false};
+      my_struct_custom_optional obj{};
+      obj.value = 42; // getter returns nullopt
+
+      std::string buffer;
+      expect(not glz::write<opts>(obj, buffer));
+
+      // When skip_null_members is false, null should be written explicitly
+      expect(buffer == R"({"value":42,"status":null})") << "Got: " << buffer;
+   };
+};
+
+// CBOR round-trip tests for custom nullable getter
+suite custom_nullable_cbor_tests = [] {
+   "cbor custom getter nullopt - round trip"_test = [] {
+      my_struct_custom_optional src{};
+      src.value = 42; // getter returns nullopt
+
+      std::string buffer;
+      expect(not glz::write_cbor(src, buffer));
+
+      my_struct_custom_optional dst{};
+      dst.value = 99;
+      expect(not glz::read_cbor(dst, buffer));
+
+      // value should survive round-trip; status was omitted (nullopt)
+      expect(dst.value == 42);
+   };
+
+   "cbor custom getter with value - round trip"_test = [] {
+      my_struct_custom_optional src{};
+      src.value = 100; // getter returns "high"
+
+      std::string buffer;
+      expect(not glz::write_cbor(src, buffer));
+
+      my_struct_custom_optional dst{};
+      expect(not glz::read_cbor(dst, buffer));
+
+      // setter receives "high" -> sets value to 50
+      expect(dst.value == 50);
+   };
+};
+
+// BEVE round-trip tests for custom nullable getter
+suite custom_nullable_beve_tests = [] {
+   "beve custom getter nullopt - round trip"_test = [] {
+      my_struct_custom_optional src{};
+      src.value = 42; // getter returns nullopt
+
+      std::string buffer;
+      expect(not glz::write_beve(src, buffer));
+
+      my_struct_custom_optional dst{};
+      dst.value = 99;
+      expect(not glz::read_beve(dst, buffer));
+
+      expect(dst.value == 42);
+   };
+
+   "beve custom getter with value - round trip"_test = [] {
+      my_struct_custom_optional src{};
+      src.value = 100; // getter returns "high"
+
+      std::string buffer;
+      expect(not glz::write_beve(src, buffer));
+
+      my_struct_custom_optional dst{};
+      expect(not glz::read_beve(dst, buffer));
+
+      expect(dst.value == 50);
+   };
+};
+
 int main() {}