BlackMATov/meta.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/meta.hpp.git synced 2025-12-15 03:45:30 +07:00
Code Issues Packages Projects Releases Wiki Activity

internal states and binds cleanup

Browse Source
This commit is contained in:
BlackMATov
2023-01-14 19:07:27 +07:00
parent 4094e234d3
commit 47c564b25e
41 changed files with 478 additions and 670 deletions
Download Patch File Download Diff File Expand all files Collapse all files

574
develop/singles/headers/meta.hpp/meta_all.hpp
View File

File diff suppressed because it is too large Load Diff

127
headers/meta.hpp/meta_binds.hpp
View File

@@ -70,7 +70,7 @@ namespace meta_hpp
}; };
struct method_opts final { struct method_opts final {
argument_opts_list arguments{}; argument_opts_list arguments;
metadata_map metadata{}; metadata_map metadata{};
}; };
@@ -79,26 +79,70 @@ namespace meta_hpp
}; };
} }
namespace meta_hpp
{
template < detail::type_family Type >
class type_bind_base {
public:
explicit type_bind_base(const Type& type, metadata_map metadata)
: data_{detail::type_access(type)} {
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
operator Type() const noexcept {
return Type{data_};
}
protected:
using data_ptr = typename Type::data_ptr;
using data_ref = decltype(*std::declval<data_ptr>());
[[nodiscard]] data_ref get_data() noexcept {
return *data_;
}
private:
data_ptr data_;
detail::type_registry::locker locker_;
};
template < detail::state_family State >
class state_bind_base {
public:
explicit state_bind_base(const State& state, metadata_map metadata)
: state_{detail::state_access(state)} {
detail::insert_or_assign(state_->metadata, std::move(metadata));
}
operator State() const noexcept {
return State{state_};
}
protected:
using state_ptr = typename State::state_ptr;
using state_ref = decltype(*std::declval<state_ptr>());
[[nodiscard]] state_ref get_state() noexcept {
return *state_;
}
private:
state_ptr state_;
detail::state_registry::locker locker_;
};
}
namespace meta_hpp namespace meta_hpp
{ {
template < detail::array_kind Array > template < detail::array_kind Array >
class array_bind final { class array_bind final : public type_bind_base<array_type> {
public: public:
explicit array_bind(metadata_map metadata); explicit array_bind(metadata_map metadata);
operator array_type() const noexcept;
private:
detail::array_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::class_kind Class > template < detail::class_kind Class >
class class_bind final { class class_bind final : public type_bind_base<class_type> {
public: public:
explicit class_bind(metadata_map metadata); explicit class_bind(metadata_map metadata);
operator class_type() const noexcept;
// base_ // base_
@@ -219,138 +263,98 @@ namespace meta_hpp
Pointer pointer, Pointer pointer,
variable_opts opts, variable_opts opts,
Policy = Policy{}); Policy = Policy{});
private:
detail::class_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::enum_kind Enum > template < detail::enum_kind Enum >
class enum_bind final { class enum_bind final : public type_bind_base<enum_type> {
public: public:
explicit enum_bind(metadata_map metadata); explicit enum_bind(metadata_map metadata);
operator enum_type() const noexcept;
enum_bind& evalue_(std::string name, Enum value); enum_bind& evalue_(std::string name, Enum value);
enum_bind& evalue_(std::string name, Enum value, evalue_opts opts); enum_bind& evalue_(std::string name, Enum value, evalue_opts opts);
private:
detail::enum_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::function_kind Function > template < detail::function_kind Function >
class function_bind final { class function_bind final : public type_bind_base<function_type> {
public: public:
explicit function_bind(metadata_map metadata); explicit function_bind(metadata_map metadata);
operator function_type() const noexcept;
private:
detail::function_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::member_kind Member > template < detail::member_kind Member >
class member_bind final { class member_bind final : public type_bind_base<member_type> {
public: public:
explicit member_bind(metadata_map metadata); explicit member_bind(metadata_map metadata);
operator member_type() const noexcept;
private:
detail::member_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::method_kind Method > template < detail::method_kind Method >
class method_bind final { class method_bind final : public type_bind_base<method_type> {
public: public:
explicit method_bind(metadata_map metadata); explicit method_bind(metadata_map metadata);
operator method_type() const noexcept;
private:
detail::method_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::nullptr_kind Nullptr > template < detail::nullptr_kind Nullptr >
class nullptr_bind final { class nullptr_bind final : public type_bind_base<nullptr_type> {
public: public:
explicit nullptr_bind(metadata_map metadata); explicit nullptr_bind(metadata_map metadata);
operator nullptr_type() const noexcept;
private:
detail::nullptr_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::number_kind Number > template < detail::number_kind Number >
class number_bind final { class number_bind final : public type_bind_base<number_type> {
public: public:
explicit number_bind(metadata_map metadata); explicit number_bind(metadata_map metadata);
operator number_type() const noexcept;
private:
detail::number_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::pointer_kind Pointer > template < detail::pointer_kind Pointer >
class pointer_bind final { class pointer_bind final : public type_bind_base<pointer_type> {
public: public:
explicit pointer_bind(metadata_map metadata); explicit pointer_bind(metadata_map metadata);
operator pointer_type() const noexcept;
private:
detail::pointer_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::reference_kind Reference > template < detail::reference_kind Reference >
class reference_bind final { class reference_bind final : public type_bind_base<reference_type> {
public: public:
explicit reference_bind(metadata_map metadata); explicit reference_bind(metadata_map metadata);
operator reference_type() const noexcept;
private:
detail::reference_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
template < detail::void_kind Void > template < detail::void_kind Void >
class void_bind final { class void_bind final : public type_bind_base<void_type> {
public: public:
explicit void_bind(metadata_map metadata); explicit void_bind(metadata_map metadata);
operator void_type() const noexcept;
private:
detail::void_type_data* data_{};
detail::type_registry::locker locker_{};
}; };
} }
namespace meta_hpp namespace meta_hpp
{ {
class scope_bind final { class scope_bind final : public state_bind_base<scope> {
public: public:
explicit scope_bind(const scope& scope, metadata_map metadata); explicit scope_bind(const scope& scope, metadata_map metadata);
operator scope() const noexcept;
// function_ // function_
@@ -398,9 +402,6 @@ namespace meta_hpp
Pointer pointer, Pointer pointer,
variable_opts opts, variable_opts opts,
Policy = Policy{}); Policy = Policy{});
private:
detail::scope_state_ptr state_;
detail::state_registry::locker locker_{};
}; };
} }
@@ -465,8 +466,8 @@ namespace meta_hpp
namespace meta_hpp namespace meta_hpp
{ {
inline scope_bind local_scope_(std::string name, metadata_map metadata = {}) { inline scope_bind local_scope_(std::string name, metadata_map metadata = {}) {
scope local_scope{detail::scope_state::make(std::move(name))}; scope local_scope{detail::scope_state::make(std::move(name), std::move(metadata))};
return scope_bind{local_scope, std::move(metadata)}; return scope_bind{local_scope, {}};
} }
inline scope_bind static_scope_(std::string_view name, metadata_map metadata = {}) { inline scope_bind static_scope_(std::string_view name, metadata_map metadata = {}) {

9
headers/meta.hpp/meta_binds/array_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::array_kind Array > template < detail::array_kind Array >
array_bind<Array>::array_bind(metadata_map metadata) array_bind<Array>::array_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Array>())} { : type_bind_base{resolve_type<Array>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::array_kind Array >
array_bind<Array>::operator array_type() const noexcept {
return array_type{data_};
}
} }

33
headers/meta.hpp/meta_binds/class_bind.hpp
View File

@@ -14,19 +14,12 @@ namespace meta_hpp
{ {
template < detail::class_kind Class > template < detail::class_kind Class >
class_bind<Class>::class_bind(metadata_map metadata) class_bind<Class>::class_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Class>())} { : type_bind_base{resolve_type<Class>(), std::move(metadata)} {
detail::insert_or_assign(data_->metadata, std::move(metadata));
if constexpr ( std::is_destructible_v<Class> ) { if constexpr ( std::is_destructible_v<Class> ) {
destructor_(); destructor_();
} }
} }
template < detail::class_kind Class >
class_bind<Class>::operator class_type() const noexcept {
return class_type{data_};
}
// //
// base_ // base_
// //
@@ -39,18 +32,18 @@ namespace meta_hpp
([this]<detail::class_kind Base>(std::in_place_type_t<Base>) { ([this]<detail::class_kind Base>(std::in_place_type_t<Base>) {
const class_type& base_type = resolve_type<Base>(); const class_type& base_type = resolve_type<Base>();
if ( auto&& [_, emplaced] = data_->bases.emplace(base_type); !emplaced ) { if ( auto&& [_, emplaced] = get_data().bases.emplace(base_type); !emplaced ) {
return; return;
} }
META_HPP_TRY { META_HPP_TRY {
data_->bases_info.emplace(base_type, detail::class_type_data::base_info{ get_data().bases_info.emplace(base_type, detail::class_type_data::base_info{
.upcast = +[](void* derived) -> void* { .upcast = +[](void* derived) -> void* {
return static_cast<Base*>(static_cast<Class*>(derived)); return static_cast<Base*>(static_cast<Class*>(derived));
} }
}); });
} META_HPP_CATCH(...) { } META_HPP_CATCH(...) {
data_->bases.erase(base_type); get_data().bases.erase(base_type);
META_HPP_RETHROW(); META_HPP_RETHROW();
} }
}(std::in_place_type<Bases>), ...); }(std::in_place_type<Bases>), ...);
@@ -89,7 +82,7 @@ namespace meta_hpp
detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata); detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata);
} }
detail::insert_or_assign(data_->constructors, std::move(state)); detail::insert_or_assign(get_data().constructors, std::move(state));
return *this; return *this;
} }
@@ -109,7 +102,7 @@ namespace meta_hpp
requires detail::class_bind_destructor_kind<Class> requires detail::class_bind_destructor_kind<Class>
{ {
auto state = detail::destructor_state::make<Class>(std::move(opts.metadata)); auto state = detail::destructor_state::make<Class>(std::move(opts.metadata));
detail::insert_or_assign(data_->destructors, std::move(state)); detail::insert_or_assign(get_data().destructors, std::move(state));
return *this; return *this;
} }
@@ -150,7 +143,7 @@ namespace meta_hpp
detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata); detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata);
} }
detail::insert_or_assign(data_->functions, std::move(state)); detail::insert_or_assign(get_data().functions, std::move(state));
return *this; return *this;
} }
@@ -177,7 +170,7 @@ namespace meta_hpp
detail::state_access(arg)->name = std::data(arguments)[i]; detail::state_access(arg)->name = std::data(arguments)[i];
} }
detail::insert_or_assign(data_->functions, std::move(state)); detail::insert_or_assign(get_data().functions, std::move(state));
return *this; return *this;
} }
@@ -209,7 +202,7 @@ namespace meta_hpp
std::move(name), std::move(name),
std::move(member), std::move(member),
std::move(opts.metadata)); std::move(opts.metadata));
detail::insert_or_assign(data_->members, std::move(state)); detail::insert_or_assign(get_data().members, std::move(state));
return *this; return *this;
} }
@@ -252,7 +245,7 @@ namespace meta_hpp
detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata); detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata);
} }
detail::insert_or_assign(data_->methods, std::move(state)); detail::insert_or_assign(get_data().methods, std::move(state));
return *this; return *this;
} }
@@ -280,7 +273,7 @@ namespace meta_hpp
detail::state_access(arg)->name = std::data(arguments)[i]; detail::state_access(arg)->name = std::data(arguments)[i];
} }
detail::insert_or_assign(data_->methods, std::move(state)); detail::insert_or_assign(get_data().methods, std::move(state));
return *this; return *this;
} }
@@ -291,7 +284,7 @@ namespace meta_hpp
template < detail::class_kind Class > template < detail::class_kind Class >
template < typename Type > template < typename Type >
class_bind<Class>& class_bind<Class>::typedef_(std::string name) { class_bind<Class>& class_bind<Class>::typedef_(std::string name) {
data_->typedefs.insert_or_assign(std::move(name), resolve_type<Type>()); get_data().typedefs.insert_or_assign(std::move(name), resolve_type<Type>());
return *this; return *this;
} }
@@ -321,7 +314,7 @@ namespace meta_hpp
std::move(name), std::move(name),
std::move(pointer), std::move(pointer),
std::move(opts.metadata)); std::move(opts.metadata));
detail::insert_or_assign(data_->variables, std::move(state)); detail::insert_or_assign(get_data().variables, std::move(state));
return *this; return *this;
} }
} }

11
headers/meta.hpp/meta_binds/enum_bind.hpp
View File

@@ -14,14 +14,7 @@ namespace meta_hpp
{ {
template < detail::enum_kind Enum > template < detail::enum_kind Enum >
enum_bind<Enum>::enum_bind(metadata_map metadata) enum_bind<Enum>::enum_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Enum>())} { : type_bind_base{resolve_type<Enum>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::enum_kind Enum >
enum_bind<Enum>::operator enum_type() const noexcept {
return enum_type{data_};
}
template < detail::enum_kind Enum > template < detail::enum_kind Enum >
enum_bind<Enum>& enum_bind<Enum>::evalue_(std::string name, Enum value) { enum_bind<Enum>& enum_bind<Enum>::evalue_(std::string name, Enum value) {
@@ -34,7 +27,7 @@ namespace meta_hpp
std::move(name), std::move(name),
std::move(value), std::move(value),
std::move(opts.metadata)); std::move(opts.metadata));
detail::insert_or_assign(data_->evalues, std::move(state)); detail::insert_or_assign(get_data().evalues, std::move(state));
return *this; return *this;
} }
} }

9
headers/meta.hpp/meta_binds/function_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::function_kind Function > template < detail::function_kind Function >
function_bind<Function>::function_bind(metadata_map metadata) function_bind<Function>::function_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Function>())} { : type_bind_base{resolve_type<Function>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::function_kind Function >
function_bind<Function>::operator function_type() const noexcept {
return function_type{data_};
}
} }

9
headers/meta.hpp/meta_binds/member_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::member_kind Member > template < detail::member_kind Member >
member_bind<Member>::member_bind(metadata_map metadata) member_bind<Member>::member_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Member>())} { : type_bind_base{resolve_type<Member>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::member_kind Member >
member_bind<Member>::operator member_type() const noexcept {
return member_type{data_};
}
} }

9
headers/meta.hpp/meta_binds/method_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::method_kind Method > template < detail::method_kind Method >
method_bind<Method>::method_bind(metadata_map metadata) method_bind<Method>::method_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Method>())} { : type_bind_base{resolve_type<Method>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::method_kind Method >
method_bind<Method>::operator method_type() const noexcept {
return method_type{data_};
}
} }

9
headers/meta.hpp/meta_binds/nullptr_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::nullptr_kind Nullptr > template < detail::nullptr_kind Nullptr >
nullptr_bind<Nullptr>::nullptr_bind(metadata_map metadata) nullptr_bind<Nullptr>::nullptr_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Nullptr>())} { : type_bind_base{resolve_type<Nullptr>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::nullptr_kind Nullptr >
nullptr_bind<Nullptr>::operator nullptr_type() const noexcept {
return nullptr_type{data_};
}
} }

9
headers/meta.hpp/meta_binds/number_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::number_kind Number > template < detail::number_kind Number >
number_bind<Number>::number_bind(metadata_map metadata) number_bind<Number>::number_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Number>())} { : type_bind_base{resolve_type<Number>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::number_kind Number >
number_bind<Number>::operator number_type() const noexcept {
return number_type{data_};
}
} }

9
headers/meta.hpp/meta_binds/pointer_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::pointer_kind Pointer > template < detail::pointer_kind Pointer >
pointer_bind<Pointer>::pointer_bind(metadata_map metadata) pointer_bind<Pointer>::pointer_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Pointer>())} { : type_bind_base{resolve_type<Pointer>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::pointer_kind Pointer >
pointer_bind<Pointer>::operator pointer_type() const noexcept {
return pointer_type{data_};
}
} }

9
headers/meta.hpp/meta_binds/reference_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::reference_kind Reference > template < detail::reference_kind Reference >
reference_bind<Reference>::reference_bind(metadata_map metadata) reference_bind<Reference>::reference_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<Reference>())} { : type_bind_base{resolve_type<Reference>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::reference_kind Reference >
reference_bind<Reference>::operator reference_type() const noexcept {
return reference_type{data_};
}
} }

16
headers/meta.hpp/meta_binds/scope_bind.hpp
View File

@@ -13,13 +13,7 @@
namespace meta_hpp namespace meta_hpp
{ {
inline scope_bind::scope_bind(const scope& scope, metadata_map metadata) inline scope_bind::scope_bind(const scope& scope, metadata_map metadata)
: state_{detail::state_access(scope)} { : state_bind_base{scope, std::move(metadata)} {}
detail::insert_or_assign(state_->metadata, std::move(metadata));
}
inline scope_bind::operator scope() const noexcept {
return scope{state_};
}
// //
// function_ // function_
@@ -56,7 +50,7 @@ namespace meta_hpp
detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata); detail::state_access(arg)->metadata = std::move(opts.arguments[i].metadata);
} }
detail::insert_or_assign(state_->functions, std::move(state)); detail::insert_or_assign(get_state().functions, std::move(state));
return *this; return *this;
} }
@@ -82,7 +76,7 @@ namespace meta_hpp
detail::state_access(arg)->name = std::data(arguments)[i]; detail::state_access(arg)->name = std::data(arguments)[i];
} }
detail::insert_or_assign(state_->functions, std::move(state)); detail::insert_or_assign(get_state().functions, std::move(state));
return *this; return *this;
} }
@@ -92,7 +86,7 @@ namespace meta_hpp
template < typename Type > template < typename Type >
scope_bind& scope_bind::typedef_(std::string name) { scope_bind& scope_bind::typedef_(std::string name) {
state_->typedefs.insert_or_assign(std::move(name), resolve_type<Type>()); get_state().typedefs.insert_or_assign(std::move(name), resolve_type<Type>());
return *this; return *this;
} }
@@ -120,7 +114,7 @@ namespace meta_hpp
std::move(name), std::move(name),
std::move(pointer), std::move(pointer),
std::move(opts.metadata)); std::move(opts.metadata));
detail::insert_or_assign(state_->variables, std::move(state)); detail::insert_or_assign(get_state().variables, std::move(state));
return *this; return *this;
} }
} }

9
headers/meta.hpp/meta_binds/void_bind.hpp
View File

@@ -14,12 +14,5 @@ namespace meta_hpp
{ {
template < detail::void_kind Void > template < detail::void_kind Void >
void_bind<Void>::void_bind(metadata_map metadata) void_bind<Void>::void_bind(metadata_map metadata)
: data_{detail::type_access(resolve_type<void>())} { : type_bind_base{resolve_type<Void>(), std::move(metadata)} {}
detail::insert_or_assign(data_->metadata, std::move(metadata));
}
template < detail::void_kind Void >
void_bind<Void>::operator void_type() const noexcept {
return void_type{data_};
}
} }

2
headers/meta.hpp/meta_detail/state_family.hpp
View File

@@ -23,7 +23,7 @@ namespace meta_hpp::detail
std::is_same_v<T, variable>; std::is_same_v<T, variable>;
template < state_family T > template < state_family T >
[[nodiscard]] auto state_access(const T& state) { [[nodiscard]] typename T::state_ptr state_access(const T& state) {
return state.state_; return state.state_;
} }
} }

6
headers/meta.hpp/meta_detail/state_registry.hpp
View File

@@ -49,8 +49,10 @@ namespace meta_hpp::detail
return iter->second; return iter->second;
} }
auto state = scope_state::make(std::string{name}); auto&& [iter, _] = scopes_.insert_or_assign(
auto&& [iter, _] = scopes_.insert_or_assign(std::string{name}, std::move(state)); std::string{name},
scope_state::make(std::string{name}, metadata_map{}));
return iter->second; return iter->second;
} }
private: private:

2
headers/meta.hpp/meta_detail/type_family.hpp
View File

@@ -28,7 +28,7 @@ namespace meta_hpp::detail
std::is_same_v<T, void_type>; std::is_same_v<T, void_type>;
template < type_family T > template < type_family T >
[[nodiscard]] auto type_access(const T& type) { [[nodiscard]] typename T::data_ptr type_access(const T& type) {
return type.data_; return type.data_;
} }
} }

92
headers/meta.hpp/meta_states.hpp
View File

@@ -106,10 +106,10 @@ namespace meta_hpp
class argument final { class argument final {
public: public:
using index_type = argument_index; using index_type = argument_index;
using state_ptr = detail::argument_state_ptr;
explicit argument() = default; argument() = default;
explicit argument(detail::argument_state_ptr state) noexcept; argument(state_ptr state) noexcept;
argument& operator=(detail::argument_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -122,17 +122,17 @@ namespace meta_hpp
[[nodiscard]] const std::string& get_name() const noexcept; [[nodiscard]] const std::string& get_name() const noexcept;
private: private:
detail::argument_state_ptr state_; state_ptr state_;
friend auto detail::state_access<argument>(const argument&); friend state_ptr detail::state_access<argument>(const argument&);
}; };
class constructor final { class constructor final {
public: public:
using index_type = constructor_index; using index_type = constructor_index;
using state_ptr = detail::constructor_state_ptr;
explicit constructor() = default; constructor() = default;
constructor(detail::constructor_state_ptr state) noexcept; constructor(state_ptr state) noexcept;
constructor& operator=(detail::constructor_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -157,17 +157,17 @@ namespace meta_hpp
[[nodiscard]] argument get_argument(std::size_t position) const noexcept; [[nodiscard]] argument get_argument(std::size_t position) const noexcept;
[[nodiscard]] const argument_list& get_arguments() const noexcept; [[nodiscard]] const argument_list& get_arguments() const noexcept;
private: private:
detail::constructor_state_ptr state_; state_ptr state_;
friend auto detail::state_access<constructor>(const constructor&); friend state_ptr detail::state_access<constructor>(const constructor&);
}; };
class destructor final { class destructor final {
public: public:
using index_type = destructor_index; using index_type = destructor_index;
using state_ptr = detail::destructor_state_ptr;
explicit destructor() = default; destructor() = default;
destructor(detail::destructor_state_ptr state) noexcept; destructor(state_ptr state) noexcept;
destructor& operator=(detail::destructor_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -182,17 +182,17 @@ namespace meta_hpp
void destroy_at(void* mem) const; void destroy_at(void* mem) const;
private: private:
detail::destructor_state_ptr state_; state_ptr state_;
friend auto detail::state_access<destructor>(const destructor&); friend state_ptr detail::state_access<destructor>(const destructor&);
}; };
class evalue final { class evalue final {
public: public:
using index_type = evalue_index; using index_type = evalue_index;
using state_ptr = detail::evalue_state_ptr;
explicit evalue() = default; evalue() = default;
evalue(detail::evalue_state_ptr state) noexcept; evalue(state_ptr state) noexcept;
evalue& operator=(detail::evalue_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -212,17 +212,17 @@ namespace meta_hpp
template < typename T > template < typename T >
[[nodiscard]] T get_underlying_value_as() const; [[nodiscard]] T get_underlying_value_as() const;
private: private:
detail::evalue_state_ptr state_; state_ptr state_;
friend auto detail::state_access<evalue>(const evalue&); friend state_ptr detail::state_access<evalue>(const evalue&);
}; };
class function final { class function final {
public: public:
using index_type = function_index; using index_type = function_index;
using state_ptr = detail::function_state_ptr;
explicit function() = default; function() = default;
function(detail::function_state_ptr state) noexcept; function(state_ptr state) noexcept;
function& operator=(detail::function_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -248,17 +248,17 @@ namespace meta_hpp
[[nodiscard]] argument get_argument(std::size_t position) const noexcept; [[nodiscard]] argument get_argument(std::size_t position) const noexcept;
[[nodiscard]] const argument_list& get_arguments() const noexcept; [[nodiscard]] const argument_list& get_arguments() const noexcept;
private: private:
detail::function_state_ptr state_; state_ptr state_;
friend auto detail::state_access<function>(const function&); friend state_ptr detail::state_access<function>(const function&);
}; };
class member final { class member final {
public: public:
using index_type = member_index; using index_type = member_index;
using state_ptr = detail::member_state_ptr;
explicit member() = default; member() = default;
member(detail::member_state_ptr state) noexcept; member(state_ptr state) noexcept;
member& operator=(detail::member_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -296,17 +296,17 @@ namespace meta_hpp
template < typename Instance, typename Value > template < typename Instance, typename Value >
[[nodiscard]] bool is_settable_with(Instance&& instance, Value&& value) const noexcept; [[nodiscard]] bool is_settable_with(Instance&& instance, Value&& value) const noexcept;
private: private:
detail::member_state_ptr state_; state_ptr state_;
friend auto detail::state_access<member>(const member&); friend state_ptr detail::state_access<member>(const member&);
}; };
class method final { class method final {
public: public:
using index_type = method_index; using index_type = method_index;
using state_ptr = detail::method_state_ptr;
explicit method() = default; method() = default;
method(detail::method_state_ptr state) noexcept; method(state_ptr state) noexcept;
method& operator=(detail::method_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -332,17 +332,17 @@ namespace meta_hpp
[[nodiscard]] argument get_argument(std::size_t position) const noexcept; [[nodiscard]] argument get_argument(std::size_t position) const noexcept;
[[nodiscard]] const argument_list& get_arguments() const noexcept; [[nodiscard]] const argument_list& get_arguments() const noexcept;
private: private:
detail::method_state_ptr state_; state_ptr state_;
friend auto detail::state_access<method>(const method&); friend state_ptr detail::state_access<method>(const method&);
}; };
class scope final { class scope final {
public: public:
using index_type = scope_index; using index_type = scope_index;
using state_ptr = detail::scope_state_ptr;
explicit scope() = default; scope() = default;
explicit scope(detail::scope_state_ptr state) noexcept; scope(state_ptr state) noexcept;
scope& operator=(detail::scope_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -367,17 +367,17 @@ namespace meta_hpp
[[nodiscard]] function get_function_with(std::string_view name, std::span<const any_type> args) const noexcept; [[nodiscard]] function get_function_with(std::string_view name, std::span<const any_type> args) const noexcept;
[[nodiscard]] function get_function_with(std::string_view name, std::initializer_list<any_type> args) const noexcept; [[nodiscard]] function get_function_with(std::string_view name, std::initializer_list<any_type> args) const noexcept;
private: private:
detail::scope_state_ptr state_; state_ptr state_;
friend auto detail::state_access<scope>(const scope&); friend state_ptr detail::state_access<scope>(const scope&);
}; };
class variable final { class variable final {
public: public:
using index_type = variable_index; using index_type = variable_index;
using state_ptr = detail::variable_state_ptr;
explicit variable() = default; variable() = default;
variable(detail::variable_state_ptr state) noexcept; variable(state_ptr state) noexcept;
variable& operator=(detail::variable_state_ptr state) noexcept;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -407,8 +407,8 @@ namespace meta_hpp
template < typename Value > template < typename Value >
[[nodiscard]] bool is_settable_with(Value&& value) const noexcept; [[nodiscard]] bool is_settable_with(Value&& value) const noexcept;
private: private:
detail::variable_state_ptr state_; state_ptr state_;
friend auto detail::state_access<variable>(const variable&); friend state_ptr detail::state_access<variable>(const variable&);
}; };
} }
@@ -600,7 +600,7 @@ namespace meta_hpp::detail
typedef_map typedefs{}; typedef_map typedefs{};
variable_set variables{}; variable_set variables{};
[[nodiscard]] static scope_state_ptr make(std::string name); [[nodiscard]] static scope_state_ptr make(std::string name, metadata_map metadata);
}; };
struct variable_state final { struct variable_state final {

7
headers/meta.hpp/meta_states/argument.hpp
View File

@@ -23,14 +23,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline argument::argument(detail::argument_state_ptr state) noexcept inline argument::argument(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline argument& argument::operator=(detail::argument_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool argument::is_valid() const noexcept { inline bool argument::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/constructor.hpp
View File

@@ -142,14 +142,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline constructor::constructor(detail::constructor_state_ptr state) noexcept inline constructor::constructor(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline constructor& constructor::operator=(detail::constructor_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool constructor::is_valid() const noexcept { inline bool constructor::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/destructor.hpp
View File

@@ -64,14 +64,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline destructor::destructor(detail::destructor_state_ptr state) noexcept inline destructor::destructor(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline destructor& destructor::operator=(detail::destructor_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool destructor::is_valid() const noexcept { inline bool destructor::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/evalue.hpp
View File

@@ -26,14 +26,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline evalue::evalue(detail::evalue_state_ptr state) noexcept inline evalue::evalue(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline evalue& evalue::operator=(detail::evalue_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool evalue::is_valid() const noexcept { inline bool evalue::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/function.hpp
View File

@@ -124,14 +124,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline function::function(detail::function_state_ptr state) noexcept inline function::function(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline function& function::operator=(detail::function_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool function::is_valid() const noexcept { inline bool function::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/member.hpp
View File

@@ -161,14 +161,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline member::member(detail::member_state_ptr state) noexcept inline member::member(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline member& member::operator=(detail::member_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool member::is_valid() const noexcept { inline bool member::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/method.hpp
View File

@@ -135,14 +135,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline method::method(detail::method_state_ptr state) noexcept inline method::method(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline method& method::operator=(detail::method_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool method::is_valid() const noexcept { inline bool method::is_valid() const noexcept {
return !!state_; return !!state_;
} }

10
headers/meta.hpp/meta_states/scope.hpp
View File

@@ -19,23 +19,19 @@
namespace meta_hpp::detail namespace meta_hpp::detail
{ {
inline scope_state_ptr scope_state::make(std::string name) { inline scope_state_ptr scope_state::make(std::string name, metadata_map metadata) {
return std::make_shared<scope_state>(scope_state{ return std::make_shared<scope_state>(scope_state{
.index{scope_index::make(std::move(name))}, .index{scope_index::make(std::move(name))},
.metadata{std::move(metadata)},
}); });
} }
} }
namespace meta_hpp namespace meta_hpp
{ {
inline scope::scope(detail::scope_state_ptr state) noexcept inline scope::scope(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline scope& scope::operator=(detail::scope_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool scope::is_valid() const noexcept { inline bool scope::is_valid() const noexcept {
return !!state_; return !!state_;
} }

7
headers/meta.hpp/meta_states/variable.hpp
View File

@@ -109,14 +109,9 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline variable::variable(detail::variable_state_ptr state) noexcept inline variable::variable(state_ptr state) noexcept
: state_{std::move(state)} {} : state_{std::move(state)} {}
inline variable& variable::operator=(detail::variable_state_ptr state) noexcept {
state_ = std::move(state);
return *this;
}
inline bool variable::is_valid() const noexcept { inline bool variable::is_valid() const noexcept {
return !!state_; return !!state_;
} }

112
headers/meta.hpp/meta_types.hpp
View File

@@ -62,7 +62,9 @@ namespace meta_hpp
{ {
class any_type final { class any_type final {
public: public:
explicit any_type() = default; using data_ptr = detail::type_data_base*;
any_type() = default;
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -114,14 +116,16 @@ namespace meta_hpp
[[nodiscard]] reference_type as_reference() const noexcept; [[nodiscard]] reference_type as_reference() const noexcept;
[[nodiscard]] void_type as_void() const noexcept; [[nodiscard]] void_type as_void() const noexcept;
private: private:
detail::type_data_base* data_{}; data_ptr data_{};
friend auto detail::type_access<any_type>(const any_type&); friend data_ptr detail::type_access<any_type>(const any_type&);
}; };
class array_type final { class array_type final {
public: public:
using data_ptr = detail::array_type_data*;
array_type() = default; array_type() = default;
array_type(detail::array_type_data* data); array_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -133,14 +137,16 @@ namespace meta_hpp
[[nodiscard]] std::size_t get_extent() const noexcept; [[nodiscard]] std::size_t get_extent() const noexcept;
[[nodiscard]] any_type get_data_type() const noexcept; [[nodiscard]] any_type get_data_type() const noexcept;
private: private:
detail::array_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<array_type>(const array_type&); friend data_ptr detail::type_access<array_type>(const array_type&);
}; };
class class_type final { class class_type final {
public: public:
using data_ptr = detail::class_type_data*;
class_type() = default; class_type() = default;
class_type(detail::class_type_data* data); class_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -211,14 +217,16 @@ namespace meta_hpp
[[nodiscard]] method get_method_with(std::string_view name, std::span<const any_type> args) const noexcept; [[nodiscard]] method get_method_with(std::string_view name, std::span<const any_type> args) const noexcept;
[[nodiscard]] method get_method_with(std::string_view name, std::initializer_list<any_type> args) const noexcept; [[nodiscard]] method get_method_with(std::string_view name, std::initializer_list<any_type> args) const noexcept;
private: private:
detail::class_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<class_type>(const class_type&); friend data_ptr detail::type_access<class_type>(const class_type&);
}; };
class constructor_type final { class constructor_type final {
public: public:
using data_ptr = detail::constructor_type_data*;
constructor_type() = default; constructor_type() = default;
constructor_type(detail::constructor_type_data* data); constructor_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -232,14 +240,16 @@ namespace meta_hpp
[[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept; [[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept;
[[nodiscard]] const any_type_list& get_argument_types() const noexcept; [[nodiscard]] const any_type_list& get_argument_types() const noexcept;
private: private:
detail::constructor_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<constructor_type>(const constructor_type&); friend data_ptr detail::type_access<constructor_type>(const constructor_type&);
}; };
class destructor_type final { class destructor_type final {
public: public:
using data_ptr = detail::destructor_type_data*;
destructor_type() = default; destructor_type() = default;
destructor_type(detail::destructor_type_data* data); destructor_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -250,14 +260,16 @@ namespace meta_hpp
[[nodiscard]] any_type get_class_type() const noexcept; [[nodiscard]] any_type get_class_type() const noexcept;
private: private:
detail::destructor_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<destructor_type>(const destructor_type&); friend data_ptr detail::type_access<destructor_type>(const destructor_type&);
}; };
class enum_type final { class enum_type final {
public: public:
using data_ptr = detail::enum_type_data*;
enum_type() = default; enum_type() = default;
enum_type(detail::enum_type_data* data); enum_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -279,14 +291,16 @@ namespace meta_hpp
template < typename T > template < typename T >
[[nodiscard]] T name_to_value_as(std::string_view name) const; [[nodiscard]] T name_to_value_as(std::string_view name) const;
private: private:
detail::enum_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<enum_type>(const enum_type&); friend data_ptr detail::type_access<enum_type>(const enum_type&);
}; };
class function_type final { class function_type final {
public: public:
using data_ptr = detail::function_type_data*;
function_type() = default; function_type() = default;
function_type(detail::function_type_data* data); function_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -300,14 +314,16 @@ namespace meta_hpp
[[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept; [[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept;
[[nodiscard]] const any_type_list& get_argument_types() const noexcept; [[nodiscard]] const any_type_list& get_argument_types() const noexcept;
private: private:
detail::function_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<function_type>(const function_type&); friend data_ptr detail::type_access<function_type>(const function_type&);
}; };
class member_type final { class member_type final {
public: public:
using data_ptr = detail::member_type_data*;
member_type() = default; member_type() = default;
member_type(detail::member_type_data* data); member_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -319,14 +335,16 @@ namespace meta_hpp
[[nodiscard]] class_type get_owner_type() const noexcept; [[nodiscard]] class_type get_owner_type() const noexcept;
[[nodiscard]] any_type get_value_type() const noexcept; [[nodiscard]] any_type get_value_type() const noexcept;
private: private:
detail::member_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<member_type>(const member_type&); friend data_ptr detail::type_access<member_type>(const member_type&);
}; };
class method_type final { class method_type final {
public: public:
using data_ptr = detail::method_type_data*;
method_type() = default; method_type() = default;
method_type(detail::method_type_data* data); method_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -341,14 +359,16 @@ namespace meta_hpp
[[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept; [[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept;
[[nodiscard]] const any_type_list& get_argument_types() const noexcept; [[nodiscard]] const any_type_list& get_argument_types() const noexcept;
private: private:
detail::method_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<method_type>(const method_type&); friend data_ptr detail::type_access<method_type>(const method_type&);
}; };
class nullptr_type final { class nullptr_type final {
public: public:
using data_ptr = detail::nullptr_type_data*;
nullptr_type() = default; nullptr_type() = default;
nullptr_type(detail::nullptr_type_data* data); nullptr_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -356,14 +376,16 @@ namespace meta_hpp
[[nodiscard]] type_id get_id() const noexcept; [[nodiscard]] type_id get_id() const noexcept;
[[nodiscard]] const metadata_map& get_metadata() const noexcept; [[nodiscard]] const metadata_map& get_metadata() const noexcept;
private: private:
detail::nullptr_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<nullptr_type>(const nullptr_type&); friend data_ptr detail::type_access<nullptr_type>(const nullptr_type&);
}; };
class number_type final { class number_type final {
public: public:
using data_ptr = detail::number_type_data*;
number_type() = default; number_type() = default;
number_type(detail::number_type_data* data); number_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -375,14 +397,16 @@ namespace meta_hpp
[[nodiscard]] std::size_t get_size() const noexcept; [[nodiscard]] std::size_t get_size() const noexcept;
[[nodiscard]] std::size_t get_align() const noexcept; [[nodiscard]] std::size_t get_align() const noexcept;
private: private:
detail::number_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<number_type>(const number_type&); friend data_ptr detail::type_access<number_type>(const number_type&);
}; };
class pointer_type final { class pointer_type final {
public: public:
using data_ptr = detail::pointer_type_data*;
pointer_type() = default; pointer_type() = default;
pointer_type(detail::pointer_type_data* data); pointer_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -393,14 +417,16 @@ namespace meta_hpp
[[nodiscard]] any_type get_data_type() const noexcept; [[nodiscard]] any_type get_data_type() const noexcept;
private: private:
detail::pointer_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<pointer_type>(const pointer_type&); friend data_ptr detail::type_access<pointer_type>(const pointer_type&);
}; };
class reference_type final { class reference_type final {
public: public:
using data_ptr = detail::reference_type_data*;
reference_type() = default; reference_type() = default;
reference_type(detail::reference_type_data* data); reference_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -411,14 +437,16 @@ namespace meta_hpp
[[nodiscard]] any_type get_data_type() const noexcept; [[nodiscard]] any_type get_data_type() const noexcept;
private: private:
detail::reference_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<reference_type>(const reference_type&); friend data_ptr detail::type_access<reference_type>(const reference_type&);
}; };
class void_type final { class void_type final {
public: public:
using data_ptr = detail::void_type_data*;
void_type() = default; void_type() = default;
void_type(detail::void_type_data* data); void_type(data_ptr data);
[[nodiscard]] bool is_valid() const noexcept; [[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept; [[nodiscard]] explicit operator bool() const noexcept;
@@ -426,8 +454,8 @@ namespace meta_hpp
[[nodiscard]] type_id get_id() const noexcept; [[nodiscard]] type_id get_id() const noexcept;
[[nodiscard]] const metadata_map& get_metadata() const noexcept; [[nodiscard]] const metadata_map& get_metadata() const noexcept;
private: private:
detail::void_type_data* data_{}; data_ptr data_{};
friend auto detail::type_access<void_type>(const void_type&); friend data_ptr detail::type_access<void_type>(const void_type&);
}; };
} }

2
headers/meta.hpp/meta_types/array_type.hpp
View File

@@ -27,7 +27,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline array_type::array_type(detail::array_type_data* data) inline array_type::array_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool array_type::is_valid() const noexcept { inline bool array_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/class_type.hpp
View File

@@ -34,7 +34,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline class_type::class_type(detail::class_type_data* data) inline class_type::class_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool class_type::is_valid() const noexcept { inline bool class_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/constructor_type.hpp
View File

@@ -27,7 +27,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline constructor_type::constructor_type(detail::constructor_type_data* data) inline constructor_type::constructor_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool constructor_type::is_valid() const noexcept { inline bool constructor_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/destructor_type.hpp
View File

@@ -26,7 +26,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline destructor_type::destructor_type(detail::destructor_type_data* data) inline destructor_type::destructor_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool destructor_type::is_valid() const noexcept { inline bool destructor_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/enum_type.hpp
View File

@@ -29,7 +29,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline enum_type::enum_type(detail::enum_type_data* data) inline enum_type::enum_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool enum_type::is_valid() const noexcept { inline bool enum_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/function_type.hpp
View File

@@ -27,7 +27,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline function_type::function_type(detail::function_type_data* data) inline function_type::function_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool function_type::is_valid() const noexcept { inline bool function_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/member_type.hpp
View File

@@ -27,7 +27,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline member_type::member_type(detail::member_type_data* data) inline member_type::member_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool member_type::is_valid() const noexcept { inline bool member_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/method_type.hpp
View File

@@ -28,7 +28,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline method_type::method_type(detail::method_type_data* data) inline method_type::method_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool method_type::is_valid() const noexcept { inline bool method_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/nullptr_type.hpp
View File

@@ -22,7 +22,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline nullptr_type::nullptr_type(detail::nullptr_type_data* data) inline nullptr_type::nullptr_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool nullptr_type::is_valid() const noexcept { inline bool nullptr_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/number_type.hpp
View File

@@ -27,7 +27,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline number_type::number_type(detail::number_type_data* data) inline number_type::number_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool number_type::is_valid() const noexcept { inline bool number_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/pointer_type.hpp
View File

@@ -26,7 +26,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline pointer_type::pointer_type(detail::pointer_type_data* data) inline pointer_type::pointer_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool pointer_type::is_valid() const noexcept { inline bool pointer_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/reference_type.hpp
View File

@@ -26,7 +26,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline reference_type::reference_type(detail::reference_type_data* data) inline reference_type::reference_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool reference_type::is_valid() const noexcept { inline bool reference_type::is_valid() const noexcept {

2
headers/meta.hpp/meta_types/void_type.hpp
View File

@@ -22,7 +22,7 @@ namespace meta_hpp::detail
namespace meta_hpp namespace meta_hpp
{ {
inline void_type::void_type(detail::void_type_data* data) inline void_type::void_type(data_ptr data)
: data_{data} {} : data_{data} {}
inline bool void_type::is_valid() const noexcept { inline bool void_type::is_valid() const noexcept {