entity: get rid of field grouping feature

It wasn't implemented anyway.

5 files changed, 10 insertions, 48 deletions

diff --git a/entity/accessor.hpp b/entity/accessor.hpp
index 1a0e8b73..3a25cd22 100644
--- a/entity/accessor.hpp
+++ b/entity/accessor.hpp
@@ -25,7 +25,6 @@ struct erased_accessor final {
     using predicate_t = void;
     using c_range_t = void;
     using c_length_t = void;
-    using c_group_t = void;
     using Object = void;
     using Value = void;
 
@@ -34,7 +33,6 @@ struct erased_accessor final {
     const predicate_t* predicate = nullptr;
     const c_range_t* range = nullptr;
     const c_length_t* length = nullptr;
-    const c_group_t* group = nullptr;
 
     StringView field_name, object_type, field_type;
     void(*read_fun)(const Object*, const reader_t*, Value*) = nullptr;
@@ -42,24 +40,22 @@ struct erased_accessor final {
     field_status(*predicate_fun)(const Object*, const predicate_t*) = nullptr;
     erased_constraints::range(*range_fun)(const Object*, const c_range_t*) = nullptr;
     erased_constraints::max_length(*length_fun)(const Object*, const c_length_t*) = nullptr;
-    erased_constraints::group(*group_fun)(const Object*, const c_group_t*) = nullptr;
 
     explicit constexpr erased_accessor() noexcept = default;
     constexpr erased_accessor(const erased_accessor&) = default;
     constexpr erased_accessor(const reader_t* reader, const writer_t* writer, const predicate_t* predicate,
-                              const c_range_t* range, const c_length_t* length, const c_group_t* group,
+                              const c_range_t* range, const c_length_t* length,
                               StringView field_name, StringView object_name, StringView field_type_name,
                               void(*read_fun)(const Object*, const reader_t*, Value*),
                               void(*write_fun)(Object*, const writer_t*, Value*),
                               field_status(*predicate_fun)(const Object*, const predicate_t*),
                               erased_constraints::range(*range_fun)(const Object*, const c_range_t*),
-                              erased_constraints::max_length(*length_fun)(const Object*, const c_length_t*),
-                              erased_constraints::group(*group_fun)(const Object*, const c_group_t*)) :
+                              erased_constraints::max_length(*length_fun)(const Object*, const c_length_t*)) :
         reader{reader}, writer{writer}, predicate{predicate},
-        range{range}, length{length}, group{group},
+        range{range}, length{length},
         field_name{field_name}, object_type{object_name}, field_type{field_type_name},
         read_fun{read_fun}, write_fun{write_fun}, predicate_fun{predicate_fun},
-        range_fun{range_fun}, length_fun{length_fun}, group_fun{group_fun}
+        range_fun{range_fun}, length_fun{length_fun}
     {}
 
     template<typename T, typename FieldType>
@@ -86,7 +82,6 @@ struct erased_accessor final {
     inline bool can_write() const noexcept { return writer != nullptr; }
     inline erased_constraints::range get_range(const void* x) const noexcept;
     inline erased_constraints::max_length get_max_length(const void* x) const noexcept;
-    inline erased_constraints::group get_group(const void* x) const noexcept;
 };
 
 template<typename T, typename FieldType>
@@ -174,7 +169,6 @@ void erased_accessor::write(Obj& x, move_qualified<FieldType> value) const noexc
 field_status erased_accessor::is_enabled(const void* x) const noexcept { return predicate_fun(x, predicate); }
 erased_constraints::range erased_accessor::get_range(const void* x) const noexcept { return range_fun(x,range); }
 erased_constraints::max_length erased_accessor::get_max_length(const void* x) const noexcept { return length_fun(x,length); }
-erased_constraints::group erased_accessor::get_group(const void* x) const noexcept { return group_fun(x, group); }
 
 template<typename T> void get_erased_accessors(std::vector<erased_accessor>& ret);
 
diff --git a/entity/constraints.hpp b/entity/constraints.hpp
index 19ca37b2..6ebf2d90 100644
--- a/entity/constraints.hpp
+++ b/entity/constraints.hpp
@@ -40,6 +40,5 @@ template<> struct range<String>
 };
 
 using max_length = erased_constraints::max_length;
-using group = erased_constraints::group;
 
 } // namespace floormat::entities::constraints
diff --git a/entity/erased-constraints.hpp b/entity/erased-constraints.hpp
index 4d38f456..af050bd6 100644
--- a/entity/erased-constraints.hpp
+++ b/entity/erased-constraints.hpp
@@ -16,13 +16,13 @@ struct range final
     union element {
         float f;
         U u;
-        I i;
+        I i = 0;
         Math::Vector4<float> f4;
         Math::Vector4<U> u4;
         Math::Vector4<I> i4;
     };
 
-    element min {.i = 0}, max {.i = 0};
+    element min, max;
     type_ type = type_none;
 
     template<typename T> std::pair<T, T> convert() const;
@@ -34,11 +34,4 @@ struct max_length final {
     constexpr operator size_t() const { return value; }
 };
 
-struct group final {
-    StringView group_name;
-    constexpr operator StringView() const { return group_name; }
-    constexpr group() = default;
-    constexpr group(StringView name) : group_name{name} {}
-};
-
 } // namespace floormat::entities::erased_constraints
diff --git a/entity/metadata.hpp b/entity/metadata.hpp
index eece486f..8b1717b8 100644
--- a/entity/metadata.hpp
+++ b/entity/metadata.hpp
@@ -85,20 +85,16 @@ private:
     static constexpr auto default_predicate = constantly(field_status::enabled);
     static constexpr auto default_c_range   = constantly(constraints::range<Type>{});
     static constexpr auto default_c_length  = constantly(constraints::max_length{size_t(-1)});
-    static constexpr auto default_c_group   = constantly(StringView{});
     using default_predicate_t = std::decay_t<decltype(default_predicate)>;
     using default_c_range_t   = std::decay_t<decltype(default_c_range)>;
     using default_c_length_t  = std::decay_t<decltype(default_c_length)>;
-    using default_c_group_t   = std::decay_t<decltype(default_c_group)>;
     using c_predicate = detail::find_reader<Obj, field_status, default_predicate_t, 0, Ts...>;
     using c_range  = detail::find_reader<Obj, constraints::range<Type>, default_c_range_t, 0, Ts...>;
     using c_length = detail::find_reader<Obj, constraints::max_length, default_c_length_t, 0, Ts...>;
-    using c_group  = detail::find_reader<Obj, constraints::group, default_c_group_t, 0, Ts...>;
     static constexpr size_t good_arguments =
         unsigned(c_predicate::index != sizeof...(Ts)) +
         unsigned(c_range::index != sizeof...(Ts)) +
-        unsigned(c_length::index != sizeof...(Ts)) +
-        unsigned(c_group::index != sizeof...(Ts));
+        unsigned(c_length::index != sizeof...(Ts));
     static_assert(sizeof...(Ts) == good_arguments, "ignored arguments");
 
 public:
@@ -109,7 +105,6 @@ public:
     using Predicate  = typename c_predicate::type;
     using Range      = typename c_range::type;
     using Length     = typename c_length::type;
-    using Group      = typename c_group::type;
 
     StringView name;
     [[no_unique_address]] R reader;
@@ -117,7 +112,6 @@ public:
     [[no_unique_address]] Predicate predicate;
     [[no_unique_address]] Range range;
     [[no_unique_address]] Length length;
-    [[no_unique_address]] Group group;
 
     fm_DECLARE_DEFAULT_MOVE_COPY_ASSIGNMENTS(entity_field);
 
@@ -134,15 +128,12 @@ public:
     constexpr constraints::range<Type> get_range(const Obj& x) const { return get_range(range, x); }
     static constexpr constraints::max_length get_max_length(const Length& l, const Obj& x);
     constexpr constraints::max_length get_max_length(const Obj& x) const { return get_max_length(length, x); }
-    static constexpr constraints::group get_group(const Group& g, const Obj& x);
-    constexpr constraints::group get_group(const Obj& x) const { return get_group(group, x); }
 
     constexpr entity_field(StringView name, R r, W w, Ts&&... ts) noexcept :
         name{name}, reader{r}, writer{w},
         predicate { std::get<c_predicate::index>(std::forward_as_tuple(ts..., default_predicate)) },
         range     { std::get<c_range::index>    (std::forward_as_tuple(ts..., default_c_range))   },
-        length    { std::get<c_length::index>   (std::forward_as_tuple(ts..., default_c_length))  },
-        group     { std::get<c_group::index>    (std::forward_as_tuple(ts..., default_c_group))   }
+        length    { std::get<c_length::index>   (std::forward_as_tuple(ts..., default_c_length))  }
     {}
     constexpr erased_accessor erased() const;
 };
@@ -161,7 +152,6 @@ constexpr erased_accessor entity_field<Obj, Type, R, W, Ts...>::erased() const
     using predicate_t = typename erased_accessor::predicate_t;
     using c_range_t   = typename erased_accessor::c_range_t;
     using c_length_t  = typename erased_accessor::c_length_t;
-    using c_group_t   = typename erased_accessor::c_group_t;
     constexpr auto obj_name = name_of<Obj>, field_name = name_of<Type>;
 
     constexpr auto reader_fn = [](const void* obj, const reader_t* reader, void* value) {
@@ -192,18 +182,14 @@ constexpr erased_accessor entity_field<Obj, Type, R, W, Ts...>::erased() const
     constexpr auto c_length_fn = [](const void* obj, const c_length_t* reader) -> erased_constraints::max_length {
         return get_max_length(*reinterpret_cast<const Length*>(reader), *reinterpret_cast<const Obj*>(obj));
     };
-    constexpr auto c_group_fn = [](const void* obj, const c_group_t* reader) -> erased_constraints::group {
-        return get_group(*reinterpret_cast<const Group*>(reader), *reinterpret_cast<const Obj*>(obj));
-    };
-
     return erased_accessor {
         (void*)&reader, has_writer ? (void*)&writer : nullptr,
         (void*)&predicate,
-        (void*)&range, (void*)&length, (void*)&group,
+        (void*)&range, (void*)&length,
         name, obj_name, field_name,
         reader_fn, has_writer ? writer_fn : writer_stub_fn,
         predicate_fn,
-        c_range_fn, c_length_fn, c_group_fn,
+        c_range_fn, c_length_fn,
     };
 }
 
@@ -219,10 +205,6 @@ template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj,
 constexpr constraints::max_length entity_field<Obj, Type, R, W, Ts...>::get_max_length(const Length& l, const Obj& x)
 { return detail::read_field<Obj, constraints::max_length , Length>::read(x, l); }
 
-template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts>
-constexpr constraints::group entity_field<Obj, Type, R, W, Ts...>::get_group(const Group& g, const Obj& x)
-{ return detail::read_field<Obj, constraints::group, Group>::read(x, g); }
-
 template<typename Obj>
 struct Entity final {
     static_assert(std::is_same_v<Obj, std::decay_t<Obj>>);
diff --git a/test/entity.cpp b/test/entity.cpp
index 40b7eb6b..1ae77129 100644
--- a/test/entity.cpp
+++ b/test/entity.cpp
@@ -207,16 +207,13 @@ constexpr void test_constraints()
         "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
         constantly(constraints::max_length{42}),
         constantly(constraints::range<int>{37, 42}),
-        constantly(constraints::group{"foo"_s})
     };
 
     static_assert(foo.get_range(x) == constraints::range<int>{37, 42});
     static_assert(foo.get_max_length(x) == 42);
-    static_assert(foo.get_group(x) == "foo"_s);
 
     static_assert(m_foo.get_range(x) == constraints::range<int>{});
     static_assert(m_foo.get_max_length(x) == (size_t)-1);
-    static_assert(m_foo.get_group(x) == ""_s);
 
     constexpr auto foo2 = entity::type<int>::field {
         "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
@@ -224,7 +221,6 @@ constexpr void test_constraints()
     };
     static_assert(foo2.get_range(x) == constraints::range<int>{});
     static_assert(foo2.get_max_length(x) == 123);
-    static_assert(foo2.get_group(x) == ""_s);
 }
 
 void test_erased_constraints()
@@ -234,7 +230,6 @@ void test_erased_constraints()
         "foo"_s, &TestAccessors::foo, &TestAccessors::foo,
         constantly(constraints::max_length{42}),
         constantly(constraints::range<int>{37, 42}),
-        constantly(constraints::group{"foo"_s})
     };
     static constexpr auto erased = foo.erased();
     const auto x = TestAccessors{};
@@ -242,7 +237,6 @@ void test_erased_constraints()
     erased.do_asserts<TestAccessors>();
     fm_assert(erased.get_range(&x) == constraints::range<int>{37, 42});
     fm_assert(erased.get_max_length(&x) == 42);
-    fm_assert(erased.get_group(&x) == "foo"_s);
 }
 
 } // namespace