首次提交

2026-08-07 16:21:44 +08:00
parent 396311246c
commit 1e903dfe1e
33 changed files with 5960 additions and 1 deletions
@@ -0,0 +1,101 @@
+#pragma once
+#include "accessor.hpp"
+#include "attributes.hpp"
+#include "meta.hpp"
+#include <cstddef>
+#include <tuple>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+namespace structive {
+template <class Value, class... Attributes>
+consteval bool constraints_compatible() {
+    return (([] {
+        if constexpr (Property_Constraint<Attributes>) {
+            return Property_Constraint_For<Attributes, Value>;
+        }
+        return true;
+    }()) && ...);
+}
+template <Property_Accessor Accessor, class... Attributes>
+struct Property_Descriptor {
+    using property_descriptor_tag = void;
+    using accessor_type = Accessor;
+    using object_type = typename Accessor::object_type;
+    using value_type = typename Accessor::value_type;
+    using storage_identity = typename Accessor::storage_identity;
+    using attribute_types = Type_List<Attributes...>;
+    static constexpr bool readable = Accessor::readable;
+    static constexpr bool writable = Accessor::writable;
+    static constexpr bool synchronized_view_read = Accessor::synchronized_view_read;
+    static constexpr bool trusted_object_access = Accessor::trusted_object_access;
+    static_assert(unique_single_value_categories<Attributes...>());
+    using key_type = find_attribute_in_list_t<Key_Category, attribute_types>;
+    static_assert(!std::same_as<key_type, void>);
+    static_assert(key_type::value.view().size() > 0);
+    static_assert(constraints_compatible<value_type, Attributes...>());
+    [[no_unique_address]] Accessor accessor{};
+    std::tuple<Attributes...> attributes;
+    template <class Category>
+    using attribute_type = find_attribute_in_list_t<Category, attribute_types>;
+    template <class Category>
+    static constexpr bool has_attribute = !std::same_as<attribute_type<Category>, void>;
+    template <class Category>
+    constexpr decltype(auto) attribute() const requires has_attribute<Category> {
+        using target = attribute_type<Category>;
+        return std::get<target>(attributes);
+    }
+    constexpr std::string_view key() const noexcept {
+        return key_type::value.view();
+    }
+    template <class Function>
+    constexpr void for_each_attribute(Function&& function) const {
+        std::apply([&](const auto&... values) {
+            (function(values), ...);
+        }, attributes);
+    }
+    template <class Function>
+    constexpr void for_each_constraint(Function&& function) const {
+        std::apply([&](const auto&... values) {
+            ([&] {
+                using type = std::remove_cvref_t<decltype(values)>;
+                if constexpr (Property_Constraint<type>) {
+                    function(values);
+                }
+            }(), ...);
+        }, attributes);
+    }
+};
+template <class Type>
+concept Property_Descriptor_Type = requires {
+    typename Type::property_descriptor_tag;
+    typename Type::object_type;
+    typename Type::value_type;
+    typename Type::accessor_type;
+    typename Type::storage_identity;
+};
+template <auto Member, class... Attributes>
+constexpr auto property(Attributes&&... attributes) {
+    using accessor = Member_Accessor<Member>;
+    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{{}, {std::forward<Attributes>(attributes)...}};
+}
+template <auto Member, class... Attributes>
+constexpr auto field(Attributes&&... attributes) {
+    return property<Member>(std::forward<Attributes>(attributes)...);
+}
+template <class Object, class Value, class Function, class... Attributes>
+constexpr auto computed_property(Function&& function, Attributes&&... attributes) {
+    using accessor = Synchronized_Computed_Accessor<Object, Value, std::decay_t<Function>>;
+    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{accessor{std::forward<Function>(function)}, {std::forward<Attributes>(attributes)...}};
+}
+template <auto Getter, class... Attributes> requires Trusted_Getter_Function<Getter>
+constexpr auto trusted_computed_property(Attributes&&... attributes) {
+    using accessor = Trusted_Computed_Accessor<Getter>;
+    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{{}, {std::forward<Attributes>(attributes)...}};
+}
+template <auto Getter, auto Setter, class... Attributes> requires Trusted_Getter_Function<Getter> && Trusted_Setter_Function_For<Setter, trusted_getter_object_t<Getter>, trusted_getter_value_t<Getter>>
+constexpr auto trusted_accessor_property(Attributes&&... attributes) {
+    using accessor = Trusted_Getter_Setter_Accessor<Getter, Setter>;
+    return Property_Descriptor<accessor, std::decay_t<Attributes>...>{{}, {std::forward<Attributes>(attributes)...}};
+}
+}