psc/Structive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

去除internel 访问级别

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-07 17:15:02 +08:00
parent 1ddd2799f2
commit 0c7fac70b2
8 changed files with 270 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/include/structive/property/property_object.hpp
+147 -119
View File
@@ -80,10 +80,21 @@ public:
};
}
enum class Managed_Access_Mode {
internal,
external,
persistence
};
namespace detail {
enum class Access_Kind {
intrinsic,
external,
persistence
};
constexpr Access_Kind access_kind(Managed_Access_Mode mode) noexcept {
return mode == Managed_Access_Mode::external ? Access_Kind::external : Access_Kind::persistence;
}
template <Managed_Access_Mode Mode>
inline constexpr Access_Kind access_kind_v = Mode == Managed_Access_Mode::external ? Access_Kind::external : Access_Kind::persistence;
}
enum class Runtime_Access_Result {
ok,
unknown_property,
@@ -96,8 +107,8 @@ class Property_Object_Base {
struct Runtime_Interface {
const std::type_info& (*object_type)() noexcept;
std::size_t (*property_count)() noexcept;
Runtime_Access_Result (*read)(const Property_Object_Base&, Managed_Access_Mode, std::string_view, void*, Runtime_Read_Callback);
Runtime_Access_Result (*write)(Property_Object_Base&, Managed_Access_Mode, std::string_view, const std::type_info&, const void*);
Runtime_Access_Result (*read)(const Property_Object_Base&, detail::Access_Kind, std::string_view, void*, Runtime_Read_Callback);
Runtime_Access_Result (*write)(Property_Object_Base&, detail::Access_Kind, std::string_view, const std::type_info&, const void*);
};
const Runtime_Interface* runtime_interface_{};
protected:
@@ -116,19 +127,27 @@ public:
std::size_t runtime_property_count() const noexcept {
return runtime_interface_->property_count();
}
Runtime_Access_Result runtime_read(std::string_view key, void* context, Runtime_Read_Callback callback) const {
return runtime_interface_->read(*this, detail::Access_Kind::intrinsic, key, context, callback);
}
Runtime_Access_Result runtime_read(Managed_Access_Mode mode, std::string_view key, void* context, Runtime_Read_Callback callback) const {
return runtime_interface_->read(*this, mode, key, context, callback);
return runtime_interface_->read(*this, detail::access_kind(mode), key, context, callback);
}
Runtime_Access_Result runtime_write(std::string_view key, const std::type_info& value_type, const void* value) {
return runtime_interface_->write(*this, detail::Access_Kind::intrinsic, key, value_type, value);
}
Runtime_Access_Result runtime_write(Managed_Access_Mode mode, std::string_view key, const std::type_info& value_type, const void* value) {
return runtime_interface_->write(*this, mode, key, value_type, value);
return runtime_interface_->write(*this, detail::access_kind(mode), key, value_type, value);
}
};
template <Managed_Access_Mode Mode, class Schema, std::size_t Index>
inline constexpr bool property_read_allowed_v = Mode == Managed_Access_Mode::internal ? Schema::template property_type<Index>::readable : Mode == Managed_Access_Mode::external ? external_readable_v<Schema, Index> : persistence_storable_v<Schema, Index>;
template <Managed_Access_Mode Mode, class Schema, std::size_t Index>
inline constexpr bool property_write_allowed_v = Mode == Managed_Access_Mode::internal ? Schema::template property_type<Index>::writable : Mode == Managed_Access_Mode::external ? external_writable_v<Schema, Index> : persistence_loadable_v<Schema, Index>;
template <Managed_Access_Mode Mode, class Schema, std::size_t Index>
namespace detail {
template <Access_Kind Mode, class Schema, std::size_t Index>
inline constexpr bool property_read_allowed_v = Mode == Access_Kind::intrinsic ? Schema::template property_type<Index>::readable : Mode == Access_Kind::external ? external_readable_v<Schema, Index> : persistence_storable_v<Schema, Index>;
template <Access_Kind Mode, class Schema, std::size_t Index>
inline constexpr bool property_write_allowed_v = Mode == Access_Kind::intrinsic ? Schema::template property_type<Index>::writable : Mode == Access_Kind::external ? external_writable_v<Schema, Index> : persistence_loadable_v<Schema, Index>;
template <Access_Kind Mode, class Schema, std::size_t Index>
inline constexpr bool property_visible_v = property_read_allowed_v<Mode, Schema, Index> || property_write_allowed_v<Mode, Schema, Index>;
}
struct Property_Synchronization {
Synchronization_Plan plan;
};
@@ -230,23 +249,23 @@ private:
}
count = write;
}
template <Managed_Access_Mode Mode>
template <detail::Access_Kind Mode>
static bool runtime_property_readable(std::size_t index) {
using Schema = type_descriptor_schema_t<Derived>;
static const auto table = []<std::size_t... Index>(std::index_sequence<Index...>) {
return std::array<bool, Schema::property_count>{property_read_allowed_v<Mode, Schema, Index>...};
return std::array<bool, Schema::property_count>{detail::property_read_allowed_v<Mode, Schema, Index>...};
}(std::make_index_sequence<Schema::property_count>{});
return table[index];
}
template <Managed_Access_Mode Mode>
template <detail::Access_Kind Mode>
static bool runtime_property_visible(std::size_t index) {
using Schema = type_descriptor_schema_t<Derived>;
static const auto table = []<std::size_t... Index>(std::index_sequence<Index...>) {
return std::array<bool, Schema::property_count>{property_visible_v<Mode, Schema, Index>...};
return std::array<bool, Schema::property_count>{detail::property_visible_v<Mode, Schema, Index>...};
}(std::make_index_sequence<Schema::property_count>{});
return table[index];
}
template <Managed_Access_Mode Mode>
template <detail::Access_Kind Mode>
Dynamic_Lock_Targets collect_dynamic_lock_targets(std::span<const std::string_view> keys, bool shared_access) const {
using Schema = type_descriptor_schema_t<Derived>;
Dynamic_Lock_Targets targets;
@@ -274,10 +293,10 @@ private:
targets.unsynchronized_properties.erase(std::unique(targets.unsynchronized_properties.begin(), targets.unsynchronized_properties.end()), targets.unsynchronized_properties.end());
return targets;
}
template <Managed_Access_Mode Mode, bool Shared_Access, std::size_t... Index>
template <detail::Access_Kind Mode, bool Shared_Access, std::size_t... Index>
Static_Lock_Targets<sizeof...(Index)> collect_static_lock_targets() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(((Shared_Access ? property_read_allowed_v<Mode, Schema, Index> : property_visible_v<Mode, Schema, Index>) && ...));
static_assert(((Shared_Access ? detail::property_read_allowed_v<Mode, Schema, Index> : detail::property_visible_v<Mode, Schema, Index>) && ...));
Static_Lock_Targets<sizeof...(Index)> targets;
auto collect = [&]<std::size_t Property_Index>() {
auto lock_slot = slot(Property_Index);
@@ -292,12 +311,12 @@ private:
sort_unique_prefix(targets.unsynchronized_properties, targets.unsynchronized_count);
return targets;
}
template <Managed_Access_Mode Mode, bool Shared_Access>
template <detail::Access_Kind Mode, bool Shared_Access>
auto collect_all_static_lock_targets() const {
using Schema = type_descriptor_schema_t<Derived>;
Static_Lock_Targets<Schema::property_count> targets;
auto collect = [&]<std::size_t Index>() {
constexpr bool allowed = Shared_Access ? property_read_allowed_v<Mode, Schema, Index> : property_write_allowed_v<Mode, Schema, Index>;
constexpr bool allowed = Shared_Access ? detail::property_read_allowed_v<Mode, Schema, Index> : detail::property_write_allowed_v<Mode, Schema, Index>;
if constexpr (allowed) {
auto lock_slot = slot(Index);
if (lock_slot == Resolved_Synchronization_View::unsynchronized_slot) {
@@ -330,7 +349,7 @@ private:
const auto& descriptor = type_descriptor<Derived>().template property<Index>();
descriptor.accessor.write(static_cast<Derived&>(*this), std::forward<Value>(value));
}
template <Managed_Access_Mode Mode>
template <detail::Access_Kind Mode>
class Single_Read_View {
const Property_Object* owner_{};
std::size_t property_index_{};
@@ -358,10 +377,10 @@ private:
return owner_->template read_unlocked<index>(*this);
}
};
template <Managed_Access_Mode Mode, std::size_t Index>
template <detail::Access_Kind Mode, std::size_t Index>
auto read_one() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(property_read_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_read_allowed_v<Mode, Schema, Index>);
using Property = typename Schema::template property_type<Index>;
using Value = typename Property::value_type;
if constexpr (!uses_real_mutexes && !Property::accessor_type::synchronized_view_read) {
@@ -378,10 +397,10 @@ private:
std::shared_lock lock{mutex(lock_slot)};
return Value(read_unlocked<Index>(view));
}
template <Managed_Access_Mode Mode, std::size_t Index, class Value>
template <detail::Access_Kind Mode, std::size_t Index, class Value>
void write_one(Value&& value) {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(property_write_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_write_allowed_v<Mode, Schema, Index>);
if constexpr (!uses_real_mutexes) {
write_unlocked<Index>(std::forward<Value>(value));
return;
@@ -394,9 +413,9 @@ private:
std::unique_lock lock{mutex(lock_slot)};
write_unlocked<Index>(std::forward<Value>(value));
}
public:
template <Managed_Access_Mode Mode>
class Read_Guard {
private:
template <detail::Access_Kind Mode>
class Basic_Read_Guard {
const Property_Object* owner_{};
std::vector<std::size_t> slots_;
std::vector<std::size_t> unsynchronized_properties_;
@@ -409,7 +428,7 @@ public:
return std::binary_search(slots_.begin(), slots_.end(), lock_slot);
}
friend class Property_Object;
Read_Guard(const Property_Object& owner, Dynamic_Lock_Targets targets) : owner_(&owner), slots_(std::move(targets.slots)), unsynchronized_properties_(std::move(targets.unsynchronized_properties)) {
Basic_Read_Guard(const Property_Object& owner, Dynamic_Lock_Targets targets) : owner_(&owner), slots_(std::move(targets.slots)), unsynchronized_properties_(std::move(targets.unsynchronized_properties)) {
if constexpr (uses_real_mutexes) {
locks_.reserve(slots_.size());
for (auto lock_slot : slots_) {
@@ -422,7 +441,7 @@ public:
decltype(auto) get_index() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(Index < Schema::property_count);
static_assert(property_read_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_read_allowed_v<Mode, Schema, Index>);
if (!holds(Index)) {
throw std::logic_error("Property is outside the held synchronization set");
}
@@ -443,8 +462,8 @@ public:
return get_index<index>();
}
};
template <Managed_Access_Mode Mode>
class Write_Guard {
template <detail::Access_Kind Mode>
class Basic_Write_Guard {
Property_Object* owner_{};
std::vector<std::size_t> slots_;
std::vector<std::size_t> unsynchronized_properties_;
@@ -457,7 +476,7 @@ public:
return std::binary_search(slots_.begin(), slots_.end(), lock_slot);
}
friend class Property_Object;
Write_Guard(Property_Object& owner, Dynamic_Lock_Targets targets) : owner_(&owner), slots_(std::move(targets.slots)), unsynchronized_properties_(std::move(targets.unsynchronized_properties)) {
Basic_Write_Guard(Property_Object& owner, Dynamic_Lock_Targets targets) : owner_(&owner), slots_(std::move(targets.slots)), unsynchronized_properties_(std::move(targets.unsynchronized_properties)) {
if constexpr (uses_real_mutexes) {
locks_.reserve(slots_.size());
for (auto lock_slot : slots_) {
@@ -470,7 +489,7 @@ public:
decltype(auto) get_index() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(Index < Schema::property_count);
static_assert(property_read_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_read_allowed_v<Mode, Schema, Index>);
if (!holds(Index)) {
throw std::logic_error("Property is outside the held synchronization set");
}
@@ -494,7 +513,7 @@ public:
void set_index(Value&& value) {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(Index < Schema::property_count);
static_assert(property_write_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_write_allowed_v<Mode, Schema, Index>);
if (!holds(Index)) {
throw std::logic_error("Property is outside the held synchronization set");
}
@@ -515,7 +534,7 @@ public:
set_index<index>(std::forward<Value>(value));
}
};
template <Managed_Access_Mode Mode, std::size_t Capacity>
template <detail::Access_Kind Mode, std::size_t Capacity>
class Static_Read_Guard {
const Property_Object* owner_{};
Static_Lock_Targets<Capacity> targets_;
@@ -540,7 +559,7 @@ public:
decltype(auto) get_index() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(Index < Schema::property_count);
static_assert(property_read_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_read_allowed_v<Mode, Schema, Index>);
if (!holds(Index)) {
throw std::logic_error("Property is outside the held synchronization set");
}
@@ -561,7 +580,7 @@ public:
return get_index<index>();
}
};
template <Managed_Access_Mode Mode, std::size_t Capacity>
template <detail::Access_Kind Mode, std::size_t Capacity>
class Static_Write_Guard {
Property_Object* owner_{};
Static_Lock_Targets<Capacity> targets_;
@@ -586,7 +605,7 @@ public:
decltype(auto) get_index() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(Index < Schema::property_count);
static_assert(property_read_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_read_allowed_v<Mode, Schema, Index>);
if (!holds(Index)) {
throw std::logic_error("Property is outside the held synchronization set");
}
@@ -610,7 +629,7 @@ public:
void set_index(Value&& value) {
using Schema = type_descriptor_schema_t<Derived>;
static_assert(Index < Schema::property_count);
static_assert(property_write_allowed_v<Mode, Schema, Index>);
static_assert(detail::property_write_allowed_v<Mode, Schema, Index>);
if (!holds(Index)) {
throw std::logic_error("Property is outside the held synchronization set");
}
@@ -631,32 +650,39 @@ public:
set_index<index>(std::forward<Value>(value));
}
};
public:
using Intrinsic_Read_Guard = Basic_Read_Guard<detail::Access_Kind::intrinsic>;
using Intrinsic_Write_Guard = Basic_Write_Guard<detail::Access_Kind::intrinsic>;
template <Managed_Access_Mode Mode>
using Read_Guard = Basic_Read_Guard<detail::access_kind_v<Mode>>;
template <Managed_Access_Mode Mode>
using Write_Guard = Basic_Write_Guard<detail::access_kind_v<Mode>>;
private:
template <Managed_Access_Mode Mode, class Function>
template <detail::Access_Kind Mode, class Function>
void for_each_readable_impl(Function&& function) const {
using Schema = type_descriptor_schema_t<Derived>;
const auto& schema = type_descriptor<Derived>();
schema.for_each_property([&](auto index, const auto& descriptor) {
constexpr std::size_t property_index = decltype(index)::value;
if constexpr (property_read_allowed_v<Mode, Schema, property_index>) {
if constexpr (detail::property_read_allowed_v<Mode, Schema, property_index>) {
auto value = read_one<Mode, property_index>();
std::invoke(function, index, descriptor, value);
}
});
}
template <Managed_Access_Mode Mode, class Function>
template <detail::Access_Kind Mode, class Function>
void for_each_readable_locked_impl(Function&& function) const {
using Schema = type_descriptor_schema_t<Derived>;
auto targets = collect_all_static_lock_targets<Mode, true>();
Static_Read_Guard<Mode, Schema::property_count> guard{*this, std::move(targets)};
type_descriptor<Derived>().for_each_property([&](auto index, const auto& descriptor) {
constexpr std::size_t property_index = decltype(index)::value;
if constexpr (property_read_allowed_v<Mode, Schema, property_index>) {
if constexpr (detail::property_read_allowed_v<Mode, Schema, property_index>) {
std::invoke(function, index, descriptor, guard.template get_index<property_index>());
}
});
}
template <Managed_Access_Mode Mode, class Function>
template <detail::Access_Kind Mode, class Function>
void with_all_writable_locked_impl(Function&& function) {
using Schema = type_descriptor_schema_t<Derived>;
auto targets = collect_all_static_lock_targets<Mode, false>();
@@ -670,7 +696,7 @@ private:
using Schema = type_descriptor_schema_t<Derived>;
return Schema::property_count;
}
template <Managed_Access_Mode Mode>
template <detail::Access_Kind Mode>
Runtime_Access_Result runtime_read_mode(std::string_view key, void* context, Runtime_Read_Callback callback) const {
using Schema = type_descriptor_schema_t<Derived>;
auto index = schema_property_index<Schema>(key);
@@ -707,19 +733,19 @@ private:
});
return result;
}
static Runtime_Access_Result runtime_read_impl(const Property_Object_Base& base, Managed_Access_Mode mode, std::string_view key, void* context, Runtime_Read_Callback callback) {
static Runtime_Access_Result runtime_read_impl(const Property_Object_Base& base, detail::Access_Kind mode, std::string_view key, void* context, Runtime_Read_Callback callback) {
const auto& self = static_cast<const Property_Object&>(base);
switch (mode) {
case Managed_Access_Mode::internal:
return self.template runtime_read_mode<Managed_Access_Mode::internal>(key, context, callback);
case Managed_Access_Mode::external:
return self.template runtime_read_mode<Managed_Access_Mode::external>(key, context, callback);
case Managed_Access_Mode::persistence:
return self.template runtime_read_mode<Managed_Access_Mode::persistence>(key, context, callback);
case detail::Access_Kind::intrinsic:
return self.template runtime_read_mode<detail::Access_Kind::intrinsic>(key, context, callback);
case detail::Access_Kind::external:
return self.template runtime_read_mode<detail::Access_Kind::external>(key, context, callback);
case detail::Access_Kind::persistence:
return self.template runtime_read_mode<detail::Access_Kind::persistence>(key, context, callback);
}
return Runtime_Access_Result::not_readable;
}
template <Managed_Access_Mode Mode>
template <detail::Access_Kind Mode>
Runtime_Access_Result runtime_write_mode(std::string_view key, const std::type_info& value_type, const void* value) {
using Schema = type_descriptor_schema_t<Derived>;
auto index = schema_property_index<Schema>(key);
@@ -735,7 +761,7 @@ private:
using Property = typename Schema::template property_type<property_index>;
using Accessor = typename Property::accessor_type;
using Value = typename Property::value_type;
if constexpr (!property_write_allowed_v<Mode, Schema, property_index> || !requires(const Accessor& accessor, Derived& object, const Value& candidate) { accessor.write(object, candidate); }) {
if constexpr (!detail::property_write_allowed_v<Mode, Schema, property_index> || !requires(const Accessor& accessor, Derived& object, const Value& candidate) { accessor.write(object, candidate); }) {
result = Runtime_Access_Result::not_writable;
} else if (value_type != typeid(Value)) {
result = Runtime_Access_Result::type_mismatch;
@@ -746,15 +772,15 @@ private:
});
return result;
}
static Runtime_Access_Result runtime_write_impl(Property_Object_Base& base, Managed_Access_Mode mode, std::string_view key, const std::type_info& value_type, const void* value) {
static Runtime_Access_Result runtime_write_impl(Property_Object_Base& base, detail::Access_Kind mode, std::string_view key, const std::type_info& value_type, const void* value) {
auto& self = static_cast<Property_Object&>(base);
switch (mode) {
case Managed_Access_Mode::internal:
return self.template runtime_write_mode<Managed_Access_Mode::internal>(key, value_type, value);
case Managed_Access_Mode::external:
return self.template runtime_write_mode<Managed_Access_Mode::external>(key, value_type, value);
case Managed_Access_Mode::persistence:
return self.template runtime_write_mode<Managed_Access_Mode::persistence>(key, value_type, value);
case detail::Access_Kind::intrinsic:
return self.template runtime_write_mode<detail::Access_Kind::intrinsic>(key, value_type, value);
case detail::Access_Kind::external:
return self.template runtime_write_mode<detail::Access_Kind::external>(key, value_type, value);
case detail::Access_Kind::persistence:
return self.template runtime_write_mode<detail::Access_Kind::persistence>(key, value_type, value);
}
return Runtime_Access_Result::not_writable;
}
@@ -808,28 +834,28 @@ public:
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_member_property_index_v<Schema, Member>;
static_assert(index < Schema::property_count);
return read_one<Managed_Access_Mode::internal, index>();
return read_one<detail::Access_Kind::intrinsic, index>();
}
template <Fixed_String Key>
auto read_key() const {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_property_index_v<Schema, Key>;
static_assert(index < Schema::property_count);
return read_one<Managed_Access_Mode::internal, index>();
return read_one<detail::Access_Kind::intrinsic, index>();
}
template <auto Member, class Value>
void write(Value&& value) {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_member_property_index_v<Schema, Member>;
static_assert(index < Schema::property_count);
write_one<Managed_Access_Mode::internal, index>(std::forward<Value>(value));
write_one<detail::Access_Kind::intrinsic, index>(std::forward<Value>(value));
}
template <Fixed_String Key, class Value>
void write_key(Value&& value) {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_property_index_v<Schema, Key>;
static_assert(index < Schema::property_count);
write_one<Managed_Access_Mode::internal, index>(std::forward<Value>(value));
write_one<detail::Access_Kind::intrinsic, index>(std::forward<Value>(value));
}
template <auto Member>
std::size_t lock_slot() const noexcept {
@@ -838,67 +864,69 @@ public:
static_assert(index < Schema::property_count);
return slot(index);
}
template <Managed_Access_Mode Mode>
Read_Guard<Mode> lock_shared(std::span<const std::string_view> keys) const {
return Read_Guard<Mode>{*this, collect_dynamic_lock_targets<Mode>(keys, true)};
private:
template <detail::Access_Kind Mode>
Basic_Read_Guard<Mode> lock_shared_mode(std::span<const std::string_view> keys) const {
return Basic_Read_Guard<Mode>{*this, collect_dynamic_lock_targets<Mode>(keys, true)};
}
template <Managed_Access_Mode Mode>
Read_Guard<Mode> lock_shared(std::initializer_list<std::string_view> keys) const {
return lock_shared<Mode>(std::span<const std::string_view>{keys.begin(), keys.size()});
template <detail::Access_Kind Mode>
Basic_Read_Guard<Mode> lock_shared_mode(std::initializer_list<std::string_view> keys) const {
return lock_shared_mode<Mode>(std::span<const std::string_view>{keys.begin(), keys.size()});
}
Read_Guard<Managed_Access_Mode::internal> lock_shared(std::span<const std::string_view> keys) const {
return lock_shared<Managed_Access_Mode::internal>(keys);
template <detail::Access_Kind Mode>
Basic_Write_Guard<Mode> lock_unique_mode(std::span<const std::string_view> keys) {
return Basic_Write_Guard<Mode>{*this, collect_dynamic_lock_targets<Mode>(keys, false)};
}
Read_Guard<Managed_Access_Mode::internal> lock_shared(std::initializer_list<std::string_view> keys) const {
return lock_shared<Managed_Access_Mode::internal>(keys);
template <detail::Access_Kind Mode>
Basic_Write_Guard<Mode> lock_unique_mode(std::initializer_list<std::string_view> keys) {
return lock_unique_mode<Mode>(std::span<const std::string_view>{keys.begin(), keys.size()});
}
template <Managed_Access_Mode Mode>
Write_Guard<Mode> lock_unique(std::span<const std::string_view> keys) {
return Write_Guard<Mode>{*this, collect_dynamic_lock_targets<Mode>(keys, false)};
}
template <Managed_Access_Mode Mode>
Write_Guard<Mode> lock_unique(std::initializer_list<std::string_view> keys) {
return lock_unique<Mode>(std::span<const std::string_view>{keys.begin(), keys.size()});
}
Write_Guard<Managed_Access_Mode::internal> lock_unique(std::span<const std::string_view> keys) {
return lock_unique<Managed_Access_Mode::internal>(keys);
}
Write_Guard<Managed_Access_Mode::internal> lock_unique(std::initializer_list<std::string_view> keys) {
return lock_unique<Managed_Access_Mode::internal>(keys);
}
template <Managed_Access_Mode Mode, auto... Members>
template <detail::Access_Kind Mode, auto... Members>
auto lock_shared_mode() const {
using Schema = type_descriptor_schema_t<Derived>;
static_assert((Schema_Property_Member<Schema, Members> && ...));
auto targets = collect_static_lock_targets<Mode, true, schema_member_property_index_v<Schema, Members>...>();
return Static_Read_Guard<Mode, sizeof...(Members)>{*this, std::move(targets)};
}
template <auto... Members>
auto lock_shared() const {
return lock_shared_mode<Managed_Access_Mode::internal, Members...>();
}
template <Managed_Access_Mode Mode, auto... Members>
template <detail::Access_Kind Mode, auto... Members>
auto lock_unique_mode() {
using Schema = type_descriptor_schema_t<Derived>;
static_assert((Schema_Property_Member<Schema, Members> && ...));
auto targets = collect_static_lock_targets<Mode, false, schema_member_property_index_v<Schema, Members>...>();
return Static_Write_Guard<Mode, sizeof...(Members)>{*this, std::move(targets)};
}
public:
Intrinsic_Read_Guard lock_shared(std::span<const std::string_view> keys) const {
return lock_shared_mode<detail::Access_Kind::intrinsic>(keys);
}
Intrinsic_Read_Guard lock_shared(std::initializer_list<std::string_view> keys) const {
return lock_shared_mode<detail::Access_Kind::intrinsic>(keys);
}
Intrinsic_Write_Guard lock_unique(std::span<const std::string_view> keys) {
return lock_unique_mode<detail::Access_Kind::intrinsic>(keys);
}
Intrinsic_Write_Guard lock_unique(std::initializer_list<std::string_view> keys) {
return lock_unique_mode<detail::Access_Kind::intrinsic>(keys);
}
template <auto... Members>
auto lock_shared() const {
return lock_shared_mode<detail::Access_Kind::intrinsic, Members...>();
}
template <auto... Members>
auto lock_unique() {
return lock_unique_mode<Managed_Access_Mode::internal, Members...>();
return lock_unique_mode<detail::Access_Kind::intrinsic, Members...>();
}
template <class Function>
void for_each_readable(Function&& function) const {
for_each_readable_impl<Managed_Access_Mode::internal>(std::forward<Function>(function));
for_each_readable_impl<detail::Access_Kind::intrinsic>(std::forward<Function>(function));
}
template <class Function>
void for_each_readable_locked(Function&& function) const {
for_each_readable_locked_impl<Managed_Access_Mode::internal>(std::forward<Function>(function));
for_each_readable_locked_impl<detail::Access_Kind::intrinsic>(std::forward<Function>(function));
}
template <class Function>
void with_all_writable_locked(Function&& function) {
with_all_writable_locked_impl<Managed_Access_Mode::internal>(std::forward<Function>(function));
with_all_writable_locked_impl<detail::Access_Kind::intrinsic>(std::forward<Function>(function));
}
template <Managed_Access_Mode Mode>
class Capability_View {
@@ -910,42 +938,42 @@ public:
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_member_property_index_v<Schema, Member>;
static_assert(index < Schema::property_count);
return owner_->template read_one<Mode, index>();
return owner_->template read_one<detail::access_kind_v<Mode>, index>();
}
template <Fixed_String Key>
auto read_key() const {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_property_index_v<Schema, Key>;
static_assert(index < Schema::property_count);
return owner_->template read_one<Mode, index>();
return owner_->template read_one<detail::access_kind_v<Mode>, index>();
}
template <auto Member, class Value>
void write(Value&& value) requires (Mode != Managed_Access_Mode::persistence) {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_member_property_index_v<Schema, Member>;
static_assert(index < Schema::property_count);
owner_->template write_one<Mode, index>(std::forward<Value>(value));
owner_->template write_one<detail::access_kind_v<Mode>, index>(std::forward<Value>(value));
}
template <Fixed_String Key, class Value>
void write_key(Value&& value) requires (Mode != Managed_Access_Mode::persistence) {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_property_index_v<Schema, Key>;
static_assert(index < Schema::property_count);
owner_->template write_one<Mode, index>(std::forward<Value>(value));
owner_->template write_one<detail::access_kind_v<Mode>, index>(std::forward<Value>(value));
}
template <auto Member, class Value>
void load(Value&& value) requires (Mode == Managed_Access_Mode::persistence) {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_member_property_index_v<Schema, Member>;
static_assert(index < Schema::property_count);
owner_->template write_one<Mode, index>(std::forward<Value>(value));
owner_->template write_one<detail::access_kind_v<Mode>, index>(std::forward<Value>(value));
}
template <Fixed_String Key, class Value>
void load_key(Value&& value) requires (Mode == Managed_Access_Mode::persistence) {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_property_index_v<Schema, Key>;
static_assert(index < Schema::property_count);
owner_->template write_one<Mode, index>(std::forward<Value>(value));
owner_->template write_one<detail::access_kind_v<Mode>, index>(std::forward<Value>(value));
}
template <auto Member>
auto store() const requires (Mode == Managed_Access_Mode::persistence) {
@@ -957,33 +985,33 @@ public:
}
template <auto... Members>
auto lock_shared() const {
return owner_->template lock_shared_mode<Mode, Members...>();
return owner_->template lock_shared_mode<detail::access_kind_v<Mode>, Members...>();
}
template <auto... Members>
auto lock_unique() {
return owner_->template lock_unique_mode<Mode, Members...>();
return owner_->template lock_unique_mode<detail::access_kind_v<Mode>, Members...>();
}
Read_Guard<Mode> lock_shared(std::span<const std::string_view> keys) const {
return owner_->template lock_shared<Mode>(keys);
return owner_->template lock_shared_mode<detail::access_kind_v<Mode>>(keys);
}
Write_Guard<Mode> lock_unique(std::span<const std::string_view> keys) {
return owner_->template lock_unique<Mode>(keys);
return owner_->template lock_unique_mode<detail::access_kind_v<Mode>>(keys);
}
template <class Function>
void for_each_readable(Function&& function) const {
owner_->template for_each_readable_impl<Mode>(std::forward<Function>(function));
owner_->template for_each_readable_impl<detail::access_kind_v<Mode>>(std::forward<Function>(function));
}
template <class Function>
void for_each_readable_locked(Function&& function) const {
owner_->template for_each_readable_locked_impl<Mode>(std::forward<Function>(function));
owner_->template for_each_readable_locked_impl<detail::access_kind_v<Mode>>(std::forward<Function>(function));
}
template <class Function>
void with_all_writable_locked(Function&& function) requires (Mode != Managed_Access_Mode::persistence) {
owner_->template with_all_writable_locked_impl<Mode>(std::forward<Function>(function));
owner_->template with_all_writable_locked_impl<detail::access_kind_v<Mode>>(std::forward<Function>(function));
}
template <class Function>
void with_all_loadable_locked(Function&& function) requires (Mode == Managed_Access_Mode::persistence) {
owner_->template with_all_writable_locked_impl<Mode>(std::forward<Function>(function));
owner_->template with_all_writable_locked_impl<detail::access_kind_v<Mode>>(std::forward<Function>(function));
}
};
template <Managed_Access_Mode Mode>
@@ -996,14 +1024,14 @@ public:
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_member_property_index_v<Schema, Member>;
static_assert(index < Schema::property_count);
return owner_->template read_one<Mode, index>();
return owner_->template read_one<detail::access_kind_v<Mode>, index>();
}
template <Fixed_String Key>
auto read_key() const {
using Schema = type_descriptor_schema_t<Derived>;
constexpr auto index = schema_property_index_v<Schema, Key>;
static_assert(index < Schema::property_count);
return owner_->template read_one<Mode, index>();
return owner_->template read_one<detail::access_kind_v<Mode>, index>();
}
template <auto Member>
auto store() const requires (Mode == Managed_Access_Mode::persistence) {
@@ -1015,18 +1043,18 @@ public:
}
template <auto... Members>
auto lock_shared() const {
return owner_->template lock_shared_mode<Mode, Members...>();
return owner_->template lock_shared_mode<detail::access_kind_v<Mode>, Members...>();
}
Read_Guard<Mode> lock_shared(std::span<const std::string_view> keys) const {
return owner_->template lock_shared<Mode>(keys);
return owner_->template lock_shared_mode<detail::access_kind_v<Mode>>(keys);
}
template <class Function>
void for_each_readable(Function&& function) const {
owner_->template for_each_readable_impl<Mode>(std::forward<Function>(function));
owner_->template for_each_readable_impl<detail::access_kind_v<Mode>>(std::forward<Function>(function));
}
template <class Function>
void for_each_readable_locked(Function&& function) const {
owner_->template for_each_readable_locked_impl<Mode>(std::forward<Function>(function));
owner_->template for_each_readable_locked_impl<detail::access_kind_v<Mode>>(std::forward<Function>(function));
}
};
Capability_View<Managed_Access_Mode::external> external() {