Add skip function for glz::meta to ignore members during write (#1846)

* Add skip function in the meta to ignore elements during write

* cleanup

* Update json_reflection_test.cpp

---------

Co-authored-by: Stephen Berry <stephenberry.developer@gmail.com>

Author: Yaraslaut

include/glaze/core/reflect.hpp

@@ -219,7 +219,11 @@ namespace glz
    inline constexpr bool maybe_skipped = [] {
       if constexpr (reflect<T>::size > 0) {
          constexpr auto N = reflect<T>::size;
-         if constexpr (Opts.skip_null_members) {
+         if constexpr (meta_has_skip<T>) {
+            // If the glz::meta provides a skip method, we assume the user wants to skip fields
+            return true;
+         }
+         else if constexpr (Opts.skip_null_members) {
             // if any type could be null then we might skip
             return []<size_t... I>(std::index_sequence<I...>) {
                return ((always_skipped<field_t<T, I>> || null_t<field_t<T, I>>) || ...);

include/glaze/json/write.hpp

@@ -1812,6 +1812,10 @@ namespace glz
                for_each<N>([&]<size_t I>() {
                   using val_t = field_t<T, I>;
 
+                  if constexpr (meta_has_skip<T>) {
+                     if constexpr (meta<T>::skip(reflect<T>::keys[I])) return;
+                  }
+                  
                   if constexpr (always_skipped<val_t>) {
                      return;
                   }
@@ -1855,7 +1859,7 @@ namespace glz
                         first = false;
                      }
                      else {
-                        // Null members may be skipped so we cant just write it out for all but the last member
+                        // Null members may be skipped so we can't just write it out for all but the last member
                         if constexpr (Opts.prettify) {
                            std::memcpy(&b[ix], ",\n", 2);
                            ix += 2;

include/glaze/reflection/get_name.hpp

@@ -123,6 +123,12 @@ namespace glz
    template <class T>
    struct meta;
 
+   // Concept when skip is specified for the type
+   template <class T>
+   concept meta_has_skip = requires(T t, const std::string_view s) {
+      { glz::meta<std::remove_cvref_t<T>>::skip(s) } -> std::same_as<bool>;
+   };
+
    // Concept for when rename_key returns exactly std::string (allocates)
    template <class T>
    concept meta_has_rename_key_string = requires(T t, const std::string_view s) {

tests/json_reflection_test/json_reflection_test.cpp

@@ -19,6 +19,21 @@ static_assert(glz::reflectable<my_struct>);
 
 static_assert(glz::name_v<my_struct> == "my_struct");
 
+static_assert(glz::meta_has_skip<my_struct> == false);
+
+struct test_skip
+{
+};
+
+template <>
+   struct glz::meta<test_skip>
+   {
+      static constexpr bool skip(const std::string_view) { return true; }
+   };
+
+
+static_assert(glz::meta_has_skip<test_skip>);
+
 suite reflection = [] {
    "reflect_write"_test = [] {
       std::string buffer = R"({"i":287,"d":3.14,"hello":"Hello World","arr":[1,2,3]})";

tests/json_test/json_test.cpp

@@ -9104,6 +9104,68 @@ suite skip_tests = [] {
    };
 };
 
+struct specify_only_skip_obj
+{
+   int i{1};
+   int j{2};
+   int k{3};
+};
+
+template <>
+struct glz::meta<specify_only_skip_obj>
+{
+   static constexpr bool skip(const std::string_view key) { return key == "j"; }
+};
+
+suite specify_only_skip_obj_tests = [] {
+   "skip_only_one"_test = [] {
+      specify_only_skip_obj obj{};
+      expect(glz::write_json(obj) == R"({"i":1,"k":3})") << glz::write_json(obj).value();
+   };
+};
+
+struct skip_hidden_elements
+{
+   int i{1};
+   int hidden_j{2};
+   int hidden_k{3};
+   int l{4};
+};
+
+template <>
+struct glz::meta<skip_hidden_elements>
+{
+   static constexpr bool skip(const std::string_view key) { return key.starts_with(std::string_view{"hidden"}); }
+};
+
+suite skip_hidden_elements_tests = [] {
+   "skip_hidden_elements"_test = [] {
+      skip_hidden_elements obj{};
+      expect(glz::write_json(obj) == R"({"i":1,"l":4})") << glz::write_json(obj).value();
+   };
+};
+
+struct skip_first_and_last
+{
+   int i{1};
+   int hidden_j{2};
+   int hidden_k{3};
+   int l{4};
+};
+
+template <>
+struct glz::meta<skip_first_and_last>
+{
+   static constexpr bool skip(const std::string_view key) { return key == "i" || key == "l"; }
+};
+
+suite skip_first_and_last_tests = [] {
+   "skip_first_and_last_tests"_test = [] {
+      skip_first_and_last obj{};
+      expect(glz::write_json(obj) == R"({"hidden_j":2,"hidden_k":3})") << glz::write_json(obj).value();
+   };
+};
+
 template <size_t N>
 struct FixedName
 {