Improve compilation performance and cleanup (#1512)

* Faster compile time contains

* Remove old invalid test code

* support for meta_keys objects

* Faster compilation of glz::detail::schematic

* Use normal `for` loop

* Remove now unused tuple_ptr code

* Use std::array rather than std::vector

* Revert "Use std::array rather than std::vector"

This reverts commit 43b0aec.

* reserve memory

* Note on using vector rather than array

* Removing more old map handling code

* formatting

* Remove make_map usage

* More removal of make_map

* Removing make_map for flags_t

Author: stephenberry

include/glaze/beve/write.hpp

@@ -874,14 +874,18 @@ namespace glz
 
                   static constexpr auto key = get<0>(group);
                   static constexpr auto sub_partial = get<1>(group);
-                  static constexpr auto frozen_map = detail::make_map<T>();
-                  static constexpr auto member_it = frozen_map.find(key);
-                  static_assert(member_it != frozen_map.end(), "Invalid key passed to partial write");
-                  static constexpr auto index = member_it->second.index();
-                  static constexpr decltype(auto) element = get<index>(member_it->second);
-
-                  detail::write<BEVE>::no_header<Opts>(key, ctx, b, ix);
-                  write_partial<BEVE>::op<sub_partial, Opts>(glz::get_member(value, element), ctx, b, ix);
+                  static constexpr auto index = key_index<T>(key);
+                  static_assert(index < reflect<T>::size, "Invalid key passed to partial write");
+                  
+                  if constexpr (glaze_object_t<T>) {
+                     static constexpr auto member = get<index>(reflect<T>::values);
+                     detail::write<BEVE>::no_header<Opts>(key, ctx, b, ix);
+                     write_partial<BEVE>::op<sub_partial, Opts>(get_member(value, member), ctx, b, ix);
+                  }
+                  else {
+                     detail::write<BEVE>::no_header<Opts>(key, ctx, b, ix);
+                     write_partial<BEVE>::op<sub_partial, Opts>(get_member(value, get<index>(to_tuple(value))), ctx, b, ix);
+                  }
                });
             }
             else if constexpr (writable_map_t<T>) {

include/glaze/core/common.hpp

@@ -372,7 +372,7 @@ namespace glz
       concept glaze_array_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Array>;
 
       template <class T>
-      concept glaze_object_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Object>;
+      concept glaze_object_t = glaze_t<T> && (is_specialization_v<meta_wrapper_t<T>, Object> || (not std::is_enum_v<std::decay_t<T>> && meta_keys<T>));
 
       template <class T>
       concept glaze_enum_t = glaze_t<T> && is_specialization_v<meta_wrapper_t<T>, Enum>;
@@ -387,7 +387,7 @@ namespace glz
       template <class T>
       concept reflectable = std::is_aggregate_v<std::remove_cvref_t<T>> && std::is_class_v<std::remove_cvref_t<T>> &&
                             !(is_no_reflect<T> || glaze_value_t<T> || glaze_object_t<T> || glaze_array_t<T> ||
-                              glaze_flags_t<T> || range<T> || pair_t<T> || null_t<T>);
+                              glaze_flags_t<T> || range<T> || pair_t<T> || null_t<T> || meta_keys<T>);
 
       template <class T>
       concept is_memory_object = is_memory_type<T> && (glaze_object_t<memory_type<T>> || reflectable<memory_type<T>>);

include/glaze/core/meta.hpp

@@ -140,7 +140,14 @@ namespace glz
    }();
 
    template <class T>
-   inline constexpr auto meta_v = meta_wrapper_v<decay_keep_volatile_t<T>>.value;
+   inline constexpr auto meta_v = []() -> decltype(auto) {
+      if constexpr (detail::meta_keys<T>) {
+         return meta_wrapper_v<decay_keep_volatile_t<T>>;
+      }
+      else {
+         return meta_wrapper_v<decay_keep_volatile_t<T>>.value;
+      }
+   }();
 
    template <class T>
    using meta_t = decay_keep_volatile_t<decltype(meta_v<T>)>;

include/glaze/core/reflect.hpp

@@ -13,62 +13,6 @@
 #pragma warning(disable : 4100 4189)
 #endif
 
-namespace glz::detail
-{
-   // We create const and not-const versions for when our reflected struct is const or non-const qualified
-   template <class Tuple>
-   struct tuple_ptr;
-
-   template <class... Ts>
-   struct tuple_ptr<tuplet::tuple<Ts...>>
-   {
-      using type = tuplet::tuple<std::add_pointer_t<std::remove_reference_t<Ts>>...>;
-   };
-
-   template <class Tuple>
-   struct tuple_ptr_const;
-
-   template <class... Ts>
-   struct tuple_ptr_const<tuplet::tuple<Ts...>>
-   {
-      using type = tuplet::tuple<std::add_pointer_t<std::add_const_t<std::remove_reference_t<Ts>>>...>;
-   };
-
-   // This is needed to hack a fix for MSVC evaluating wrong `if constexpr` branches
-   template <class T>
-      requires(!reflectable<T>)
-   constexpr auto make_tuple_from_struct() noexcept
-   {
-      return glz::tuplet::tuple{};
-   }
-
-   // This needs to produce const qualified pointers so that we can write out const structs
-   template <reflectable T>
-   constexpr auto make_tuple_from_struct() noexcept
-   {
-      using V = decay_keep_volatile_t<decltype(to_tuple(std::declval<T>()))>;
-      return typename tuple_ptr<V>::type{};
-   }
-
-   template <reflectable T>
-   constexpr auto make_const_tuple_from_struct() noexcept
-   {
-      using V = decay_keep_volatile_t<decltype(to_tuple(std::declval<T>()))>;
-      return typename tuple_ptr_const<V>::type{};
-   }
-
-   template <reflectable T, class TuplePtrs>
-      requires(!std::is_const_v<TuplePtrs>)
-   constexpr void populate_tuple_ptr(T&& value, TuplePtrs& tuple_of_ptrs) noexcept
-   {
-      // we have to populate the pointers in the reflection tuple from the structured binding
-      auto t = to_tuple(std::forward<T>(value));
-      [&]<size_t... I>(std::index_sequence<I...>) {
-         ((get<I>(tuple_of_ptrs) = &get<I>(t)), ...);
-      }(std::make_index_sequence<count_members<T>>{});
-   }
-}
-
 namespace glz
 {
    // Get indices of elements satisfying a predicate
@@ -246,8 +190,6 @@ namespace glz
       using V = std::remove_cvref_t<T>;
       using tuple = decay_keep_volatile_t<decltype(to_tuple(std::declval<T>()))>;
 
-      // static constexpr auto values = typename detail::tuple_ptr<tuple>::type{};
-
       static constexpr auto keys = member_names<V>;
       static constexpr auto size = keys.size();
 
@@ -528,15 +470,6 @@ namespace glz::detail
       constexpr auto indices = std::make_index_sequence<reflect<T>::size>{};
       return make_map_impl<decay_keep_volatile_t<T>, use_hash_comparison>(indices);
    }
-
-   template <class T>
-   constexpr auto make_key_int_map()
-   {
-      constexpr auto N = reflect<T>::size;
-      return [&]<size_t... I>(std::index_sequence<I...>) {
-         return normal_map<sv, size_t, reflect<T>::size>(pair<sv, size_t>{reflect<T>::keys[I], I}...);
-      }(std::make_index_sequence<N>{});
-   }
 }
 
 namespace glz
@@ -705,18 +638,6 @@ namespace glz
          constexpr auto indices = std::make_index_sequence<count_members<T>>{};
          return make_reflection_map_impl<decay_keep_volatile_t<T>, use_hash_comparison>(indices);
       }
-
-      template <reflectable T>
-      GLZ_ALWAYS_INLINE constexpr void populate_map(T&& value, auto& cmap) noexcept
-      {
-         // we have to populate the pointers in the reflection map from the structured binding
-         auto t = to_tuple(std::forward<T>(value));
-         [&]<size_t... I>(std::index_sequence<I...>) {
-            ((get<std::add_pointer_t<decay_keep_volatile_t<decltype(get<I>(t))>>>(get<I>(cmap.items).second) =
-                 &get<I>(t)),
-             ...);
-         }(std::make_index_sequence<count_members<T>>{});
-      }
    }
 }
 
@@ -785,7 +706,12 @@ namespace glz::detail
          using V = decay_keep_volatile_t<std::variant_alternative_t<I, T>>;
          if constexpr (glaze_object_t<V> || reflectable<V> || is_memory_object<V>) {
             using X = std::conditional_t<is_memory_object<V>, memory_type<V>, V>;
-            for_each<reflect<X>::size>([&](auto J) { deduction_map.find(reflect<X>::keys[J])->second[I] = true; });
+            constexpr auto Size = reflect<X>::size;
+            if constexpr (Size > 0) {
+               for (size_t J = 0; J < Size; ++J) {
+                  deduction_map.find(reflect<X>::keys[J])->second[I] = true;
+               }
+            }
          }
       });
 
@@ -795,6 +721,18 @@ namespace glz::detail
 
 namespace glz::detail
 {
+   template <class T>
+   consteval size_t key_index(const std::string_view key)
+   {
+      const auto n = reflect<T>::keys.size();
+      for (size_t i = 0; i < n; ++i) {
+         if (key == reflect<T>::keys[i]) {
+            return i;
+         }
+      }
+      return n;
+   }
+   
    GLZ_ALWAYS_INLINE constexpr uint64_t bitmix(uint64_t h, const uint64_t seed) noexcept
    {
       h *= seed;
@@ -851,7 +789,10 @@ namespace glz::detail
          return {};
       }
 
+      // This could be a std::array, but each length N for std::array causes unique template instaniations
+      // This propagates to std::ranges::sort, so using std::vector means less template instaniations
       std::vector<std::string_view> strings{};
+      strings.reserve(N);
       for (size_t i = 0; i < N; ++i) {
          strings.emplace_back(input_strings[i]);
       }
@@ -1262,7 +1203,7 @@ namespace glz::detail
                   break;
                }
                const auto bucket = hash % bsize;
-               if (contains(std::span{bucket_index.data(), index}, bucket)) {
+               if (contains(bucket_index.data(), index, bucket)) {
                   break;
                }
                bucket_index[index] = bucket;
@@ -1272,7 +1213,7 @@ namespace glz::detail
             if (index == N) {
                // make sure the seed does not collide with any hashes
                const auto bucket = seed % bsize;
-               if (not contains(std::span{bucket_index.data(), N}, bucket)) {
+               if (not contains(bucket_index.data(), N, bucket)) {
                   return; // found working seed
                }
             }
@@ -1421,7 +1362,7 @@ namespace glz::detail
                      break;
                   }
                   const auto bucket = hash % bsize;
-                  if (contains(std::span{bucket_index.data(), index}, bucket)) {
+                  if (contains(bucket_index.data(), index, bucket)) {
                      break;
                   }
                   bucket_index[index] = bucket;
@@ -1431,7 +1372,7 @@ namespace glz::detail
                if (index == N) {
                   // make sure the seed does not collide with any hashes
                   const auto bucket = seed % bsize;
-                  if (not contains(std::span{bucket_index.data(), N}, bucket)) {
+                  if (not contains(bucket_index.data(), N, bucket)) {
                      return; // found working seed
                   }
                }
@@ -1466,7 +1407,7 @@ namespace glz::detail
                      break;
                   }
                   const auto bucket = hash % bsize;
-                  if (contains(std::span{bucket_index.data(), index}, bucket)) {
+                  if (contains(bucket_index.data(), index, bucket)) {
                      break;
                   }
                   bucket_index[index] = bucket;
@@ -1476,7 +1417,7 @@ namespace glz::detail
                if (index == N) {
                   // make sure the seed does not collide with any hashes
                   const auto bucket = seed % bsize;
-                  if (not contains(std::span{bucket_index.data(), N}, bucket)) {
+                  if (not contains(bucket_index.data(), N, bucket)) {
                      return; // found working seed
                   }
                }
@@ -1508,7 +1449,7 @@ namespace glz::detail
                      break;
                   }
                   const auto bucket = hash % bsize;
-                  if (contains(std::span{bucket_index.data(), index}, bucket)) {
+                  if (contains(bucket_index.data(), index, bucket)) {
                      break;
                   }
                   bucket_index[index] = bucket;
@@ -1518,7 +1459,7 @@ namespace glz::detail
                if (index == N) {
                   // make sure the seed does not collide with any hashes
                   const auto bucket = seed % bsize;
-                  if (not contains(std::span{bucket_index.data(), N}, bucket)) {
+                  if (not contains(bucket_index.data(), N, bucket)) {
                      return; // found working seed
                   }
                }
@@ -1542,7 +1483,7 @@ namespace glz::detail
 
    template <class T>
    constexpr auto hash_info = [] {
-      if constexpr ((glaze_object_t<T> || reflectable<T> ||
+      if constexpr ((glaze_object_t<T> || reflectable<T> || glaze_flags_t<T> ||
                      ((std::is_enum_v<std::remove_cvref_t<T>> && meta_keys<T>) || glaze_enum_t<T>)) &&
                     (reflect<T>::size > 0)) {
          constexpr auto& k_info = keys_info<T>;

include/glaze/core/seek.hpp

@@ -533,48 +533,40 @@ namespace glz
       return arrs;
    }
 
-   template <class T, string_literal key_str>
-   struct member_getter
-   {
-      static constexpr auto frozen_map = detail::make_map<T>();
-      static constexpr auto member_it = frozen_map.find(key_str.sv());
-   };
-
    // TODO support custom types
-   template <class Root_t, string_literal ptr, class Expected_t = void>
+   template <class Root, string_literal ptr, class Expected = void>
    constexpr bool valid()
    {
-      using V = std::decay_t<Root_t>;
+      using V = std::decay_t<Root>;
       if constexpr (ptr.sv() == sv{""}) {
-         return std::same_as<Expected_t, void> || std::same_as<V, Expected_t>;
+         return std::same_as<Expected, void> || std::same_as<V, Expected>;
       }
       else {
          constexpr auto tokens = tokenize_json_ptr(ptr.sv());
          constexpr auto key_str = tokens.first;
          constexpr auto rem_ptr = glz::string_literal_from_view<tokens.second.size()>(tokens.second);
          if constexpr (glz::detail::glaze_object_t<V>) {
-            constexpr auto string_literal_key = glz::string_literal_from_view<key_str.size()>(key_str);
-            using G = member_getter<V, string_literal_key>;
-            if constexpr (G::member_it != G::frozen_map.end()) {
-               constexpr auto& element = G::member_it->second;
-               constexpr auto I = element.index();
-               constexpr auto& member_ptr = get<I>(element);
-
-               using mptr_t = std::decay_t<decltype(member_ptr)>;
-               using T = member_t<V, mptr_t>;
+            constexpr auto& HashInfo = detail::hash_info<V>;
+            constexpr auto I = detail::decode_hash_with_size<JSON, V, HashInfo, HashInfo.type>::op(key_str.data(), key_str.data() + key_str.size(), key_str.size());
+            
+            if constexpr (I < reflect<V>::size) {
+               if constexpr (key_str != reflect<V>::keys[I]) {
+                  return false;
+               }
+               using T = refl_t<V, I>;
                if constexpr (is_specialization_v<T, includer>) {
-                  return valid<file_include, rem_ptr, Expected_t>();
+                  return valid<file_include, rem_ptr, Expected>();
                }
                else {
-                  return valid<T, rem_ptr, Expected_t>();
+                  return valid<T, rem_ptr, Expected>();
                }
             }
             else {
                return false;
             }
          }
          else if constexpr (glz::detail::writable_map_t<V>) {
-            return valid<typename V::mapped_type, rem_ptr, Expected_t>();
+            return valid<typename V::mapped_type, rem_ptr, Expected>();
          }
          else if constexpr (glz::detail::glaze_array_t<V>) {
             constexpr auto member_array = glz::detail::make_array<std::decay_t<V>>();
@@ -585,7 +577,7 @@ namespace glz
                   constexpr auto member = member_array[index];
                   constexpr auto member_ptr = std::get<member.index()>(member);
                   using sub_t = decltype(glz::get_member(std::declval<V>(), member_ptr));
-                  return valid<sub_t, rem_ptr, Expected_t>();
+                  return valid<sub_t, rem_ptr, Expected>();
                }
                else {
                   return false;
@@ -597,13 +589,13 @@ namespace glz
          }
          else if constexpr (glz::detail::array_t<V>) {
             if (glz::detail::stoui(key_str)) {
-               return valid<range_value_t<V>, rem_ptr, Expected_t>();
+               return valid<range_value_t<V>, rem_ptr, Expected>();
             }
             return false;
          }
          else if constexpr (glz::detail::nullable_t<V>) {
             using sub_t = decltype(*std::declval<V>());
-            return valid<sub_t, ptr, Expected_t>();
+            return valid<sub_t, ptr, Expected>();
          }
          else {
             return false;