更完

core/include/structive/property/accessor.hpp

@@ -140,6 +140,46 @@ struct Trusted_Getter_Setter_Accessor {
         std::invoke(Setter, object, std::forward<Value>(value));
     }
 };
+template <class Object, class Reader, class Writer>
+requires std::invocable<const Reader&, const Object&> &&
+         (!std::is_void_v<std::invoke_result_t<const Reader&, const Object&>>) &&
+         (!std::is_rvalue_reference_v<std::invoke_result_t<const Reader&, const Object&>>) &&
+         std::invocable<const Writer&, Object&,
+                        std::remove_cvref_t<std::invoke_result_t<const Reader&, const Object&>>> &&
+         std::same_as<std::invoke_result_t<
+                          const Writer&, Object&,
+                          std::remove_cvref_t<std::invoke_result_t<const Reader&, const Object&>>>,
+                      void>
+struct Trusted_Callable_Accessor {
+    using object_type = Object;
+    using value_type =
+        std::remove_cvref_t<std::invoke_result_t<const Reader&, const Object&>>;
+    using storage_identity = void;
+    static constexpr bool readable = true;
+    static constexpr bool writable = true;
+    static constexpr bool synchronized_view_read = false;
+    static constexpr bool trusted_object_access = true;
+    using dependency_spec = No_Property_Dependencies;
+
+    [[no_unique_address]] Reader reader;
+    [[no_unique_address]] Writer writer;
+
+    constexpr decltype(auto) read(const object_type& object) const
+        noexcept(std::is_nothrow_invocable_v<const Reader&, const object_type&>) {
+        return std::invoke(reader, object);
+    }
+    template <class Value>
+    constexpr void write(object_type& object, Value&& value) const
+        requires std::invocable<const Writer&, object_type&, Value> &&
+                 std::same_as<std::invoke_result_t<const Writer&, object_type&, Value>, void> {
+        std::invoke(writer, object, std::forward<Value>(value));
+    }
+};
+template <class Object, class Reader, class Writer>
+auto trusted_callable_accessor(Reader reader, Writer writer) {
+    return Trusted_Callable_Accessor<Object, Reader, Writer>{
+        std::move(reader), std::move(writer)};
+}
 template <class Accessor>
 concept Property_Accessor = requires {
     typename Accessor::object_type;

core/include/structive/property/schema.hpp

@@ -556,6 +556,9 @@ auto object_schema(Properties&&... properties) requires (Property_Descriptor_Typ
     return make_object_schema<Object>(no_defaults, Synchronization_Plan{}, std::forward<Properties>(properties)...);
 }
 template <class Object, class... Arguments>
+requires requires(Arguments&&... arguments) {
+    object_schema<Object>(std::forward<Arguments>(arguments)...);
+}
 auto object(Arguments&&... arguments) {
     return object_schema<Object>(std::forward<Arguments>(arguments)...);
 }