diff options
Diffstat (limited to 'entity')
| -rw-r--r-- | entity/accessor.hpp | 13 | ||||
| -rw-r--r-- | entity/concepts.hpp | 1 | ||||
| -rw-r--r-- | entity/constraints.hpp | 7 | ||||
| -rw-r--r-- | entity/erased-constraints.cpp | 12 | ||||
| -rw-r--r-- | entity/erased-constraints.hpp | 3 | ||||
| -rw-r--r-- | entity/field-status.hpp | 7 | ||||
| -rw-r--r-- | entity/field.hpp | 163 | ||||
| -rw-r--r-- | entity/metadata.hpp | 196 |
8 files changed, 202 insertions, 200 deletions
diff --git a/entity/accessor.hpp b/entity/accessor.hpp index 9dd9c3b6..22bef6e3 100644 --- a/entity/accessor.hpp +++ b/entity/accessor.hpp @@ -2,21 +2,11 @@ #include "util.hpp" #include "erased-constraints.hpp" #include "name-of.hpp" -#include <type_traits> +#include "field-status.hpp" #include <Corrade/Containers/StringView.h> -namespace floormat::erased_constraints { - -struct range; -struct max_length; -struct group; - -} // namespace floormat::erased_constraints - namespace floormat::entities { -enum class field_status : unsigned char { hidden, readonly, enabled, COUNT, }; - struct erased_accessor final { using reader_t = void; using writer_t = void; @@ -40,7 +30,6 @@ struct erased_accessor final { erased_constraints::max_length(*length_fun)(const Object*, const c_length_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, StringView field_name, StringView object_name, StringView field_type_name, diff --git a/entity/concepts.hpp b/entity/concepts.hpp index 5e01fcda..6c13299c 100644 --- a/entity/concepts.hpp +++ b/entity/concepts.hpp @@ -3,7 +3,6 @@ #include "compat/function2.hpp" #include "compat/assert.hpp" #include <concepts> -#include <type_traits> namespace floormat::entities { diff --git a/entity/constraints.hpp b/entity/constraints.hpp index 6a5587d5..0bfc2f15 100644 --- a/entity/constraints.hpp +++ b/entity/constraints.hpp @@ -1,8 +1,7 @@ #pragma once #include "compat/limits.hpp" #include "erased-constraints.hpp" -#include <type_traits> -#include <utility> +#include <cr/Pair.h> #include <mg/Vector.h> namespace floormat::entities::limit_detail { @@ -52,7 +51,7 @@ template<typename T> struct range T max = limit_detail::limit_traits<T>::max(); constexpr operator erased_constraints::range() const noexcept; - constexpr operator std::pair<T, T>() const noexcept; + constexpr operator Pair<T, T>() const noexcept; constexpr bool operator==(const range&) const noexcept = default; }; @@ -125,7 +124,7 @@ template<typename T> constexpr range<T>::operator erased_constraints::range() const noexcept { return erased_range_from_range(min, max); } -template<typename T> constexpr range<T>::operator std::pair<T, T>() const noexcept { return { min, max }; } +template<typename T> constexpr range<T>::operator Pair<T, T>() const noexcept { return { min, max }; } template<> struct range<String> { constexpr operator erased_constraints::range() const noexcept { return {}; } }; template<> struct range<StringView> { constexpr operator erased_constraints::range() const noexcept { return {}; } }; diff --git a/entity/erased-constraints.cpp b/entity/erased-constraints.cpp index 6e81820a..4cb915dc 100644 --- a/entity/erased-constraints.cpp +++ b/entity/erased-constraints.cpp @@ -2,17 +2,17 @@ #include "compat/assert.hpp" #include <cmath> #include <limits> -#include <Magnum/Magnum.h> -#include <Magnum/Math/Vector2.h> -#include <Magnum/Math/Vector3.h> -#include <Magnum/Math/Vector4.h> +#include <cr/Pair.h> +#include <mg/Vector2.h> +#include <mg/Vector3.h> +#include <mg/Vector4.h> namespace floormat::entities::erased_constraints { static_assert(sizeof(size_t) == sizeof(uintptr_t)); static_assert(sizeof(size_t) == sizeof(ptrdiff_t)); -template<typename T> std::pair<T, T> range::convert() const +template<typename T> Pair<T, T> range::convert() const { static_assert(sizeof(T) <= sizeof(min)); @@ -103,7 +103,7 @@ template<typename T> std::pair<T, T> range::convert() const } } -template<typename T> using pair2 = std::pair<T, T>; +template<typename T> using pair2 = Pair<T, T>; template pair2<uint8_t> range::convert() const; template pair2<uint16_t> range::convert() const; diff --git a/entity/erased-constraints.hpp b/entity/erased-constraints.hpp index af050bd6..64b469a3 100644 --- a/entity/erased-constraints.hpp +++ b/entity/erased-constraints.hpp @@ -1,4 +1,5 @@ #pragma once +#include <utility> #include <Corrade/Containers/StringView.h> #include <Magnum/Math/Vector4.h> @@ -25,7 +26,7 @@ struct range final element min, max; type_ type = type_none; - template<typename T> std::pair<T, T> convert() const; + template<typename T> Pair<T, T> convert() const; friend bool operator==(const range& a, const range& b); }; diff --git a/entity/field-status.hpp b/entity/field-status.hpp new file mode 100644 index 00000000..f95d54ed --- /dev/null +++ b/entity/field-status.hpp @@ -0,0 +1,7 @@ +#pragma once + +namespace floormat::entities { + +enum class field_status : unsigned char { hidden, readonly, enabled, COUNT, }; + +} // namespace floormat::entities diff --git a/entity/field.hpp b/entity/field.hpp new file mode 100644 index 00000000..02782651 --- /dev/null +++ b/entity/field.hpp @@ -0,0 +1,163 @@ +#pragma once + +#include "constraints.hpp" +#include "concepts.hpp" +#include "accessor.hpp" +#include "field-status.hpp" +#include "compat/defs.hpp" + +namespace floormat::entities::detail { +template<typename Obj, typename Type, typename Default, size_t I, typename... Fs> struct find_reader; + +template<typename Obj, typename Type, typename Default, size_t I> struct find_reader<Obj, Type, Default, I> { + using type = Default; + static constexpr size_t index = I; +}; + +template<typename Obj, typename Type, typename Default, size_t I, typename F, typename... Fs> +struct find_reader<Obj, Type, Default, I, F, Fs...> { + using type = typename find_reader<Obj, Type, Default, I+1, Fs...>::type; + static constexpr size_t index = find_reader<Obj, Type, Default, I+1, Fs...>::index; +}; + +template<typename Obj, typename Type, typename Default, size_t I, typename F, typename... Fs> +requires FieldReader<F, Obj, Type> +struct find_reader<Obj, Type, Default, I, F, Fs...> { using type = F; static constexpr size_t index = I; }; + +} // namespace floormat::entities::detail + +namespace floormat::entities { + +constexpr auto constantly(const auto& x) noexcept { + return [x]<typename... Ts> (const Ts&...) constexpr -> const auto& { return x; }; +} + +template<typename Obj, typename Type> struct entity_field_base {}; + +template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> +struct entity_field : entity_field_base<Obj, Type> { +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)}); + 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 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...>; + static constexpr size_t good_arguments = + unsigned(c_predicate::index != sizeof...(Ts)) + + unsigned(c_range::index != sizeof...(Ts)) + + unsigned(c_length::index != sizeof...(Ts)); + static_assert(sizeof...(Ts) == good_arguments, "ignored arguments"); + +public: + using ObjectType = Obj; + using FieldType = Type; + using Reader = R; + using Writer = W; + using Predicate = typename c_predicate::type; + using Range = typename c_range::type; + using Length = typename c_length::type; + + StringView name; + [[fm_no_unique_address]] R reader; + [[fm_no_unique_address]] W writer; + [[fm_no_unique_address]] Predicate predicate; + [[fm_no_unique_address]] Range range; + [[fm_no_unique_address]] Length length; + + fm_DECLARE_DEFAULT_MOVE_COPY_ASSIGNMENTS(entity_field); + + static constexpr decltype(auto) read(const R& reader, const Obj& x) { return detail::read_field<Obj, Type, R>::read(x, reader); } + static constexpr void write(const W& writer, Obj& x, Type v); + constexpr decltype(auto) read(const Obj& x) const { return read(reader, x); } + constexpr void write(Obj& x, Type value) const { write(writer, x, move(value)); } + static constexpr bool can_write = !std::is_same_v<std::nullptr_t, decltype(entity_field<Obj, Type, R, W, Ts...>::writer)>; + + static constexpr field_status is_enabled(const Predicate & p, const Obj& x); + constexpr field_status is_enabled(const Obj& x) const { return is_enabled(predicate, x); } + + static constexpr constraints::range<Type> get_range(const Range& r, const Obj& x); + 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); } + + 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)) } + {} + constexpr erased_accessor erased() const; +}; + +template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> +constexpr void entity_field<Obj, Type, R, W, Ts...>::write(const W& writer, Obj& x, Type v) +{ + static_assert(can_write); detail::write_field<Obj, Type, W>::write(x, writer, move(v)); +} + +template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> +constexpr erased_accessor entity_field<Obj, Type, R, W, Ts...>::erased() const +{ + using reader_t = typename erased_accessor::reader_t; + using writer_t = typename erased_accessor::writer_t; + 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; + 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) { + const auto& obj_ = *static_cast<const Obj*>(obj); + const auto& reader_ = *static_cast<const R*>(reader); + auto& value_ = *static_cast<Type*>(value); + value_ = read(reader_, obj_); + }; + constexpr auto writer_fn = [](void* obj, const writer_t* writer, void* value) { + auto& obj_ = *static_cast<Obj*>(obj); + const auto& writer_ = *static_cast<const W*>(writer); + Type value_ = move(*static_cast<Type*>(value)); + write(writer_, obj_, move(value_)); + }; + constexpr auto predicate_fn = [](const void* obj, const predicate_t* predicate) { + const auto& obj_ = *static_cast<const Obj*>(obj); + const auto& predicate_ = *static_cast<const Predicate*>(predicate); + return is_enabled(predicate_, obj_); + }; + constexpr auto writer_stub_fn = [](void*, const writer_t*, void*) { + fm_abort("no writer for this accessor"); + }; + constexpr bool has_writer = !std::is_same_v<std::decay_t<decltype(writer)>, std::nullptr_t>; + + constexpr auto c_range_fn = [](const void* obj, const c_range_t* reader) -> erased_constraints::range { + return get_range(*static_cast<const Range*>(reader), *static_cast<const Obj*>(obj)); + }; + constexpr auto c_length_fn = [](const void* obj, const c_length_t* reader) -> erased_constraints::max_length { + return get_max_length(*static_cast<const Length*>(reader), *static_cast<const Obj*>(obj)); + }; + return erased_accessor { + (void*)&reader, has_writer ? (void*)&writer : nullptr, + (void*)&predicate, + (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, + }; +} + +template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> +constexpr field_status entity_field<Obj, Type, R, W, Ts...>::is_enabled(const Predicate& p, const Obj& x) +{ return detail::read_field<Obj, field_status, Predicate>::read(x, p); } + +template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> +constexpr constraints::range<Type> entity_field<Obj, Type, R, W, Ts...>::get_range(const Range& r, const Obj& x) +{ return detail::read_field<Obj, constraints::range<Type>, Range>::read(x, r); } + +template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> +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); } + +} // namespace floormat::entities diff --git a/entity/metadata.hpp b/entity/metadata.hpp index 101af0df..8e3b41d3 100644 --- a/entity/metadata.hpp +++ b/entity/metadata.hpp @@ -1,28 +1,13 @@ #pragma once #include "name-of.hpp" #include "accessor.hpp" -#include "constraints.hpp" -#include "util.hpp" +#include "field.hpp" #include "concepts.hpp" -#include "compat/defs.hpp" -#include <type_traits> -#include <concepts> -#include <limits> -#include <tuple> +#include <utility> #include <array> #include <compat/function2.hpp> #include <Corrade/Containers/StringView.h> -namespace floormat::entities { - -struct inspect_intent_t {}; -struct serialize_intent_t {}; -struct report_intent_t {}; - -template<typename T, typename Intent> struct entity_accessors; - -} // namespace floormat::entities - namespace floormat::entities::detail { template<typename F, typename Tuple, size_t N> @@ -55,158 +40,33 @@ template<typename T> struct decay_tuple_; template<typename... Ts> struct decay_tuple_<std::tuple<Ts...>> { using type = std::tuple<std::decay_t<Ts>...>; }; template<typename T> using decay_tuple = typename decay_tuple_<T>::type; -template<typename Obj, typename Type, typename Default, size_t I, typename... Fs> struct find_reader; - -template<typename Obj, typename Type, typename Default, size_t I> struct find_reader<Obj, Type, Default, I> { - using type = Default; - static constexpr size_t index = I; -}; - -template<typename Obj, typename Type, typename Default, size_t I, typename F, typename... Fs> -struct find_reader<Obj, Type, Default, I, F, Fs...> { - using type = typename find_reader<Obj, Type, Default, I+1, Fs...>::type; - static constexpr size_t index = find_reader<Obj, Type, Default, I+1, Fs...>::index; -}; - -template<typename Obj, typename Type, typename Default, size_t I, typename F, typename... Fs> -requires FieldReader<F, Obj, Type> -struct find_reader<Obj, Type, Default, I, F, Fs...> { using type = F; static constexpr size_t index = I; }; - } // namespace floormat::entities::detail namespace floormat::entities { -constexpr auto constantly(const auto& x) noexcept { - return [x]<typename... Ts> (const Ts&...) constexpr -> const auto& { return x; }; -} - -template<typename Obj, typename Type> struct entity_field_base {}; - -template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> -struct entity_field : entity_field_base<Obj, Type> { -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)}); - 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 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...>; - static constexpr size_t good_arguments = - unsigned(c_predicate::index != sizeof...(Ts)) + - unsigned(c_range::index != sizeof...(Ts)) + - unsigned(c_length::index != sizeof...(Ts)); - static_assert(sizeof...(Ts) == good_arguments, "ignored arguments"); - -public: - using ObjectType = Obj; - using FieldType = Type; - using Reader = R; - using Writer = W; - using Predicate = typename c_predicate::type; - using Range = typename c_range::type; - using Length = typename c_length::type; - - StringView name; - [[fm_no_unique_address]] R reader; - [[fm_no_unique_address]] W writer; - [[fm_no_unique_address]] Predicate predicate; - [[fm_no_unique_address]] Range range; - [[fm_no_unique_address]] Length length; - - fm_DECLARE_DEFAULT_MOVE_COPY_ASSIGNMENTS(entity_field); - - static constexpr decltype(auto) read(const R& reader, const Obj& x) { return detail::read_field<Obj, Type, R>::read(x, reader); } - static constexpr void write(const W& writer, Obj& x, Type v); - constexpr decltype(auto) read(const Obj& x) const { return read(reader, x); } - constexpr void write(Obj& x, Type value) const { write(writer, x, move(value)); } - static constexpr bool can_write = !std::is_same_v<std::nullptr_t, decltype(entity_field<Obj, Type, R, W, Ts...>::writer)>; - - static constexpr field_status is_enabled(const Predicate & p, const Obj& x); - constexpr field_status is_enabled(const Obj& x) const { return is_enabled(predicate, x); } - - static constexpr constraints::range<Type> get_range(const Range& r, const Obj& x); - 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); } - - 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)) } - {} - constexpr erased_accessor erased() const; -}; - -template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> -constexpr void entity_field<Obj, Type, R, W, Ts...>::write(const W& writer, Obj& x, Type v) +template<typename F, typename Tuple> +constexpr void visit_tuple(F&& fun, Tuple&& tuple) { - static_assert(can_write); detail::write_field<Obj, Type, W>::write(x, writer, move(v)); + using Size = std::tuple_size<std::decay_t<Tuple>>; + if constexpr(Size() > 0) + detail::visit_tuple<F, Tuple, 0>(floormat::forward<F>(fun), floormat::forward<Tuple>(tuple)); } -template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> -constexpr erased_accessor entity_field<Obj, Type, R, W, Ts...>::erased() const +template<typename F, typename Tuple> +constexpr bool find_in_tuple(F&& fun, Tuple&& tuple) { - using reader_t = typename erased_accessor::reader_t; - using writer_t = typename erased_accessor::writer_t; - 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; - 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) { - const auto& obj_ = *static_cast<const Obj*>(obj); - const auto& reader_ = *static_cast<const R*>(reader); - auto& value_ = *static_cast<Type*>(value); - value_ = read(reader_, obj_); - }; - constexpr auto writer_fn = [](void* obj, const writer_t* writer, void* value) { - auto& obj_ = *static_cast<Obj*>(obj); - const auto& writer_ = *static_cast<const W*>(writer); - Type value_ = move(*static_cast<Type*>(value)); - write(writer_, obj_, move(value_)); - }; - constexpr auto predicate_fn = [](const void* obj, const predicate_t* predicate) { - const auto& obj_ = *static_cast<const Obj*>(obj); - const auto& predicate_ = *static_cast<const Predicate*>(predicate); - return is_enabled(predicate_, obj_); - }; - constexpr auto writer_stub_fn = [](void*, const writer_t*, void*) { - fm_abort("no writer for this accessor"); - }; - constexpr bool has_writer = !std::is_same_v<std::decay_t<decltype(writer)>, std::nullptr_t>; - - constexpr auto c_range_fn = [](const void* obj, const c_range_t* reader) -> erased_constraints::range { - return get_range(*static_cast<const Range*>(reader), *reinterpret_cast<const Obj*>(obj)); - }; - constexpr auto c_length_fn = [](const void* obj, const c_length_t* reader) -> erased_constraints::max_length { - return get_max_length(*static_cast<const Length*>(reader), *reinterpret_cast<const Obj*>(obj)); - }; - return erased_accessor { - (void*)&reader, has_writer ? (void*)&writer : nullptr, - (void*)&predicate, - (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, - }; + using Size = std::tuple_size<std::decay_t<Tuple>>; + if constexpr(Size() > 0) + return detail::find_in_tuple<F, Tuple, 0>(floormat::forward<F>(fun), floormat::forward<Tuple>(tuple)); + else + return false; } -template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> -constexpr field_status entity_field<Obj, Type, R, W, Ts...>::is_enabled(const Predicate& p, const Obj& x) -{ return detail::read_field<Obj, field_status, Predicate>::read(x, p); } - -template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> -constexpr constraints::range<Type> entity_field<Obj, Type, R, W, Ts...>::get_range(const Range& r, const Obj& x) -{ return detail::read_field<Obj, constraints::range<Type>, Range>::read(x, r); } +struct inspect_intent_t {}; +struct serialize_intent_t {}; +struct report_intent_t {}; -template<typename Obj, typename Type, FieldReader<Obj, Type> R, FieldWriter<Obj, Type> W, typename... Ts> -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 T, typename Intent> struct entity_accessors; template<typename Obj> struct Entity final { @@ -228,24 +88,6 @@ struct Entity final { }; }; -template<typename F, typename Tuple> -constexpr void visit_tuple(F&& fun, Tuple&& tuple) -{ - using Size = std::tuple_size<std::decay_t<Tuple>>; - if constexpr(Size() > 0) - detail::visit_tuple<F, Tuple, 0>(floormat::forward<F>(fun), floormat::forward<Tuple>(tuple)); -} - -template<typename F, typename Tuple> -constexpr bool find_in_tuple(F&& fun, Tuple&& tuple) -{ - using Size = std::tuple_size<std::decay_t<Tuple>>; - if constexpr(Size() > 0) - return detail::find_in_tuple<F, Tuple, 0>(floormat::forward<F>(fun), floormat::forward<Tuple>(tuple)); - else - return false; -} - constexpr inline auto ignored_write = []<typename O, typename T>(O&, T) {}; } // namespace floormat::entities @@ -264,6 +106,8 @@ public: static constexpr auto accessors = entities::entity_accessors<T, Intent>::accessors(); static constexpr size_t size = std::tuple_size_v<std::decay_t<decltype(accessors)>>; static constexpr auto erased_accessors = erased_helper(accessors, std::make_index_sequence<size>{}); + + entity_metadata() = default; }; template<typename T, typename Intent> |