meta concept

include/glaze/concepts/container_concepts.hpp

@@ -67,15 +67,6 @@ namespace glz
 
    template <class Buffer>
    concept non_const_buffer = !std::is_const_v<Buffer>;
-
-   namespace detail
-   {
-      template <class T>
-      struct is_static_helper: std::false_type {};
-   }
-
-   template <class T>
-   concept is_static = detail::is_static_helper<T>::value;
 }
 
 namespace glz::detail

include/glaze/core/common.hpp

@@ -239,17 +239,20 @@ namespace glz
          (!std::same_as<std::nullptr_t, T> && std::constructible_from<std::string_view, std::decay_t<T>>) ||
          array_char_t<T>;
 
+      template <class T>
+      concept is_static_string = requires { meta<std::decay_t<T>>::glaze_static_string == true; } || std::decay_t<T>::glaze_static_string == true ;
+
       // this concept requires that T is a writeable string. It can be resized, appended to, or assigned to
       template <class T>
       concept string_t =
        str_t<T> && !string_view_t<T> &&
-                         (has_assign<T> || (resizable<T> && has_data<T>) || has_append<T>) && !is_static<T>;
+                         (has_assign<T> || (resizable<T> && has_data<T>) || has_append<T>) && !is_static_string<T>;
 
       // static string; very like `string_t`, but with a fixed max capacity
       template <class T>
-      concept static_str_t =
+      concept static_string_t =
        str_t<T> && !string_view_t<T> &&
-                         (has_assign<T> || (resizable<T> && has_data<T>) || has_append<T>) && is_static<T>;
+                         (has_assign<T> || (resizable<T> && has_data<T>) || has_append<T>) && is_static_string<T>;
 
       template <class T>
       concept char_array_t = str_t<T> && std::is_array_v<std::remove_pointer_t<std::remove_reference_t<T>>>;

include/glaze/json/read.hpp

@@ -987,7 +987,7 @@ namespace glz
       };
 
       template <class T>
-         requires(string_view_t<T> || char_array_t<T> || array_char_t<T> || static_str_t<T>)
+         requires(string_view_t<T> || char_array_t<T> || array_char_t<T> || static_string_t<T>)
       struct from<JSON, T>
       {
          template <auto Opts, class It, class End>
@@ -1027,7 +1027,7 @@ namespace glz
                }
                std::memcpy(value.data(), start, n);
                value[n] = '\0';
-            } else if constexpr (static_str_t<T>) {
+            } else if constexpr (static_string_t<T>) {
                const size_t n = it - start;
                if (n > value.size()) {
                   ctx.error = error_code::unexpected_end;

tests/json_test/json_test.cpp

@@ -9741,21 +9741,21 @@ suite array_char_tests = [] {
 };
 
 template <size_t N>
-struct naive_static_str_t
+struct naive_static_string_t
 {
    using value_type = char;
    using size_type = size_t;
 
 
-   naive_static_str_t() = default;
-   naive_static_str_t(std::string_view sv) { assign(sv.data(), sv.size()); }
+   naive_static_string_t() = default;
+   naive_static_string_t(std::string_view sv) { assign(sv.data(), sv.size()); }
    operator std::string_view() const { return std::string_view(buffer, length); }
 
    size_t size() const { return N; }
    size_t capacity() const { return N; }
    const char* data() const { return buffer; }
 
-   naive_static_str_t& assign(const char* v, size_t sz)
+   naive_static_string_t& assign(const char* v, size_t sz)
    {
       const auto bytes_to_copy = std::min(N, sz);
       length = bytes_to_copy;
@@ -9774,16 +9774,18 @@ struct naive_static_str_t
 };
 
 template <size_t N>
-struct glz::detail::is_static_helper<naive_static_str_t<N>>: std::true_type{};
+struct glz::meta<naive_static_string_t<N>> {
+ static constexpr auto glaze_static_string = true;
+};
 
-static_assert(std::constructible_from<std::string_view, std::decay_t<naive_static_str_t<3>>>);
-static_assert(glz::detail::has_assign<naive_static_str_t<3>>);
-static_assert(glz::is_static<naive_static_str_t<3>>);
-static_assert(glz::detail::static_str_t<naive_static_str_t<3>>);
+static_assert(std::constructible_from<std::string_view, std::decay_t<naive_static_string_t<3>>>);
+static_assert(glz::detail::has_assign<naive_static_string_t<3>>);
+static_assert(glz::detail::is_static_string<naive_static_string_t<3>>);
+static_assert(glz::detail::static_string_t<naive_static_string_t<3>>);
 
-suite static_str_tests = [] {
+suite static_string_tests = [] {
    "static_str<N> value"_test = [] {
-      naive_static_str_t<6> value{};
+      naive_static_string_t<6> value{};
       expect(not glz::read_json(value, R"("hello")"));
       expect(std::string_view{value} == "hello");
       expect(glz::write_json(value).value_or("error") == R"("hello")");