BlackMATov/meta.hpp
1
0
Fork 0
mirror of https://github.com/BlackMATov/meta.hpp.git synced 2025-12-14 19:41:29 +07:00
Code Issues Packages Projects Releases Wiki Activity

rename: ctor -> constructor, dtor -> destructor, parameter -> argument

Browse Source
This commit is contained in:
BlackMATov
2022-02-08 23:36:20 +07:00
parent 8e18c85823
commit 04fd737d62
38 changed files with 795 additions and 795 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
headers/meta.hpp/meta_all.hpp
View File

@@ -14,24 +14,24 @@
#include "meta_binds/scope_bind.hpp"
#include "meta_indices.hpp"
#include "meta_indices/ctor_index.hpp"
#include "meta_indices/dtor_index.hpp"
#include "meta_indices/argument_index.hpp"
#include "meta_indices/constructor_index.hpp"
#include "meta_indices/destructor_index.hpp"
#include "meta_indices/evalue_index.hpp"
#include "meta_indices/function_index.hpp"
#include "meta_indices/member_index.hpp"
#include "meta_indices/method_index.hpp"
#include "meta_indices/parameter_index.hpp"
#include "meta_indices/scope_index.hpp"
#include "meta_indices/variable_index.hpp"
#include "meta_states.hpp"
#include "meta_states/ctor.hpp"
#include "meta_states/dtor.hpp"
#include "meta_states/argument.hpp"
#include "meta_states/constructor.hpp"
#include "meta_states/destructor.hpp"
#include "meta_states/evalue.hpp"
#include "meta_states/function.hpp"
#include "meta_states/member.hpp"
#include "meta_states/method.hpp"
#include "meta_states/parameter.hpp"
#include "meta_states/scope.hpp"
#include "meta_states/variable.hpp"
@@ -39,8 +39,8 @@
#include "meta_types/any_type.hpp"
#include "meta_types/array_type.hpp"
#include "meta_types/class_type.hpp"
#include "meta_types/ctor_type.hpp"
#include "meta_types/dtor_type.hpp"
#include "meta_types/constructor_type.hpp"
#include "meta_types/destructor_type.hpp"
#include "meta_types/enum_type.hpp"
#include "meta_types/function_type.hpp"
#include "meta_types/member_type.hpp"

44
headers/meta.hpp/meta_base.hpp
View File

@@ -103,35 +103,35 @@ namespace meta_hpp
namespace meta_hpp
{
class ctor;
class dtor;
class argument;
class constructor;
class destructor;
class evalue;
class function;
class member;
class method;
class parameter;
class scope;
class variable;
namespace detail
{
struct ctor_state;
struct dtor_state;
struct argument_state;
struct constructor_state;
struct destructor_state;
struct evalue_state;
struct function_state;
struct member_state;
struct method_state;
struct parameter_state;
struct scope_state;
struct variable_state;
using ctor_state_ptr = std::shared_ptr<ctor_state>;
using dtor_state_ptr = std::shared_ptr<dtor_state>;
using argument_state_ptr = std::shared_ptr<argument_state>;
using constructor_state_ptr = std::shared_ptr<constructor_state>;
using destructor_state_ptr = std::shared_ptr<destructor_state>;
using evalue_state_ptr = std::shared_ptr<evalue_state>;
using function_state_ptr = std::shared_ptr<function_state>;
using member_state_ptr = std::shared_ptr<member_state>;
using method_state_ptr = std::shared_ptr<method_state>;
using parameter_state_ptr = std::shared_ptr<parameter_state>;
using scope_state_ptr = std::shared_ptr<scope_state>;
using variable_state_ptr = std::shared_ptr<variable_state>;
}
@@ -142,8 +142,8 @@ namespace meta_hpp
class any_type;
class array_type;
class class_type;
class ctor_type;
class dtor_type;
class constructor_type;
class destructor_type;
class enum_type;
class function_type;
class member_type;
@@ -159,8 +159,8 @@ namespace meta_hpp
struct type_data_base;
struct array_type_data;
struct class_type_data;
struct ctor_type_data;
struct dtor_type_data;
struct constructor_type_data;
struct destructor_type_data;
struct enum_type_data;
struct function_type_data;
struct member_type_data;
@@ -174,8 +174,8 @@ namespace meta_hpp
using type_data_base_ptr = std::shared_ptr<type_data_base>;
using array_type_data_ptr = std::shared_ptr<array_type_data>;
using class_type_data_ptr = std::shared_ptr<class_type_data>;
using ctor_type_data_ptr = std::shared_ptr<ctor_type_data>;
using dtor_type_data_ptr = std::shared_ptr<dtor_type_data>;
using constructor_type_data_ptr = std::shared_ptr<constructor_type_data>;
using destructor_type_data_ptr = std::shared_ptr<destructor_type_data>;
using enum_type_data_ptr = std::shared_ptr<enum_type_data>;
using function_type_data_ptr = std::shared_ptr<function_type_data>;
using member_type_data_ptr = std::shared_ptr<member_type_data>;
@@ -190,33 +190,33 @@ namespace meta_hpp
namespace meta_hpp
{
class ctor_index;
class dtor_index;
class argument_index;
class constructor_index;
class destructor_index;
class evalue_index;
class function_index;
class member_index;
class method_index;
class parameter_index;
class scope_index;
class variable_index;
}
namespace meta_hpp
{
using argument_list = std::vector<argument>;
using class_set = std::set<class_type, std::less<>>;
using class_map = std::map<std::string, class_type, std::less<>>;
using enum_set = std::set<enum_type, std::less<>>;
using enum_map = std::map<std::string, enum_type, std::less<>>;
using ctor_map = std::map<ctor_index, ctor, std::less<>>;
using dtor_map = std::map<dtor_index, dtor, std::less<>>;
using constructor_map = std::map<constructor_index, constructor, std::less<>>;
using destructor_map = std::map<destructor_index, destructor, std::less<>>;
using evalue_map = std::map<evalue_index, evalue, std::less<>>;
using function_map = std::map<function_index, function, std::less<>>;
using member_map = std::map<member_index, member, std::less<>>;
using method_map = std::map<method_index, method, std::less<>>;
using scope_map = std::map<scope_index, scope, std::less<>>;
using variable_map = std::map<variable_index, variable, std::less<>>;
using parameter_list = std::vector<parameter>;
}

4
headers/meta.hpp/meta_base/type_kinds.hpp
View File

@@ -50,8 +50,8 @@ namespace meta_hpp::detail
enum class type_kind : std::uint32_t {
array_,
class_,
ctor_,
dtor_,
constructor_,
destructor_,
enum_,
function_,
member_,

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

@@ -14,12 +14,12 @@ namespace meta_hpp
namespace detail
{
template < typename Class, typename... Args >
concept class_bind_ctor_kind =
concept class_bind_constructor_kind =
class_kind<Class> &&
requires(Args&&... args) { { Class{std::forward<Args>(args)...} }; };
template < typename Class >
concept class_bind_dtor_kind =
concept class_bind_destructor_kind =
class_kind<Class> &&
requires(Class&& inst) { { inst.~Class() }; };
@@ -46,19 +46,19 @@ namespace meta_hpp
operator class_type() const noexcept;
template < typename... Args
, ctor_policy_kind Policy = ctor_policy::as_object >
class_bind& ctor_(Policy = Policy{})
requires detail::class_bind_ctor_kind<Class, Args...>;
, constructor_policy_kind Policy = constructor_policy::as_object >
class_bind& constructor_(Policy = Policy{})
requires detail::class_bind_constructor_kind<Class, Args...>;
template < typename... Args
, ctor_policy_kind Policy = ctor_policy::as_object >
class_bind& ctor_(
std::initializer_list<std::string_view> pnames,
, constructor_policy_kind Policy = constructor_policy::as_object >
class_bind& constructor_(
std::initializer_list<std::string_view> anames,
Policy = Policy{})
requires detail::class_bind_ctor_kind<Class, Args...>;
requires detail::class_bind_constructor_kind<Class, Args...>;
class_bind& dtor_()
requires detail::class_bind_dtor_kind<Class>;
class_bind& destructor_()
requires detail::class_bind_destructor_kind<Class>;
template < detail::class_kind Base >
class_bind& base_()
@@ -73,7 +73,7 @@ namespace meta_hpp
class_bind& function_(
std::string name,
Function function,
std::initializer_list<std::string_view> pnames,
std::initializer_list<std::string_view> anames,
Policy = Policy{});
template < detail::member_kind Member
@@ -91,7 +91,7 @@ namespace meta_hpp
class_bind& method_(
std::string name,
Method method,
std::initializer_list<std::string_view> pnames,
std::initializer_list<std::string_view> anames,
Policy = Policy{})
requires detail::class_bind_method_kind<Class, Method>;
@@ -143,7 +143,7 @@ namespace meta_hpp
scope_bind& function_(
std::string name,
Function function,
std::initializer_list<std::string_view> pnames,
std::initializer_list<std::string_view> anames,
Policy = Policy{});
template < detail::pointer_kind Pointer

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

@@ -23,41 +23,41 @@ namespace meta_hpp
}
template < detail::class_kind Class >
template < typename... Args, ctor_policy_kind Policy >
class_bind<Class>& class_bind<Class>::ctor_(Policy policy)
requires detail::class_bind_ctor_kind<Class, Args...>
template < typename... Args, constructor_policy_kind Policy >
class_bind<Class>& class_bind<Class>::constructor_(Policy policy)
requires detail::class_bind_constructor_kind<Class, Args...>
{
return ctor_<Args...>({}, policy);
return constructor_<Args...>({}, policy);
}
template < detail::class_kind Class >
template < typename... Args, ctor_policy_kind Policy >
class_bind<Class>& class_bind<Class>::ctor_(
std::initializer_list<std::string_view> pnames,
template < typename... Args, constructor_policy_kind Policy >
class_bind<Class>& class_bind<Class>::constructor_(
std::initializer_list<std::string_view> anames,
[[maybe_unused]] Policy policy)
requires detail::class_bind_ctor_kind<Class, Args...>
requires detail::class_bind_constructor_kind<Class, Args...>
{
auto ctor_state = detail::ctor_state::make<Policy, Class, Args...>();
auto constructor_state = detail::constructor_state::make<Policy, Class, Args...>();
if ( pnames.size() > ctor_state->parameters.size() ) {
detail::throw_exception_with("provided parameter names don't match constructor argument count");
if ( anames.size() > constructor_state->arguments.size() ) {
detail::throw_exception_with("provided argument names don't match constructor argument count");
}
for ( std::size_t i = 0; i < pnames.size(); ++i ) {
parameter& param = ctor_state->parameters[i];
detail::state_access(param)->name = std::string{std::data(pnames)[i]};
for ( std::size_t i = 0; i < anames.size(); ++i ) {
argument& arg = constructor_state->arguments[i];
detail::state_access(arg)->name = std::string{std::data(anames)[i]};
}
data_->ctors.emplace(ctor_state->index, std::move(ctor_state));
data_->constructors.emplace(constructor_state->index, std::move(constructor_state));
return *this;
}
template < detail::class_kind Class >
class_bind<Class>& class_bind<Class>::dtor_()
requires detail::class_bind_dtor_kind<Class>
class_bind<Class>& class_bind<Class>::destructor_()
requires detail::class_bind_destructor_kind<Class>
{
auto dtor_state = detail::dtor_state::make<Class>();
data_->dtors.emplace(dtor_state->index, std::move(dtor_state));
auto destructor_state = detail::destructor_state::make<Class>();
data_->destructors.emplace(destructor_state->index, std::move(destructor_state));
return *this;
}
@@ -86,18 +86,18 @@ namespace meta_hpp
class_bind<Class>& class_bind<Class>::function_(
std::string name,
Function function,
std::initializer_list<std::string_view> pnames,
std::initializer_list<std::string_view> anames,
[[maybe_unused]] Policy policy)
{
auto function_state = detail::function_state::make<Policy>(std::move(name), std::move(function));
if ( pnames.size() > function_state->parameters.size() ) {
detail::throw_exception_with("provided parameter names don't match function argument count");
if ( anames.size() > function_state->arguments.size() ) {
detail::throw_exception_with("provided argument names don't match function argument count");
}
for ( std::size_t i = 0; i < pnames.size(); ++i ) {
parameter& param = function_state->parameters[i];
detail::state_access(param)->name = std::string{std::data(pnames)[i]};
for ( std::size_t i = 0; i < anames.size(); ++i ) {
argument& arg = function_state->arguments[i];
detail::state_access(arg)->name = std::string{std::data(anames)[i]};
}
data_->functions.emplace(function_state->index, std::move(function_state));
@@ -127,19 +127,19 @@ namespace meta_hpp
class_bind<Class>& class_bind<Class>::method_(
std::string name,
Method method,
std::initializer_list<std::string_view> pnames,
std::initializer_list<std::string_view> anames,
[[maybe_unused]] Policy policy)
requires detail::class_bind_method_kind<Class, Method>
{
auto method_state = detail::method_state::make<Policy>(std::move(name), std::move(method));
if ( pnames.size() > method_state->parameters.size() ) {
detail::throw_exception_with("provided parameter names don't match method argument count");
if ( anames.size() > method_state->arguments.size() ) {
detail::throw_exception_with("provided argument names don't match method argument count");
}
for ( std::size_t i = 0; i < pnames.size(); ++i ) {
parameter& param = method_state->parameters[i];
detail::state_access(param)->name = std::string{std::data(pnames)[i]};
for ( std::size_t i = 0; i < anames.size(); ++i ) {
argument& arg = method_state->arguments[i];
detail::state_access(arg)->name = std::string{std::data(anames)[i]};
}
data_->methods.emplace(method_state->index, std::move(method_state));

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

@@ -47,18 +47,18 @@ namespace meta_hpp
scope_bind& scope_bind::function_(
std::string name,
Function function,
std::initializer_list<std::string_view> pnames,
std::initializer_list<std::string_view> anames,
[[maybe_unused]] Policy policy)
{
auto function_state = detail::function_state::make<Policy>(std::move(name), std::move(function));
if ( pnames.size() > function_state->parameters.size() ) {
detail::throw_exception_with("provided parameter names don't match function argument count");
if ( anames.size() > function_state->arguments.size() ) {
detail::throw_exception_with("provided argument names don't match function argument count");
}
for ( std::size_t i = 0; i < pnames.size(); ++i ) {
parameter& param = function_state->parameters[i];
detail::state_access(param)->name = std::string{std::data(pnames)[i]};
for ( std::size_t i = 0; i < anames.size(); ++i ) {
argument& arg = function_state->arguments[i];
detail::state_access(arg)->name = std::string{std::data(anames)[i]};
}
state_->functions.emplace(function_state->index, std::move(function_state));

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

@@ -12,13 +12,13 @@ namespace meta_hpp::detail
{
template < typename T >
inline constexpr bool is_state_family_v =
std::is_same_v<T, ctor> ||
std::is_same_v<T, dtor> ||
std::is_same_v<T, argument> ||
std::is_same_v<T, constructor> ||
std::is_same_v<T, destructor> ||
std::is_same_v<T, evalue> ||
std::is_same_v<T, function> ||
std::is_same_v<T, member> ||
std::is_same_v<T, method> ||
std::is_same_v<T, parameter> ||
std::is_same_v<T, scope> ||
std::is_same_v<T, variable>;

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

@@ -15,8 +15,8 @@ namespace meta_hpp::detail
std::is_same_v<T, any_type> ||
std::is_same_v<T, array_type> ||
std::is_same_v<T, class_type> ||
std::is_same_v<T, ctor_type> ||
std::is_same_v<T, dtor_type> ||
std::is_same_v<T, constructor_type> ||
std::is_same_v<T, destructor_type> ||
std::is_same_v<T, enum_type> ||
std::is_same_v<T, function_type> ||
std::is_same_v<T, member_type> ||

20
headers/meta.hpp/meta_detail/type_registry.hpp
View File

@@ -82,10 +82,10 @@ namespace meta_hpp::detail
[[nodiscard]] class_type resolve_class_type() { return class_type{resolve_class_type_data<Class>()}; }
template < class_kind Class, typename... Args >
[[nodiscard]] ctor_type resolve_ctor_type() { return ctor_type{resolve_ctor_type_data<Class, Args...>()}; }
[[nodiscard]] constructor_type resolve_constructor_type() { return constructor_type{resolve_constructor_type_data<Class, Args...>()}; }
template < class_kind Class >
[[nodiscard]] dtor_type resolve_dtor_type() { return dtor_type{resolve_dtor_type_data<Class>()}; }
[[nodiscard]] destructor_type resolve_destructor_type() { return destructor_type{resolve_destructor_type_data<Class>()}; }
template < enum_kind Enum >
[[nodiscard]] enum_type resolve_enum_type() { return enum_type{resolve_enum_type_data<Enum>()}; }
@@ -131,14 +131,14 @@ namespace meta_hpp::detail
}
template < class_kind Class, typename... Args >
[[nodiscard]] ctor_type_data_ptr resolve_ctor_type_data() {
static ctor_type_data_ptr data{std::make_shared<ctor_type_data>(type_list<Class>{}, type_list<Args...>{})};
[[nodiscard]] constructor_type_data_ptr resolve_constructor_type_data() {
static constructor_type_data_ptr data{std::make_shared<constructor_type_data>(type_list<Class>{}, type_list<Args...>{})};
return data;
}
template < class_kind Class >
[[nodiscard]] dtor_type_data_ptr resolve_dtor_type_data() {
static dtor_type_data_ptr data{std::make_shared<dtor_type_data>(type_list<Class>{})};
[[nodiscard]] destructor_type_data_ptr resolve_destructor_type_data() {
static destructor_type_data_ptr data{std::make_shared<destructor_type_data>(type_list<Class>{})};
return data;
}
@@ -234,15 +234,15 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < class_kind Class, typename... Args >
ctor_type resolve_ctor_type() {
constructor_type resolve_constructor_type() {
type_registry& registry = type_registry::instance();
return registry.resolve_ctor_type<Class, Args...>();
return registry.resolve_constructor_type<Class, Args...>();
}
template < class_kind Class >
dtor_type resolve_dtor_type() {
destructor_type resolve_destructor_type() {
type_registry& registry = type_registry::instance();
return registry.resolve_dtor_type<Class>();
return registry.resolve_destructor_type<Class>();
}
}

14
headers/meta.hpp/meta_detail/type_traits/ctor_traits.hpp → headers/meta.hpp/meta_detail/type_traits/constructor_traits.hpp
View File

@@ -10,28 +10,28 @@
namespace meta_hpp::detail
{
enum class ctor_flags : std::uint32_t {
enum class constructor_flags : std::uint32_t {
is_noexcept = 1 << 0,
};
ENUM_HPP_OPERATORS_DECL(ctor_flags)
using ctor_bitflags = bitflags<ctor_flags>;
ENUM_HPP_OPERATORS_DECL(constructor_flags)
using constructor_bitflags = bitflags<constructor_flags>;
}
namespace meta_hpp::detail
{
template < class_kind Class, typename... Args >
struct ctor_traits {
struct constructor_traits {
static constexpr std::size_t arity{sizeof...(Args)};
using class_type = Class;
using argument_types = type_list<Args...>;
[[nodiscard]] static constexpr ctor_bitflags make_flags() noexcept {
ctor_bitflags flags{};
[[nodiscard]] static constexpr constructor_bitflags make_flags() noexcept {
constructor_bitflags flags{};
if constexpr ( std::is_nothrow_constructible_v<Class, Args...> ) {
flags.set(ctor_flags::is_noexcept);
flags.set(constructor_flags::is_noexcept);
}
return flags;

14
headers/meta.hpp/meta_detail/type_traits/dtor_traits.hpp → headers/meta.hpp/meta_detail/type_traits/destructor_traits.hpp
View File

@@ -10,25 +10,25 @@
namespace meta_hpp::detail
{
enum class dtor_flags : std::uint32_t {
enum class destructor_flags : std::uint32_t {
is_noexcept = 1 << 0,
};
ENUM_HPP_OPERATORS_DECL(dtor_flags)
using dtor_bitflags = bitflags<dtor_flags>;
ENUM_HPP_OPERATORS_DECL(destructor_flags)
using destructor_bitflags = bitflags<destructor_flags>;
}
namespace meta_hpp::detail
{
template < class_kind Class >
struct dtor_traits {
struct destructor_traits {
using class_type = Class;
[[nodiscard]] static constexpr dtor_bitflags make_flags() noexcept {
dtor_bitflags flags{};
[[nodiscard]] static constexpr destructor_bitflags make_flags() noexcept {
destructor_bitflags flags{};
if constexpr ( std::is_nothrow_destructible_v<Class> ) {
flags.set(dtor_flags::is_noexcept);
flags.set(destructor_flags::is_noexcept);
}
return flags;

74
headers/meta.hpp/meta_indices.hpp
View File

@@ -11,36 +11,54 @@
namespace meta_hpp
{
class ctor_index final {
class argument_index final {
public:
ctor_index() = delete;
[[nodiscard]] const ctor_type& get_type() const noexcept;
argument_index() = delete;
[[nodiscard]] const any_type& get_type() const noexcept;
[[nodiscard]] std::size_t get_position() const noexcept;
private:
friend detail::ctor_state;
template < detail::class_kind Class, typename... Args >
[[nodiscard]] static ctor_index make();
friend detail::argument_state;
template < typename Argument >
[[nodiscard]] static argument_index make(std::size_t position);
private:
explicit ctor_index(ctor_type type);
friend bool operator<(const ctor_index& l, const ctor_index& r) noexcept;
friend bool operator==(const ctor_index& l, const ctor_index& r) noexcept;
explicit argument_index(any_type type, std::size_t position);
friend bool operator<(const argument_index& l, const argument_index& r) noexcept;
friend bool operator==(const argument_index& l, const argument_index& r) noexcept;
private:
ctor_type type_;
any_type type_;
std::size_t position_{};
};
class dtor_index final {
class constructor_index final {
public:
dtor_index() = delete;
[[nodiscard]] const dtor_type& get_type() const noexcept;
constructor_index() = delete;
[[nodiscard]] const constructor_type& get_type() const noexcept;
private:
friend detail::dtor_state;
friend detail::constructor_state;
template < detail::class_kind Class, typename... Args >
[[nodiscard]] static constructor_index make();
private:
explicit constructor_index(constructor_type type);
friend bool operator<(const constructor_index& l, const constructor_index& r) noexcept;
friend bool operator==(const constructor_index& l, const constructor_index& r) noexcept;
private:
constructor_type type_;
};
class destructor_index final {
public:
destructor_index() = delete;
[[nodiscard]] const destructor_type& get_type() const noexcept;
private:
friend detail::destructor_state;
template < detail::class_kind Class >
[[nodiscard]] static dtor_index make();
[[nodiscard]] static destructor_index make();
private:
explicit dtor_index(dtor_type type);
friend bool operator<(const dtor_index& l, const dtor_index& r) noexcept;
friend bool operator==(const dtor_index& l, const dtor_index& r) noexcept;
explicit destructor_index(destructor_type type);
friend bool operator<(const destructor_index& l, const destructor_index& r) noexcept;
friend bool operator==(const destructor_index& l, const destructor_index& r) noexcept;
private:
dtor_type type_;
destructor_type type_;
};
class evalue_index final {
@@ -115,24 +133,6 @@ namespace meta_hpp
std::string name_;
};
class parameter_index final {
public:
parameter_index() = delete;
[[nodiscard]] const any_type& get_type() const noexcept;
[[nodiscard]] std::size_t get_position() const noexcept;
private:
friend detail::parameter_state;
template < typename Parameter >
[[nodiscard]] static parameter_index make(std::size_t position);
private:
explicit parameter_index(any_type type, std::size_t position);
friend bool operator<(const parameter_index& l, const parameter_index& r) noexcept;
friend bool operator==(const parameter_index& l, const parameter_index& r) noexcept;
private:
any_type type_;
std::size_t position_{};
};
class scope_index final {
public:
scope_index() = delete;

16
headers/meta.hpp/meta_indices/parameter_index.hpp → headers/meta.hpp/meta_indices/argument_index.hpp
View File

@@ -14,28 +14,28 @@
namespace meta_hpp
{
inline parameter_index::parameter_index(any_type type, std::size_t position)
inline argument_index::argument_index(any_type type, std::size_t position)
: type_{std::move(type)}
, position_{position} {}
template < typename Parameter >
inline parameter_index parameter_index::make(std::size_t position) {
return parameter_index{detail::resolve_type<Parameter>(), position};
template < typename Argument >
inline argument_index argument_index::make(std::size_t position) {
return argument_index{detail::resolve_type<Argument>(), position};
}
inline const any_type& parameter_index::get_type() const noexcept {
inline const any_type& argument_index::get_type() const noexcept {
return type_;
}
inline std::size_t parameter_index::get_position() const noexcept {
inline std::size_t argument_index::get_position() const noexcept {
return position_;
}
inline bool operator<(const parameter_index& l, const parameter_index& r) noexcept {
inline bool operator<(const argument_index& l, const argument_index& r) noexcept {
return l.type_ < r.type_ || (l.type_ == r.type_ && l.position_ < r.position_);
}
inline bool operator==(const parameter_index& l, const parameter_index& r) noexcept {
inline bool operator==(const argument_index& l, const argument_index& r) noexcept {
return l.type_ == r.type_ && l.position_ == r.position_;
}
}

12
headers/meta.hpp/meta_indices/ctor_index.hpp → headers/meta.hpp/meta_indices/constructor_index.hpp
View File

@@ -14,23 +14,23 @@
namespace meta_hpp
{
inline ctor_index::ctor_index(ctor_type type)
inline constructor_index::constructor_index(constructor_type type)
: type_{std::move(type)} {}
template < detail::class_kind Class, typename... Args >
ctor_index ctor_index::make() {
return ctor_index{detail::resolve_ctor_type<Class, Args...>()};
constructor_index constructor_index::make() {
return constructor_index{detail::resolve_constructor_type<Class, Args...>()};
}
inline const ctor_type& ctor_index::get_type() const noexcept {
inline const constructor_type& constructor_index::get_type() const noexcept {
return type_;
}
inline bool operator<(const ctor_index& l, const ctor_index& r) noexcept {
inline bool operator<(const constructor_index& l, const constructor_index& r) noexcept {
return l.type_ < r.type_;
}
inline bool operator==(const ctor_index& l, const ctor_index& r) noexcept {
inline bool operator==(const constructor_index& l, const constructor_index& r) noexcept {
return l.type_ == r.type_;
}
}

12
headers/meta.hpp/meta_indices/dtor_index.hpp → headers/meta.hpp/meta_indices/destructor_index.hpp
View File

@@ -14,23 +14,23 @@
namespace meta_hpp
{
inline dtor_index::dtor_index(dtor_type type)
inline destructor_index::destructor_index(destructor_type type)
: type_{std::move(type)} {}
template < detail::class_kind Class >
dtor_index dtor_index::make() {
return dtor_index{detail::resolve_dtor_type<Class>()};
destructor_index destructor_index::make() {
return destructor_index{detail::resolve_destructor_type<Class>()};
}
inline const dtor_type& dtor_index::get_type() const noexcept {
inline const destructor_type& destructor_index::get_type() const noexcept {
return type_;
}
inline bool operator<(const dtor_index& l, const dtor_index& r) noexcept {
inline bool operator<(const destructor_index& l, const destructor_index& r) noexcept {
return l.type_ < r.type_;
}
inline bool operator==(const dtor_index& l, const dtor_index& r) noexcept {
inline bool operator==(const destructor_index& l, const destructor_index& r) noexcept {
return l.type_ == r.type_;
}
}

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

@@ -15,7 +15,7 @@
namespace meta_hpp
{
namespace ctor_policy
namespace constructor_policy
{
struct as_object final {};
struct as_raw_pointer final {};
@@ -51,10 +51,10 @@ namespace meta_hpp
}
template < typename Policy >
inline constexpr bool is_ctor_policy_v =
std::is_same_v<Policy, ctor_policy::as_object> ||
std::is_same_v<Policy, ctor_policy::as_raw_pointer> ||
std::is_same_v<Policy, ctor_policy::as_shared_pointer>;
inline constexpr bool is_constructor_policy_v =
std::is_same_v<Policy, constructor_policy::as_object> ||
std::is_same_v<Policy, constructor_policy::as_raw_pointer> ||
std::is_same_v<Policy, constructor_policy::as_shared_pointer>;
template < typename Policy >
inline constexpr bool is_function_policy_v =
@@ -81,7 +81,7 @@ namespace meta_hpp
std::is_same_v<Policy, variable_policy::as_reference_wrapper>;
template < typename Policy >
concept ctor_policy_kind = is_ctor_policy_v<Policy>;
concept constructor_policy_kind = is_constructor_policy_v<Policy>;
template < typename Policy >
concept function_policy_kind = is_function_policy_v<Policy>;
@@ -98,16 +98,33 @@ namespace meta_hpp
namespace meta_hpp
{
class ctor final {
class argument final {
public:
explicit ctor() = default;
explicit ctor(detail::ctor_state_ptr state);
explicit argument() = default;
explicit argument(detail::argument_state_ptr state);
[[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept;
[[nodiscard]] const ctor_index& get_index() const noexcept;
[[nodiscard]] const ctor_type& get_type() const noexcept;
[[nodiscard]] const argument_index& get_index() const noexcept;
[[nodiscard]] const any_type& get_type() const noexcept;
[[nodiscard]] std::size_t get_position() const noexcept;
[[nodiscard]] const std::string& get_name() const noexcept;
private:
detail::argument_state_ptr state_;
friend auto detail::state_access<argument>(const argument&);
};
class constructor final {
public:
explicit constructor() = default;
explicit constructor(detail::constructor_state_ptr state);
[[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept;
[[nodiscard]] const constructor_index& get_index() const noexcept;
[[nodiscard]] const constructor_type& get_type() const noexcept;
template < typename... Args >
uvalue invoke(Args&&... args) const;
@@ -121,23 +138,23 @@ namespace meta_hpp
template < typename... Args >
[[nodiscard]] bool is_invocable_with(Args&&... args) const noexcept;
[[nodiscard]] parameter get_parameter(std::size_t position) const noexcept;
[[nodiscard]] const parameter_list& get_parameters() const noexcept;
[[nodiscard]] argument get_argument(std::size_t position) const noexcept;
[[nodiscard]] const argument_list& get_arguments() const noexcept;
private:
detail::ctor_state_ptr state_;
friend auto detail::state_access<ctor>(const ctor&);
detail::constructor_state_ptr state_;
friend auto detail::state_access<constructor>(const constructor&);
};
class dtor final {
class destructor final {
public:
explicit dtor() = default;
explicit dtor(detail::dtor_state_ptr state);
explicit destructor() = default;
explicit destructor(detail::destructor_state_ptr state);
[[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept;
[[nodiscard]] const dtor_index& get_index() const noexcept;
[[nodiscard]] const dtor_type& get_type() const noexcept;
[[nodiscard]] const destructor_index& get_index() const noexcept;
[[nodiscard]] const destructor_type& get_type() const noexcept;
template < typename Arg >
void invoke(Arg&& ptr) const;
@@ -151,8 +168,8 @@ namespace meta_hpp
template < typename Arg >
[[nodiscard]] bool is_invocable_with(Arg&& ptr) const noexcept;
private:
detail::dtor_state_ptr state_;
friend auto detail::state_access<dtor>(const dtor&);
detail::destructor_state_ptr state_;
friend auto detail::state_access<destructor>(const destructor&);
};
class evalue final {
@@ -198,8 +215,8 @@ namespace meta_hpp
template < typename... Args >
[[nodiscard]] bool is_invocable_with(Args&&... args) const noexcept;
[[nodiscard]] parameter get_parameter(std::size_t position) const noexcept;
[[nodiscard]] const parameter_list& get_parameters() const noexcept;
[[nodiscard]] argument get_argument(std::size_t position) const noexcept;
[[nodiscard]] const argument_list& get_arguments() const noexcept;
private:
detail::function_state_ptr state_;
friend auto detail::state_access<function>(const function&);
@@ -269,30 +286,13 @@ namespace meta_hpp
template < typename Instance, typename... Args >
[[nodiscard]] bool is_invocable_with(Instance&& instance, Args&&... args) const noexcept;
[[nodiscard]] parameter get_parameter(std::size_t position) const noexcept;
[[nodiscard]] const parameter_list& get_parameters() const noexcept;
[[nodiscard]] argument get_argument(std::size_t position) const noexcept;
[[nodiscard]] const argument_list& get_arguments() const noexcept;
private:
detail::method_state_ptr state_;
friend auto detail::state_access<method>(const method&);
};
class parameter final {
public:
explicit parameter() = default;
explicit parameter(detail::parameter_state_ptr state);
[[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept;
[[nodiscard]] const parameter_index& get_index() const noexcept;
[[nodiscard]] const any_type& get_type() const noexcept;
[[nodiscard]] std::size_t get_position() const noexcept;
[[nodiscard]] const std::string& get_name() const noexcept;
private:
detail::parameter_state_ptr state_;
friend auto detail::state_access<parameter>(const parameter&);
};
class scope final {
public:
explicit scope() = default;
@@ -394,30 +394,30 @@ namespace meta_hpp
namespace meta_hpp::detail
{
struct ctor_state final {
struct constructor_state final {
using invoke_impl = fixed_function<uvalue(std::span<const uarg>)>;
using is_invocable_with_impl = fixed_function<bool(std::span<const uarg_base>)>;
ctor_index index;
constructor_index index;
invoke_impl invoke;
is_invocable_with_impl is_invocable_with;
parameter_list parameters;
argument_list arguments;
template < ctor_policy_kind Policy, class_kind Class, typename... Args >
[[nodiscard]] static ctor_state_ptr make();
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
[[nodiscard]] static constructor_state_ptr make();
};
struct dtor_state final {
struct destructor_state final {
using invoke_impl = fixed_function<void(const uarg&)>;
using is_invocable_with_impl = fixed_function<bool(const uarg_base&)>;
dtor_index index;
destructor_index index;
invoke_impl invoke;
is_invocable_with_impl is_invocable_with;
template < class_kind Class >
[[nodiscard]] static dtor_state_ptr make();
[[nodiscard]] static destructor_state_ptr make();
};
struct evalue_state final {
@@ -437,7 +437,7 @@ namespace meta_hpp::detail
invoke_impl invoke;
is_invocable_with_impl is_invocable_with;
parameter_list parameters;
argument_list arguments;
template < function_policy_kind Policy, function_kind Function >
[[nodiscard]] static function_state_ptr make(std::string name, Function function);
@@ -468,19 +468,19 @@ namespace meta_hpp::detail
invoke_impl invoke;
is_invocable_with_impl is_invocable_with;
parameter_list parameters;
argument_list arguments;
template < method_policy_kind Policy, method_kind Method >
[[nodiscard]] static method_state_ptr make(std::string name, Method method);
};
struct parameter_state final {
parameter_index index;
struct argument_state final {
argument_index index;
std::string name{};
template < typename Parameter >
[[nodiscard]] static parameter_state_ptr make(std::size_t position);
template < typename Argument >
[[nodiscard]] static argument_state_ptr make(std::size_t position);
};
struct scope_state final {

22
headers/meta.hpp/meta_states/parameter.hpp → headers/meta.hpp/meta_states/argument.hpp
View File

@@ -11,10 +11,10 @@
namespace meta_hpp::detail
{
template < typename Parameter >
inline parameter_state_ptr parameter_state::make(std::size_t position) {
return std::make_shared<parameter_state>(parameter_state{
.index{parameter_index::make<Parameter>(position)},
template < typename Argument >
inline argument_state_ptr argument_state::make(std::size_t position) {
return std::make_shared<argument_state>(argument_state{
.index{argument_index::make<Argument>(position)},
});
}
}
@@ -22,30 +22,30 @@ namespace meta_hpp::detail
namespace meta_hpp
{
inline parameter::parameter(detail::parameter_state_ptr state)
inline argument::argument(detail::argument_state_ptr state)
: state_{std::move(state)} {}
inline bool parameter::is_valid() const noexcept {
inline bool argument::is_valid() const noexcept {
return !!state_;
}
inline parameter::operator bool() const noexcept {
inline argument::operator bool() const noexcept {
return is_valid();
}
inline const parameter_index& parameter::get_index() const noexcept {
inline const argument_index& argument::get_index() const noexcept {
return state_->index;
}
inline const any_type& parameter::get_type() const noexcept {
inline const any_type& argument::get_type() const noexcept {
return state_->index.get_type();
}
inline std::size_t parameter::get_position() const noexcept {
inline std::size_t argument::get_position() const noexcept {
return state_->index.get_position();
}
inline const std::string& parameter::get_name() const noexcept {
inline const std::string& argument::get_name() const noexcept {
return state_->name;
}
}

84
headers/meta.hpp/meta_states/ctor.hpp → headers/meta.hpp/meta_states/constructor.hpp
View File

@@ -9,26 +9,26 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_types/ctor_type.hpp"
#include "../meta_types/constructor_type.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
namespace meta_hpp::detail
{
template < ctor_policy_kind Policy, class_kind Class, typename... Args >
uvalue raw_ctor_invoke(std::span<const uarg> args) {
using ct = ctor_traits<Class, Args...>;
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
uvalue raw_constructor_invoke(std::span<const uarg> args) {
using ct = constructor_traits<Class, Args...>;
using class_type = typename ct::class_type;
using argument_types = typename ct::argument_types;
constexpr bool as_object =
stdex::copy_constructible<class_type> &&
stdex::same_as<Policy, ctor_policy::as_object>;
stdex::same_as<Policy, constructor_policy::as_object>;
constexpr bool as_raw_ptr =
stdex::same_as<Policy, ctor_policy::as_raw_pointer>;
stdex::same_as<Policy, constructor_policy::as_raw_pointer>;
constexpr bool as_shared_ptr =
stdex::same_as<Policy, ctor_policy::as_shared_pointer>;
stdex::same_as<Policy, constructor_policy::as_shared_pointer>;
static_assert(as_object || as_raw_ptr || as_shared_ptr);
@@ -62,8 +62,8 @@ namespace meta_hpp::detail
}
template < class_kind Class, typename... Args >
bool raw_ctor_is_invocable_with(std::span<const uarg_base> args) {
using ct = ctor_traits<Class, Args...>;
bool raw_constructor_is_invocable_with(std::span<const uarg_base> args) {
using ct = constructor_traits<Class, Args...>;
using argument_types = typename ct::argument_types;
if ( args.size() != ct::arity ) {
@@ -79,71 +79,71 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < ctor_policy_kind Policy, class_kind Class, typename... Args >
ctor_state::invoke_impl make_ctor_invoke() {
return &raw_ctor_invoke<Policy, Class, Args...>;
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
constructor_state::invoke_impl make_constructor_invoke() {
return &raw_constructor_invoke<Policy, Class, Args...>;
}
template < class_kind Class, typename... Args >
ctor_state::is_invocable_with_impl make_ctor_is_invocable_with() {
return &raw_ctor_is_invocable_with<Class, Args...>;
constructor_state::is_invocable_with_impl make_constructor_is_invocable_with() {
return &raw_constructor_is_invocable_with<Class, Args...>;
}
template < class_kind Class, typename... Args >
parameter_list make_ctor_parameters() {
using ct = detail::ctor_traits<Class, Args...>;
argument_list make_constructor_arguments() {
using ct = detail::constructor_traits<Class, Args...>;
parameter_list parameters;
parameters.reserve(ct::arity);
argument_list arguments;
arguments.reserve(ct::arity);
// NOLINTNEXTLINE(readability-named-parameter)
[&parameters]<std::size_t... Is>(std::index_sequence<Is...>) mutable {
(parameters.push_back([]<std::size_t I>(){
[&arguments]<std::size_t... Is>(std::index_sequence<Is...>) mutable {
(arguments.push_back([]<std::size_t I>(){
using P = detail::type_list_at_t<I, typename ct::argument_types>;
return parameter{detail::parameter_state::make<P>(I)};
return argument{detail::argument_state::make<P>(I)};
}.template operator()<Is>()), ...);
}(std::make_index_sequence<ct::arity>());
return parameters;
return arguments;
}
}
namespace meta_hpp::detail
{
template < ctor_policy_kind Policy, class_kind Class, typename... Args >
ctor_state_ptr ctor_state::make() {
return std::make_shared<ctor_state>(ctor_state{
.index{ctor_index::make<Class, Args...>()},
.invoke{make_ctor_invoke<Policy, Class, Args...>()},
.is_invocable_with{make_ctor_is_invocable_with<Class, Args...>()},
.parameters{make_ctor_parameters<Class, Args...>()},
template < constructor_policy_kind Policy, class_kind Class, typename... Args >
constructor_state_ptr constructor_state::make() {
return std::make_shared<constructor_state>(constructor_state{
.index{constructor_index::make<Class, Args...>()},
.invoke{make_constructor_invoke<Policy, Class, Args...>()},
.is_invocable_with{make_constructor_is_invocable_with<Class, Args...>()},
.arguments{make_constructor_arguments<Class, Args...>()},
});
}
}
namespace meta_hpp
{
inline ctor::ctor(detail::ctor_state_ptr state)
inline constructor::constructor(detail::constructor_state_ptr state)
: state_{std::move(state)} {}
inline bool ctor::is_valid() const noexcept {
inline bool constructor::is_valid() const noexcept {
return !!state_;
}
inline ctor::operator bool() const noexcept {
inline constructor::operator bool() const noexcept {
return is_valid();
}
inline const ctor_index& ctor::get_index() const noexcept {
inline const constructor_index& constructor::get_index() const noexcept {
return state_->index;
}
inline const ctor_type& ctor::get_type() const noexcept {
inline const constructor_type& constructor::get_type() const noexcept {
return state_->index.get_type();
}
template < typename... Args >
uvalue ctor::invoke(Args&&... args) const {
uvalue constructor::invoke(Args&&... args) const {
if constexpr ( sizeof...(Args) > 0 ) {
using namespace detail;
const std::array<uarg, sizeof...(Args)> vargs{uarg{std::forward<Args>(args)}...};
@@ -154,12 +154,12 @@ namespace meta_hpp
}
template < typename... Args >
uvalue ctor::operator()(Args&&... args) const {
uvalue constructor::operator()(Args&&... args) const {
return invoke(std::forward<Args>(args)...);
}
template < typename... Args >
bool ctor::is_invocable_with() const noexcept {
bool constructor::is_invocable_with() const noexcept {
if constexpr ( sizeof...(Args) > 0 ) {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{type_list<Args>{}}...};
@@ -170,7 +170,7 @@ namespace meta_hpp
}
template < typename... Args >
bool ctor::is_invocable_with(Args&&... args) const noexcept {
bool constructor::is_invocable_with(Args&&... args) const noexcept {
if constexpr ( sizeof...(Args) > 0 ) {
using namespace detail;
const std::array<uarg_base, sizeof...(Args)> vargs{uarg_base{std::forward<Args>(args)}...};
@@ -180,11 +180,11 @@ namespace meta_hpp
}
}
inline parameter ctor::get_parameter(std::size_t position) const noexcept {
return position < state_->parameters.size() ? state_->parameters[position] : parameter{};
inline argument constructor::get_argument(std::size_t position) const noexcept {
return position < state_->arguments.size() ? state_->arguments[position] : argument{};
}
inline const parameter_list& ctor::get_parameters() const noexcept {
return state_->parameters;
inline const argument_list& constructor::get_arguments() const noexcept {
return state_->arguments;
}
}

46
headers/meta.hpp/meta_states/dtor.hpp → headers/meta.hpp/meta_states/destructor.hpp
View File

@@ -9,14 +9,14 @@
#include "../meta_base.hpp"
#include "../meta_states.hpp"
#include "../meta_types/dtor_type.hpp"
#include "../meta_types/destructor_type.hpp"
#include "../meta_detail/value_utilities/uarg.hpp"
namespace meta_hpp::detail
{
template < class_kind Class >
void raw_dtor_invoke(const uarg& ptr) {
using dt = dtor_traits<Class>;
void raw_destructor_invoke(const uarg& ptr) {
using dt = destructor_traits<Class>;
using class_type = typename dt::class_type;
if ( !ptr.can_cast_to<class_type*>() ) {
@@ -30,8 +30,8 @@ namespace meta_hpp::detail
}
template < class_kind Class >
bool raw_dtor_is_invocable_with(const uarg_base& ptr) {
using dt = dtor_traits<Class>;
bool raw_destructor_is_invocable_with(const uarg_base& ptr) {
using dt = destructor_traits<Class>;
using class_type = typename dt::class_type;
return ptr.can_cast_to<class_type*>();
@@ -41,70 +41,70 @@ namespace meta_hpp::detail
namespace meta_hpp::detail
{
template < class_kind Class >
dtor_state::invoke_impl make_dtor_invoke() {
return &raw_dtor_invoke<Class>;
destructor_state::invoke_impl make_destructor_invoke() {
return &raw_destructor_invoke<Class>;
}
template < class_kind Class >
dtor_state::is_invocable_with_impl make_dtor_is_invocable_with() {
return &raw_dtor_is_invocable_with<Class>;
destructor_state::is_invocable_with_impl make_destructor_is_invocable_with() {
return &raw_destructor_is_invocable_with<Class>;
}
}
namespace meta_hpp::detail
{
template < class_kind Class >
dtor_state_ptr dtor_state::make() {
return std::make_shared<dtor_state>(dtor_state{
.index{dtor_index::make<Class>()},
.invoke{make_dtor_invoke<Class>()},
.is_invocable_with{make_dtor_is_invocable_with<Class>()},
destructor_state_ptr destructor_state::make() {
return std::make_shared<destructor_state>(destructor_state{
.index{destructor_index::make<Class>()},
.invoke{make_destructor_invoke<Class>()},
.is_invocable_with{make_destructor_is_invocable_with<Class>()},
});
}
}
namespace meta_hpp
{
inline dtor::dtor(detail::dtor_state_ptr state)
inline destructor::destructor(detail::destructor_state_ptr state)
: state_{std::move(state)} {}
inline bool dtor::is_valid() const noexcept {
inline bool destructor::is_valid() const noexcept {
return !!state_;
}
inline dtor::operator bool() const noexcept {
inline destructor::operator bool() const noexcept {
return is_valid();
}
inline const dtor_index& dtor::get_index() const noexcept {
inline const destructor_index& destructor::get_index() const noexcept {
return state_->index;
}
inline const dtor_type& dtor::get_type() const noexcept {
inline const destructor_type& destructor::get_type() const noexcept {
return state_->index.get_type();
}
template < typename Arg >
void dtor::invoke(Arg&& ptr) const {
void destructor::invoke(Arg&& ptr) const {
using namespace detail;
const uarg varg{std::forward<Arg>(ptr)};
state_->invoke(varg);
}
template < typename Arg >
void dtor::operator()(Arg&& ptr) const {
void destructor::operator()(Arg&& ptr) const {
invoke(std::forward<Arg>(ptr));
}
template < typename Arg >
bool dtor::is_invocable_with() const noexcept {
bool destructor::is_invocable_with() const noexcept {
using namespace detail;
const uarg_base varg{type_list<Arg>{}};
return state_->is_invocable_with(varg);
}
template < typename Arg >
bool dtor::is_invocable_with(Arg&& ptr) const noexcept {
bool destructor::is_invocable_with(Arg&& ptr) const noexcept {
using namespace detail;
const uarg_base varg{std::forward<Arg>(ptr)};
return state_->is_invocable_with(varg);

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

@@ -96,21 +96,21 @@ namespace meta_hpp::detail
}
template < function_kind Function >
parameter_list make_function_parameters() {
argument_list make_function_arguments() {
using ft = detail::function_traits<Function>;
parameter_list parameters;
parameters.reserve(ft::arity);
argument_list arguments;
arguments.reserve(ft::arity);
// NOLINTNEXTLINE(readability-named-parameter)
[&parameters]<std::size_t... Is>(std::index_sequence<Is...>) mutable {
(parameters.push_back([]<std::size_t I>(){
[&arguments]<std::size_t... Is>(std::index_sequence<Is...>) mutable {
(arguments.push_back([]<std::size_t I>(){
using P = detail::type_list_at_t<I, typename ft::argument_types>;
return parameter{detail::parameter_state::make<P>(I)};
return argument{detail::argument_state::make<P>(I)};
}.template operator()<Is>()), ...);
}(std::make_index_sequence<ft::arity>());
return parameters;
return arguments;
}
}
@@ -122,7 +122,7 @@ namespace meta_hpp::detail
.index{function_index::make<Function>(std::move(name))},
.invoke{make_function_invoke<Policy>(std::move(function))},
.is_invocable_with{make_function_is_invocable_with<Function>()},
.parameters{make_function_parameters<Function>()},
.arguments{make_function_arguments<Function>()},
});
}
}
@@ -190,11 +190,11 @@ namespace meta_hpp
}
}
inline parameter function::get_parameter(std::size_t position) const noexcept {
return position < state_->parameters.size() ? state_->parameters[position] : parameter{};
inline argument function::get_argument(std::size_t position) const noexcept {
return position < state_->arguments.size() ? state_->arguments[position] : argument{};
}
inline const parameter_list& function::get_parameters() const noexcept {
return state_->parameters;
inline const argument_list& function::get_arguments() const noexcept {
return state_->arguments;
}
}

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

@@ -109,21 +109,21 @@ namespace meta_hpp::detail
}
template < method_kind Method >
parameter_list make_method_parameters() {
argument_list make_method_arguments() {
using mt = detail::method_traits<Method>;
parameter_list parameters;
parameters.reserve(mt::arity);
argument_list arguments;
arguments.reserve(mt::arity);
// NOLINTNEXTLINE(readability-named-parameter)
[&parameters]<std::size_t... Is>(std::index_sequence<Is...>) mutable {
(parameters.push_back([]<std::size_t I>(){
[&arguments]<std::size_t... Is>(std::index_sequence<Is...>) mutable {
(arguments.push_back([]<std::size_t I>(){
using P = detail::type_list_at_t<I, typename mt::argument_types>;
return parameter{detail::parameter_state::make<P>(I)};
return argument{detail::argument_state::make<P>(I)};
}.template operator()<Is>()), ...);
}(std::make_index_sequence<mt::arity>());
return parameters;
return arguments;
}
}
@@ -135,7 +135,7 @@ namespace meta_hpp::detail
.index{method_index::make<Method>(std::move(name))},
.invoke{make_method_invoke<Policy>(std::move(method))},
.is_invocable_with{make_method_is_invocable_with<Method>()},
.parameters{make_method_parameters<Method>()},
.arguments{make_method_arguments<Method>()},
});
}
}
@@ -206,11 +206,11 @@ namespace meta_hpp
}
}
inline parameter method::get_parameter(std::size_t position) const noexcept {
return position < state_->parameters.size() ? state_->parameters[position] : parameter{};
inline argument method::get_argument(std::size_t position) const noexcept {
return position < state_->arguments.size() ? state_->arguments[position] : argument{};
}
inline const parameter_list& method::get_parameters() const noexcept {
return state_->parameters;
inline const argument_list& method::get_arguments() const noexcept {
return state_->arguments;
}
}

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

@@ -12,8 +12,8 @@
#include "meta_detail/type_traits/array_traits.hpp"
#include "meta_detail/type_traits/class_traits.hpp"
#include "meta_detail/type_traits/ctor_traits.hpp"
#include "meta_detail/type_traits/dtor_traits.hpp"
#include "meta_detail/type_traits/constructor_traits.hpp"
#include "meta_detail/type_traits/destructor_traits.hpp"
#include "meta_detail/type_traits/enum_traits.hpp"
#include "meta_detail/type_traits/function_traits.hpp"
#include "meta_detail/type_traits/member_traits.hpp"
@@ -30,11 +30,11 @@ namespace meta_hpp
using class_flags = detail::class_flags;
using class_bitflags = detail::class_bitflags;
using ctor_flags = detail::ctor_flags;
using ctor_bitflags = detail::ctor_bitflags;
using constructor_flags = detail::constructor_flags;
using constructor_bitflags = detail::constructor_bitflags;
using dtor_flags = detail::dtor_flags;
using dtor_bitflags = detail::dtor_bitflags;
using destructor_flags = detail::destructor_flags;
using destructor_bitflags = detail::destructor_bitflags;
using enum_flags = detail::enum_flags;
using enum_bitflags = detail::enum_bitflags;
@@ -72,8 +72,8 @@ namespace meta_hpp
any_type(const array_type& other) noexcept;
any_type(const class_type& other) noexcept;
any_type(const ctor_type& other) noexcept;
any_type(const dtor_type& other) noexcept;
any_type(const constructor_type& other) noexcept;
any_type(const destructor_type& other) noexcept;
any_type(const enum_type& other) noexcept;
any_type(const function_type& other) noexcept;
any_type(const member_type& other) noexcept;
@@ -86,8 +86,8 @@ namespace meta_hpp
[[nodiscard]] bool is_array() const noexcept;
[[nodiscard]] bool is_class() const noexcept;
[[nodiscard]] bool is_ctor() const noexcept;
[[nodiscard]] bool is_dtor() const noexcept;
[[nodiscard]] bool is_constructor() const noexcept;
[[nodiscard]] bool is_destructor() const noexcept;
[[nodiscard]] bool is_enum() const noexcept;
[[nodiscard]] bool is_function() const noexcept;
[[nodiscard]] bool is_member() const noexcept;
@@ -100,8 +100,8 @@ namespace meta_hpp
[[nodiscard]] array_type as_array() const noexcept;
[[nodiscard]] class_type as_class() const noexcept;
[[nodiscard]] ctor_type as_ctor() const noexcept;
[[nodiscard]] dtor_type as_dtor() const noexcept;
[[nodiscard]] constructor_type as_constructor() const noexcept;
[[nodiscard]] destructor_type as_destructor() const noexcept;
[[nodiscard]] enum_type as_enum() const noexcept;
[[nodiscard]] function_type as_function() const noexcept;
[[nodiscard]] member_type as_member() const noexcept;
@@ -151,8 +151,8 @@ namespace meta_hpp
[[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept;
[[nodiscard]] const std::vector<any_type>& get_argument_types() const noexcept;
[[nodiscard]] const ctor_map& get_ctors() const noexcept;
[[nodiscard]] const dtor_map& get_dtors() const noexcept;
[[nodiscard]] const constructor_map& get_ctors() const noexcept;
[[nodiscard]] const destructor_map& get_dtors() const noexcept;
[[nodiscard]] const class_set& get_bases() const noexcept;
[[nodiscard]] const function_map& get_functions() const noexcept;
[[nodiscard]] const member_map& get_members() const noexcept;
@@ -182,11 +182,11 @@ namespace meta_hpp
[[nodiscard]] variable get_variable(std::string_view name) const noexcept;
template < typename... Args >
[[nodiscard]] ctor get_ctor_with() const noexcept;
[[nodiscard]] constructor get_constructor_with() const noexcept;
template < typename Iter >
[[nodiscard]] ctor get_ctor_with(Iter first, Iter last) const noexcept;
[[nodiscard]] ctor get_ctor_with(const std::vector<any_type>& args) const noexcept;
[[nodiscard]] ctor get_ctor_with(std::initializer_list<any_type> args) const noexcept;
[[nodiscard]] constructor get_constructor_with(Iter first, Iter last) const noexcept;
[[nodiscard]] constructor get_constructor_with(const std::vector<any_type>& args) const noexcept;
[[nodiscard]] constructor get_constructor_with(std::initializer_list<any_type> args) const noexcept;
template < typename... Args >
[[nodiscard]] function get_function_with(std::string_view name) const noexcept;
@@ -206,41 +206,41 @@ namespace meta_hpp
friend auto detail::type_access<class_type>(const class_type&);
};
class ctor_type final {
class constructor_type final {
public:
ctor_type() = default;
ctor_type(detail::ctor_type_data_ptr data);
constructor_type() = default;
constructor_type(detail::constructor_type_data_ptr data);
[[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept;
[[nodiscard]] type_id get_id() const noexcept;
[[nodiscard]] ctor_bitflags get_flags() const noexcept;
[[nodiscard]] constructor_bitflags get_flags() const noexcept;
[[nodiscard]] std::size_t get_arity() const noexcept;
[[nodiscard]] any_type get_class_type() const noexcept;
[[nodiscard]] any_type get_argument_type(std::size_t position) const noexcept;
[[nodiscard]] const std::vector<any_type>& get_argument_types() const noexcept;
private:
detail::ctor_type_data_ptr data_;
friend auto detail::type_access<ctor_type>(const ctor_type&);
detail::constructor_type_data_ptr data_;
friend auto detail::type_access<constructor_type>(const constructor_type&);
};
class dtor_type final {
class destructor_type final {
public:
dtor_type() = default;
dtor_type(detail::dtor_type_data_ptr data);
destructor_type() = default;
destructor_type(detail::destructor_type_data_ptr data);
[[nodiscard]] bool is_valid() const noexcept;
[[nodiscard]] explicit operator bool() const noexcept;
[[nodiscard]] type_id get_id() const noexcept;
[[nodiscard]] dtor_bitflags get_flags() const noexcept;
[[nodiscard]] destructor_bitflags get_flags() const noexcept;
[[nodiscard]] any_type get_class_type() const noexcept;
private:
detail::dtor_type_data_ptr data_;
friend auto detail::type_access<dtor_type>(const dtor_type&);
detail::destructor_type_data_ptr data_;
friend auto detail::type_access<destructor_type>(const destructor_type&);
};
class enum_type final {
@@ -466,8 +466,8 @@ namespace meta_hpp::detail
const std::size_t size;
const std::vector<any_type> argument_types;
ctor_map ctors;
dtor_map dtors;
constructor_map constructors;
destructor_map destructors;
class_set bases;
function_map functions;
member_map members;
@@ -486,21 +486,21 @@ namespace meta_hpp::detail
explicit class_type_data(type_list<Class>);
};
struct ctor_type_data final : type_data_base {
const ctor_bitflags flags;
struct constructor_type_data final : type_data_base {
const constructor_bitflags flags;
const any_type class_type;
const std::vector<any_type> argument_types;
template < class_kind Class, typename... Args >
explicit ctor_type_data(type_list<Class>, type_list<Args...>);
explicit constructor_type_data(type_list<Class>, type_list<Args...>);
};
struct dtor_type_data final : type_data_base {
const dtor_bitflags flags;
struct destructor_type_data final : type_data_base {
const destructor_bitflags flags;
const any_type class_type;
template < class_kind Class >
explicit dtor_type_data(type_list<Class>);
explicit destructor_type_data(type_list<Class>);
};
struct enum_type_data final : type_data_base {

28
headers/meta.hpp/meta_types/any_type.hpp
View File

@@ -33,10 +33,10 @@ namespace meta_hpp
inline any_type::any_type(const class_type& other) noexcept
: data_{detail::type_access(other)} {}
inline any_type::any_type(const ctor_type& other) noexcept
inline any_type::any_type(const constructor_type& other) noexcept
: data_{detail::type_access(other)} {}
inline any_type::any_type(const dtor_type& other) noexcept
inline any_type::any_type(const destructor_type& other) noexcept
: data_{detail::type_access(other)} {}
inline any_type::any_type(const enum_type& other) noexcept
@@ -74,12 +74,12 @@ namespace meta_hpp
return data_ && data_->kind == type_kind::class_;
}
inline bool any_type::is_ctor() const noexcept {
return data_ && data_->kind == type_kind::ctor_;
inline bool any_type::is_constructor() const noexcept {
return data_ && data_->kind == type_kind::constructor_;
}
inline bool any_type::is_dtor() const noexcept {
return data_ && data_->kind == type_kind::dtor_;
inline bool any_type::is_destructor() const noexcept {
return data_ && data_->kind == type_kind::destructor_;
}
inline bool any_type::is_enum() const noexcept {
@@ -130,16 +130,16 @@ namespace meta_hpp
: class_type{};
}
inline ctor_type any_type::as_ctor() const noexcept {
return is_ctor()
? ctor_type{std::static_pointer_cast<detail::ctor_type_data>(data_)}
: ctor_type{};
inline constructor_type any_type::as_constructor() const noexcept {
return is_constructor()
? constructor_type{std::static_pointer_cast<detail::constructor_type_data>(data_)}
: constructor_type{};
}
inline dtor_type any_type::as_dtor() const noexcept {
return is_dtor()
? dtor_type{std::static_pointer_cast<detail::dtor_type_data>(data_)}
: dtor_type{};
inline destructor_type any_type::as_destructor() const noexcept {
return is_destructor()
? destructor_type{std::static_pointer_cast<detail::destructor_type_data>(data_)}
: destructor_type{};
}
inline enum_type any_type::as_enum() const noexcept {

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

@@ -9,7 +9,7 @@
#include "../meta_base.hpp"
#include "../meta_types.hpp"
#include "../meta_states/ctor.hpp"
#include "../meta_states/constructor.hpp"
#include "../meta_states/function.hpp"
#include "../meta_states/member.hpp"
#include "../meta_states/method.hpp"
@@ -69,12 +69,12 @@ namespace meta_hpp
return data_->argument_types;
}
inline const ctor_map& class_type::get_ctors() const noexcept {
return data_->ctors;
inline const constructor_map& class_type::get_ctors() const noexcept {
return data_->constructors;
}
inline const dtor_map& class_type::get_dtors() const noexcept {
return data_->dtors;
inline const destructor_map& class_type::get_dtors() const noexcept {
return data_->destructors;
}
inline const class_set& class_type::get_bases() const noexcept {
@@ -99,7 +99,7 @@ namespace meta_hpp
template < typename... Args >
uvalue class_type::create(Args&&... args) const {
for ( auto&& ctor : data_->ctors ) {
for ( auto&& ctor : data_->constructors ) {
if ( ctor.second.is_invocable_with(std::forward<Args>(args)...) ) {
return ctor.second.invoke(std::forward<Args>(args)...);
}
@@ -114,7 +114,7 @@ namespace meta_hpp
template < typename Arg >
bool class_type::destroy(Arg&& ptr) const {
for ( auto&& dtor : data_->dtors ) {
for ( auto&& dtor : data_->destructors ) {
if ( dtor.second.is_invocable_with(std::forward<Arg>(ptr)) ) {
dtor.second.invoke(std::forward<Arg>(ptr));
return true;
@@ -234,31 +234,31 @@ namespace meta_hpp
}
//
// get_ctor_with
// get_constructor_with
//
template < typename... Args >
ctor class_type::get_ctor_with() const noexcept {
return get_ctor_with({detail::resolve_type<Args>()...});
constructor class_type::get_constructor_with() const noexcept {
return get_constructor_with({detail::resolve_type<Args>()...});
}
template < typename Iter >
ctor class_type::get_ctor_with(Iter first, Iter last) const noexcept {
for ( auto&& [index, ctor] : data_->ctors ) {
constructor class_type::get_constructor_with(Iter first, Iter last) const noexcept {
for ( auto&& [index, ctor] : data_->constructors ) {
const std::vector<any_type>& args = ctor.get_type().get_argument_types();
if ( std::equal(first, last, args.begin(), args.end()) ) {
return ctor;
}
}
return ctor{};
return constructor{};
}
inline ctor class_type::get_ctor_with(const std::vector<any_type>& args) const noexcept {
return get_ctor_with(args.begin(), args.end());
inline constructor class_type::get_constructor_with(const std::vector<any_type>& args) const noexcept {
return get_constructor_with(args.begin(), args.end());
}
inline ctor class_type::get_ctor_with(std::initializer_list<any_type> args) const noexcept {
return get_ctor_with(args.begin(), args.end());
inline constructor class_type::get_constructor_with(std::initializer_list<any_type> args) const noexcept {
return get_constructor_with(args.begin(), args.end());
}
//

65
headers/meta.hpp/meta_types/constructor_type.hpp Normal file
View File

@@ -0,0 +1,65 @@
/*******************************************************************************
* This file is part of the "https://github.com/blackmatov/meta.hpp"
* For conditions of distribution and use, see copyright notice in LICENSE.md
* Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#pragma once
#include "../meta_base.hpp"
#include "../meta_types.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/type_traits/constructor_traits.hpp"
namespace meta_hpp::detail
{
template < class_kind Class, typename... Args >
struct constructor_tag {};
template < class_kind Class, typename... Args >
// NOLINTNEXTLINE(readability-named-parameter)
constructor_type_data::constructor_type_data(type_list<Class>, type_list<Args...>)
: type_data_base{type_id{type_list<constructor_tag<Class, Args...>>{}}, type_kind::constructor_}
, flags{constructor_traits<Class, Args...>::make_flags()}
, class_type{resolve_type<typename constructor_traits<Class, Args...>::class_type>()}
, argument_types{resolve_types(typename constructor_traits<Class, Args...>::argument_types{})} {}
}
namespace meta_hpp
{
inline constructor_type::constructor_type(detail::constructor_type_data_ptr data)
: data_{std::move(data)} {}
inline bool constructor_type::is_valid() const noexcept {
return !!data_;
}
inline constructor_type::operator bool() const noexcept {
return is_valid();
}
inline type_id constructor_type::get_id() const noexcept {
return data_->id;
}
inline constructor_bitflags constructor_type::get_flags() const noexcept {
return data_->flags;
}
inline std::size_t constructor_type::get_arity() const noexcept {
return data_->argument_types.size();
}
inline any_type constructor_type::get_class_type() const noexcept {
return data_->class_type;
}
inline any_type constructor_type::get_argument_type(std::size_t position) const noexcept {
return position < data_->argument_types.size() ? data_->argument_types[position] : any_type{};
}
inline const std::vector<any_type>& constructor_type::get_argument_types() const noexcept {
return data_->argument_types;
}
}

65
headers/meta.hpp/meta_types/ctor_type.hpp
View File

@@ -1,65 +0,0 @@
/*******************************************************************************
* This file is part of the "https://github.com/blackmatov/meta.hpp"
* For conditions of distribution and use, see copyright notice in LICENSE.md
* Copyright (C) 2021, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#pragma once
#include "../meta_base.hpp"
#include "../meta_types.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/type_traits/ctor_traits.hpp"
namespace meta_hpp::detail
{
template < class_kind Class, typename... Args >
struct ctor_tag {};
template < class_kind Class, typename... Args >
// NOLINTNEXTLINE(readability-named-parameter)
ctor_type_data::ctor_type_data(type_list<Class>, type_list<Args...>)
: type_data_base{type_id{type_list<ctor_tag<Class, Args...>>{}}, type_kind::ctor_}
, flags{ctor_traits<Class, Args...>::make_flags()}
, class_type{resolve_type<typename ctor_traits<Class, Args...>::class_type>()}
, argument_types{resolve_types(typename ctor_traits<Class, Args...>::argument_types{})} {}
}
namespace meta_hpp
{
inline ctor_type::ctor_type(detail::ctor_type_data_ptr data)
: data_{std::move(data)} {}
inline bool ctor_type::is_valid() const noexcept {
return !!data_;
}
inline ctor_type::operator bool() const noexcept {
return is_valid();
}
inline type_id ctor_type::get_id() const noexcept {
return data_->id;
}
inline ctor_bitflags ctor_type::get_flags() const noexcept {
return data_->flags;
}
inline std::size_t ctor_type::get_arity() const noexcept {
return data_->argument_types.size();
}
inline any_type ctor_type::get_class_type() const noexcept {
return data_->class_type;
}
inline any_type ctor_type::get_argument_type(std::size_t position) const noexcept {
return position < data_->argument_types.size() ? data_->argument_types[position] : any_type{};
}
inline const std::vector<any_type>& ctor_type::get_argument_types() const noexcept {
return data_->argument_types;
}
}

24
headers/meta.hpp/meta_types/dtor_type.hpp → headers/meta.hpp/meta_types/destructor_type.hpp
View File

@@ -10,43 +10,43 @@
#include "../meta_types.hpp"
#include "../meta_detail/type_registry.hpp"
#include "../meta_detail/type_traits/dtor_traits.hpp"
#include "../meta_detail/type_traits/destructor_traits.hpp"
namespace meta_hpp::detail
{
template < class_kind Class >
struct dtor_tag {};
struct destructor_tag {};
template < class_kind Class >
// NOLINTNEXTLINE(readability-named-parameter)
dtor_type_data::dtor_type_data(type_list<Class>)
: type_data_base{type_id{type_list<dtor_tag<Class>>{}}, type_kind::dtor_}
, flags{dtor_traits<Class>::make_flags()}
, class_type{resolve_type<typename dtor_traits<Class>::class_type>()} {}
destructor_type_data::destructor_type_data(type_list<Class>)
: type_data_base{type_id{type_list<destructor_tag<Class>>{}}, type_kind::destructor_}
, flags{destructor_traits<Class>::make_flags()}
, class_type{resolve_type<typename destructor_traits<Class>::class_type>()} {}
}
namespace meta_hpp
{
inline dtor_type::dtor_type(detail::dtor_type_data_ptr data)
inline destructor_type::destructor_type(detail::destructor_type_data_ptr data)
: data_{std::move(data)} {}
inline bool dtor_type::is_valid() const noexcept {
inline bool destructor_type::is_valid() const noexcept {
return !!data_;
}
inline dtor_type::operator bool() const noexcept {
inline destructor_type::operator bool() const noexcept {
return is_valid();
}
inline type_id dtor_type::get_id() const noexcept {
inline type_id destructor_type::get_id() const noexcept {
return data_->id;
}
inline dtor_bitflags dtor_type::get_flags() const noexcept {
inline destructor_bitflags destructor_type::get_flags() const noexcept {
return data_->flags;
}
inline any_type dtor_type::get_class_type() const noexcept {
inline any_type destructor_type::get_class_type() const noexcept {
return data_->class_type;
}
}

2
manuals/meta_examples/classes_example.cpp
View File

@@ -47,7 +47,7 @@ TEST_CASE("meta/meta_examples/classes/type") {
// 'rectangle' class type registration
meta::class_<rectangle>()
.base_<shape>()
.ctor_<int, int>()
.constructor_<int, int>()
.method_("get_width", &rectangle::get_width)
.method_("get_height", &rectangle::get_height);

2
manuals/meta_examples/functions_example.cpp
View File

@@ -54,7 +54,7 @@ TEST_CASE("meta/meta_examples/functions/usage") {
// checks a type of the founded function
CHECK(sub_function.get_type() == meta::resolve_type<int(*)(int, int)>());
// checks the ability to call the function with specific parameters
// checks the ability to call the function with specific arguments
CHECK(sub_function.is_invocable_with(60, 18));
CHECK(sub_function.is_invocable_with<int, int>());

2
manuals/meta_examples/methods_example.cpp
View File

@@ -64,7 +64,7 @@ TEST_CASE("meta/meta_examples/methods/usage") {
// checks the type of the method 'add'
CHECK(ivec2_add.get_type() == meta::resolve_type<ivec2&(ivec2::*)(const ivec2&)>());
// checks the ability to call the method with specific parameters
// checks the ability to call the method with specific arguments
CHECK(ivec2_add.is_invocable_with(v, ivec2{22, 11}));
CHECK(ivec2_add.is_invocable_with<ivec2&, ivec2>());

84
untests/meta_states/ctor_tests.cpp
View File

@@ -14,75 +14,75 @@ namespace
clazz(int i)
: i{i} {
++ctor_counter;
++constructor_counter;
}
clazz(clazz&& other)
: i{other.i} {
other.i = 0;
++move_ctor_counter;
++move_constructor_counter;
}
clazz(const clazz& other)
: i{other.i} {
++copy_ctor_counter;
++copy_constructor_counter;
}
clazz& operator=(clazz&& other) = delete;
clazz& operator=(const clazz& other) = delete;
~clazz() {
++dtor_counter;
++destructor_counter;
}
public:
static int ctor_counter;
static int dtor_counter;
static int move_ctor_counter;
static int copy_ctor_counter;
static int constructor_counter;
static int destructor_counter;
static int move_constructor_counter;
static int copy_constructor_counter;
};
template < std::size_t N >
int clazz<N>::ctor_counter{0};
int clazz<N>::constructor_counter{0};
template < std::size_t N >
int clazz<N>::dtor_counter{0};
int clazz<N>::destructor_counter{0};
template < std::size_t N >
int clazz<N>::move_ctor_counter{0};
int clazz<N>::move_constructor_counter{0};
template < std::size_t N >
int clazz<N>::copy_ctor_counter{0};
int clazz<N>::copy_constructor_counter{0};
}
TEST_CASE("meta/meta_states/ctor") {
namespace meta = meta_hpp;
meta::class_<clazz<1>>()
.ctor_<int>(meta::ctor_policy::as_object{})
.dtor_();
.constructor_<int>(meta::constructor_policy::as_object{})
.destructor_();
meta::class_<clazz<2>>()
.ctor_<int>(meta::ctor_policy::as_raw_pointer{})
.dtor_();
.constructor_<int>(meta::constructor_policy::as_raw_pointer{})
.destructor_();
meta::class_<clazz<3>>()
.ctor_<int>(meta::ctor_policy::as_shared_pointer{})
.dtor_();
.constructor_<int>(meta::constructor_policy::as_shared_pointer{})
.destructor_();
clazz<1>::ctor_counter = 0;
clazz<1>::dtor_counter = 0;
clazz<1>::move_ctor_counter = 0;
clazz<1>::copy_ctor_counter = 0;
clazz<1>::constructor_counter = 0;
clazz<1>::destructor_counter = 0;
clazz<1>::move_constructor_counter = 0;
clazz<1>::copy_constructor_counter = 0;
clazz<2>::ctor_counter = 0;
clazz<2>::dtor_counter = 0;
clazz<2>::move_ctor_counter = 0;
clazz<2>::copy_ctor_counter = 0;
clazz<2>::constructor_counter = 0;
clazz<2>::destructor_counter = 0;
clazz<2>::move_constructor_counter = 0;
clazz<2>::copy_constructor_counter = 0;
clazz<3>::ctor_counter = 0;
clazz<3>::dtor_counter = 0;
clazz<3>::move_ctor_counter = 0;
clazz<3>::copy_ctor_counter = 0;
clazz<3>::constructor_counter = 0;
clazz<3>::destructor_counter = 0;
clazz<3>::move_constructor_counter = 0;
clazz<3>::copy_constructor_counter = 0;
SUBCASE("clazz<1>") {
const meta::class_type clazz_type = meta::resolve_type<clazz<1>>();
@@ -98,10 +98,10 @@ TEST_CASE("meta/meta_states/ctor") {
CHECK(clazz_type.destroy(meta::uvalue{nullptr}));
}
CHECK(clazz<1>::ctor_counter == 1);
CHECK(clazz<1>::dtor_counter == 2);
CHECK(clazz<1>::move_ctor_counter == 1);
CHECK(clazz<1>::copy_ctor_counter == 0);
CHECK(clazz<1>::constructor_counter == 1);
CHECK(clazz<1>::destructor_counter == 2);
CHECK(clazz<1>::move_constructor_counter == 1);
CHECK(clazz<1>::copy_constructor_counter == 0);
}
SUBCASE("clazz<2>") {
@@ -119,10 +119,10 @@ TEST_CASE("meta/meta_states/ctor") {
CHECK(clazz_type.destroy(meta::uvalue{nullptr}));
}
CHECK(clazz<2>::ctor_counter == 1);
CHECK(clazz<2>::dtor_counter == 1);
CHECK(clazz<2>::move_ctor_counter == 0);
CHECK(clazz<2>::copy_ctor_counter == 0);
CHECK(clazz<2>::constructor_counter == 1);
CHECK(clazz<2>::destructor_counter == 1);
CHECK(clazz<2>::move_constructor_counter == 0);
CHECK(clazz<2>::copy_constructor_counter == 0);
}
SUBCASE("clazz<3>") {
@@ -139,9 +139,9 @@ TEST_CASE("meta/meta_states/ctor") {
CHECK(clazz_type.destroy(meta::uvalue{nullptr}));
}
CHECK(clazz<3>::ctor_counter == 1);
CHECK(clazz<3>::dtor_counter == 1);
CHECK(clazz<3>::move_ctor_counter == 0);
CHECK(clazz<3>::copy_ctor_counter == 0);
CHECK(clazz<3>::constructor_counter == 1);
CHECK(clazz<3>::destructor_counter == 1);
CHECK(clazz<3>::move_constructor_counter == 0);
CHECK(clazz<3>::copy_constructor_counter == 0);
}
}

40
untests/meta_states/function2_tests.cpp
View File

@@ -36,37 +36,37 @@ TEST_CASE("meta/meta_states/function2") {
const meta::function func = ivec2_type.get_function("iadd");
REQUIRE(func);
CHECK(func.get_parameters().size() == 2);
CHECK(func.get_arguments().size() == 2);
REQUIRE(func.get_parameter(0));
CHECK(func.get_parameter(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_parameter(0).get_position() == 0);
CHECK(func.get_parameter(0).get_name() == "l");
REQUIRE(func.get_argument(0));
CHECK(func.get_argument(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_argument(0).get_position() == 0);
CHECK(func.get_argument(0).get_name() == "l");
REQUIRE(func.get_parameter(1));
CHECK(func.get_parameter(1).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_parameter(1).get_position() == 1);
CHECK(func.get_parameter(1).get_name() == "");
REQUIRE(func.get_argument(1));
CHECK(func.get_argument(1).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_argument(1).get_position() == 1);
CHECK(func.get_argument(1).get_name() == "");
CHECK_FALSE(func.get_parameter(2));
CHECK_FALSE(func.get_argument(2));
}
SUBCASE("isub2") {
const meta::function func = ivec2_type.get_function("isub");
REQUIRE(func);
REQUIRE(func.get_parameters().size() == 2);
REQUIRE(func.get_arguments().size() == 2);
REQUIRE(func.get_parameter(0));
CHECK(func.get_parameter(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_parameter(0).get_position() == 0);
CHECK(func.get_parameter(0).get_name() == "l");
REQUIRE(func.get_argument(0));
CHECK(func.get_argument(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_argument(0).get_position() == 0);
CHECK(func.get_argument(0).get_name() == "l");
REQUIRE(func.get_parameter(1));
CHECK(func.get_parameter(1).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_parameter(1).get_position() == 1);
CHECK(func.get_parameter(1).get_name() == "r");
REQUIRE(func.get_argument(1));
CHECK(func.get_argument(1).get_type() == meta::resolve_type<const ivec2&>());
CHECK(func.get_argument(1).get_position() == 1);
CHECK(func.get_argument(1).get_name() == "r");
CHECK_FALSE(func.get_parameter(2));
CHECK_FALSE(func.get_argument(2));
}
}

12
untests/meta_states/method2_tests.cpp
View File

@@ -33,13 +33,13 @@ TEST_CASE("meta/meta_states/method2") {
const meta::method add_m = ivec2_type.get_method("add");
REQUIRE(add_m);
CHECK(add_m.get_parameters().size() == 1);
CHECK(add_m.get_arguments().size() == 1);
REQUIRE(add_m.get_parameter(0));
CHECK(add_m.get_parameter(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(add_m.get_parameter(0).get_position() == 0);
CHECK(add_m.get_parameter(0).get_name() == "other");
REQUIRE(add_m.get_argument(0));
CHECK(add_m.get_argument(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(add_m.get_argument(0).get_position() == 0);
CHECK(add_m.get_argument(0).get_name() == "other");
CHECK_FALSE(add_m.get_parameter(1));
CHECK_FALSE(add_m.get_argument(1));
}
}

40
untests/meta_states/scope_tests.cpp
View File

@@ -97,38 +97,38 @@ TEST_CASE("meta/meta_states/scope") {
REQUIRE(iadd2_func);
{
CHECK(iadd2_func.get_parameters().size() == 2);
CHECK(iadd2_func.get_arguments().size() == 2);
REQUIRE(iadd2_func.get_parameter(0));
CHECK(iadd2_func.get_parameter(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(iadd2_func.get_parameter(0).get_position() == 0);
CHECK(iadd2_func.get_parameter(0).get_name() == "l");
REQUIRE(iadd2_func.get_argument(0));
CHECK(iadd2_func.get_argument(0).get_type() == meta::resolve_type<const ivec2&>());
CHECK(iadd2_func.get_argument(0).get_position() == 0);
CHECK(iadd2_func.get_argument(0).get_name() == "l");
REQUIRE(iadd2_func.get_parameter(1));
CHECK(iadd2_func.get_parameter(1).get_type() == meta::resolve_type<const ivec2&>());
CHECK(iadd2_func.get_parameter(1).get_position() == 1);
CHECK(iadd2_func.get_parameter(1).get_name() == "r");
REQUIRE(iadd2_func.get_argument(1));
CHECK(iadd2_func.get_argument(1).get_type() == meta::resolve_type<const ivec2&>());
CHECK(iadd2_func.get_argument(1).get_position() == 1);
CHECK(iadd2_func.get_argument(1).get_name() == "r");
CHECK_FALSE(iadd2_func.get_parameter(2));
CHECK_FALSE(iadd2_func.get_argument(2));
}
const meta::function iadd3_func = math_scope.get_function("iadd3");
REQUIRE(iadd3_func);
{
CHECK(iadd3_func.get_parameters().size() == 2);
CHECK(iadd3_func.get_arguments().size() == 2);
REQUIRE(iadd3_func.get_parameter(0));
CHECK(iadd3_func.get_parameter(0).get_type() == meta::resolve_type<const ivec3&>());
CHECK(iadd3_func.get_parameter(0).get_position() == 0);
CHECK(iadd3_func.get_parameter(0).get_name() == "l");
REQUIRE(iadd3_func.get_argument(0));
CHECK(iadd3_func.get_argument(0).get_type() == meta::resolve_type<const ivec3&>());
CHECK(iadd3_func.get_argument(0).get_position() == 0);
CHECK(iadd3_func.get_argument(0).get_name() == "l");
REQUIRE(iadd3_func.get_parameter(1));
CHECK(iadd3_func.get_parameter(1).get_type() == meta::resolve_type<const ivec3&>());
CHECK(iadd3_func.get_parameter(1).get_position() == 1);
CHECK(iadd3_func.get_parameter(1).get_name() == "");
REQUIRE(iadd3_func.get_argument(1));
CHECK(iadd3_func.get_argument(1).get_type() == meta::resolve_type<const ivec3&>());
CHECK(iadd3_func.get_argument(1).get_position() == 1);
CHECK(iadd3_func.get_argument(1).get_name() == "");
CHECK_FALSE(iadd3_func.get_parameter(2));
CHECK_FALSE(iadd3_func.get_argument(2));
}
}

16
untests/meta_types/any_type_tests.cpp
View File

@@ -32,8 +32,8 @@ TEST_CASE("meta/meta_types/any_type") {
namespace meta = meta_hpp;
meta::class_<class_t>()
.ctor_<>()
.ctor_<int>();
.constructor_<>()
.constructor_<int>();
SUBCASE("") {
const meta::any_type type{};
@@ -72,8 +72,8 @@ TEST_CASE("meta/meta_types/any_type") {
CHECK(type.is_class());
CHECK(type.get_kind() == meta::type_kind::class_);
CHECK_FALSE(type.is_ctor());
CHECK_FALSE(type.as_ctor());
CHECK_FALSE(type.is_constructor());
CHECK_FALSE(type.as_constructor());
const meta::class_type& specific_type = type.as_class();
REQUIRE(specific_type);
@@ -82,18 +82,18 @@ TEST_CASE("meta/meta_types/any_type") {
SUBCASE("ctor") {
const meta::any_type& type = meta::resolve_type<class_t>()
.get_ctor_with<>()
.get_constructor_with<>()
.get_type();
REQUIRE(type);
CHECK(type.is_ctor());
CHECK(type.get_kind() == meta::type_kind::ctor_);
CHECK(type.is_constructor());
CHECK(type.get_kind() == meta::type_kind::constructor_);
CHECK_FALSE(type.is_enum());
CHECK_FALSE(type.as_enum());
const meta::ctor_type& specific_type = type.as_ctor();
const meta::constructor_type& specific_type = type.as_constructor();
REQUIRE(specific_type);
CHECK(specific_type.get_id() == type.get_id());
}

32
untests/meta_types/class_type_tests.cpp
View File

@@ -62,7 +62,7 @@ TEST_CASE("meta/meta_types/class_type") {
namespace meta = meta_hpp;
meta::class_<base_clazz_1>()
.ctor_<int>()
.constructor_<int>()
.member_("base_member_1", &base_clazz_1::base_member_1)
.method_("base_method_1", &base_clazz_1::base_method_1)
.function_("base_function_1", &base_clazz_1::base_function_1)
@@ -73,14 +73,14 @@ TEST_CASE("meta/meta_types/class_type") {
.variable_("base_variable_1", &base_clazz_1::base_variable_1);
meta::class_<base_clazz_2>()
.ctor_<float>()
.constructor_<float>()
.member_("base_member_2", &base_clazz_2::base_member_2)
.method_("base_method_2", &base_clazz_2::base_method_2)
.function_("base_function_2", &base_clazz_2::base_function_2)
.variable_("base_variable_2", &base_clazz_2::base_variable_2);
meta::class_<derived_clazz>()
.ctor_<int, float>()
.constructor_<int, float>()
.base_<base_clazz_1>()
.base_<base_clazz_2>()
.member_("derived_member", &derived_clazz::derived_member)
@@ -89,7 +89,7 @@ TEST_CASE("meta/meta_types/class_type") {
.variable_("derived_variable", &derived_clazz::derived_variable);
meta::class_<final_derived_clazz>()
.ctor_<int, float>()
.constructor_<int, float>()
.base_<derived_clazz>();
const meta::class_type base_clazz_1_type = meta::resolve_type<base_clazz_1>();
@@ -368,23 +368,23 @@ TEST_CASE("meta/meta_types/class_type") {
CHECK(derived_clazz_type.get_variable("derived_variable"));
}
SUBCASE("get_ctor_with") {
SUBCASE("get_constructor_with") {
{
CHECK_FALSE(base_clazz_1_type.get_ctor_with<>());
CHECK(base_clazz_1_type.get_ctor_with<int>());
CHECK_FALSE(base_clazz_1_type.get_ctor_with<float>());
CHECK_FALSE(base_clazz_1_type.get_constructor_with<>());
CHECK(base_clazz_1_type.get_constructor_with<int>());
CHECK_FALSE(base_clazz_1_type.get_constructor_with<float>());
}
{
CHECK_FALSE(base_clazz_2_type.get_ctor_with<>());
CHECK_FALSE(base_clazz_2_type.get_ctor_with<int>());
CHECK(base_clazz_2_type.get_ctor_with<float>());
CHECK_FALSE(base_clazz_2_type.get_constructor_with<>());
CHECK_FALSE(base_clazz_2_type.get_constructor_with<int>());
CHECK(base_clazz_2_type.get_constructor_with<float>());
}
{
CHECK_FALSE(derived_clazz_type.get_ctor_with<>());
CHECK_FALSE(derived_clazz_type.get_ctor_with<int>());
CHECK_FALSE(derived_clazz_type.get_ctor_with<float>());
CHECK(derived_clazz_type.get_ctor_with<int, float>());
CHECK_FALSE(derived_clazz_type.get_ctor_with<float, int>());
CHECK_FALSE(derived_clazz_type.get_constructor_with<>());
CHECK_FALSE(derived_clazz_type.get_constructor_with<int>());
CHECK_FALSE(derived_clazz_type.get_constructor_with<float>());
CHECK(derived_clazz_type.get_constructor_with<int, float>());
CHECK_FALSE(derived_clazz_type.get_constructor_with<float, int>());
}
}

304
untests/meta_utilities/value2_tests.cpp
View File

@@ -21,25 +21,25 @@ namespace
, y{other.y} {
other.x = 0;
other.y = 0;
++move_ctor_counter;
++move_constructor_counter;
}
ivec2(const ivec2& other) noexcept
: x{other.x}
, y{other.y} {
++copy_ctor_counter;
++copy_constructor_counter;
}
~ivec2() noexcept {
++dtor_counter;
++destructor_counter;
}
ivec2& operator=(ivec2&& other) = delete;
ivec2& operator=(const ivec2& other) = delete;
static int dtor_counter;
static int move_ctor_counter;
static int copy_ctor_counter;
static int destructor_counter;
static int move_constructor_counter;
static int copy_constructor_counter;
};
struct ivec2_big final {
@@ -57,25 +57,25 @@ namespace
, y{other.y} {
other.x = 0;
other.y = 0;
++move_ctor_counter;
++move_constructor_counter;
}
ivec2_big(const ivec2_big& other) noexcept
: x{other.x}
, y{other.y} {
++copy_ctor_counter;
++copy_constructor_counter;
}
~ivec2_big() noexcept {
++dtor_counter;
++destructor_counter;
}
ivec2_big& operator=(ivec2_big&& other) = delete;
ivec2_big& operator=(const ivec2_big& other) = delete;
static int dtor_counter;
static int move_ctor_counter;
static int copy_ctor_counter;
static int destructor_counter;
static int move_constructor_counter;
static int copy_constructor_counter;
};
[[maybe_unused]] bool operator==(const ivec2& l, const ivec2& r) noexcept {
@@ -86,31 +86,31 @@ namespace
return l.x == r.x && l.y == r.y;
}
int ivec2::dtor_counter{0};
int ivec2::move_ctor_counter{0};
int ivec2::copy_ctor_counter{0};
int ivec2::destructor_counter{0};
int ivec2::move_constructor_counter{0};
int ivec2::copy_constructor_counter{0};
int ivec2_big::dtor_counter{0};
int ivec2_big::move_ctor_counter{0};
int ivec2_big::copy_ctor_counter{0};
int ivec2_big::destructor_counter{0};
int ivec2_big::move_constructor_counter{0};
int ivec2_big::copy_constructor_counter{0};
}
TEST_CASE("meta/meta_utilities/value2") {
namespace meta = meta_hpp;
meta::class_<ivec2>()
.ctor_<int>()
.ctor_<int, int>()
.ctor_<ivec2&&>()
.ctor_<const ivec2&>()
.constructor_<int>()
.constructor_<int, int>()
.constructor_<ivec2&&>()
.constructor_<const ivec2&>()
.member_("x", &ivec2::x)
.member_("y", &ivec2::y);
meta::class_<ivec2_big>()
.ctor_<int>()
.ctor_<int, int>()
.ctor_<ivec2_big&&>()
.ctor_<const ivec2_big&>()
.constructor_<int>()
.constructor_<int, int>()
.constructor_<ivec2_big&&>()
.constructor_<const ivec2_big&>()
.member_("x", &ivec2_big::x)
.member_("y", &ivec2_big::y);
}
@@ -118,32 +118,32 @@ TEST_CASE("meta/meta_utilities/value2") {
TEST_CASE("meta/meta_utilities/value2/counters/small") {
namespace meta = meta_hpp;
ivec2::dtor_counter = 0;
ivec2::move_ctor_counter = 0;
ivec2::copy_ctor_counter = 0;
ivec2::destructor_counter = 0;
ivec2::move_constructor_counter = 0;
ivec2::copy_constructor_counter = 0;
SUBCASE("def ctor") {
{
meta::uvalue v{};
CHECK(ivec2::dtor_counter == 0);
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 0);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 0);
}
CHECK(ivec2::dtor_counter == 0);
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 0);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 0);
}
SUBCASE("val ctor") {
{
meta::uvalue v{ivec2{1,2}};
CHECK(ivec2::dtor_counter == 1);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 1);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
}
CHECK(ivec2::dtor_counter == 2);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 2);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
}
SUBCASE("move ctor") {
@@ -154,13 +154,13 @@ TEST_CASE("meta/meta_utilities/value2/counters/small") {
CHECK_FALSE(v1);
CHECK(v2.cast<ivec2>().x == 1);
CHECK(ivec2::dtor_counter == 2);
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 2);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
}
CHECK(ivec2::dtor_counter == 3);
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 3);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
}
SUBCASE("copy ctor") {
@@ -171,66 +171,66 @@ TEST_CASE("meta/meta_utilities/value2/counters/small") {
CHECK(v1.cast<ivec2>().x == 1);
CHECK(v2.cast<ivec2>().y == 2);
CHECK(ivec2::dtor_counter == 1);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::destructor_counter == 1);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 1);
}
CHECK(ivec2::dtor_counter == 3);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::destructor_counter == 3);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 1);
}
SUBCASE("swap") {
{
meta::uvalue v1{ivec2{1,2}};
meta::uvalue v2{ivec2{3,4}};
CHECK(ivec2::dtor_counter == 2);
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 2);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
v1.swap(v2);
CHECK(v1.cast<ivec2>().x == 3);
CHECK(v2.cast<ivec2>().x == 1);
CHECK(ivec2::dtor_counter == 5);
CHECK(ivec2::move_ctor_counter == 5);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 5);
CHECK(ivec2::move_constructor_counter == 5);
CHECK(ivec2::copy_constructor_counter == 0);
}
CHECK(ivec2::dtor_counter == 7);
CHECK(ivec2::move_ctor_counter == 5);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 7);
CHECK(ivec2::move_constructor_counter == 5);
CHECK(ivec2::copy_constructor_counter == 0);
}
}
TEST_CASE("meta/meta_utilities/value2/counters/big") {
namespace meta = meta_hpp;
ivec2_big::dtor_counter = 0;
ivec2_big::move_ctor_counter = 0;
ivec2_big::copy_ctor_counter = 0;
ivec2_big::destructor_counter = 0;
ivec2_big::move_constructor_counter = 0;
ivec2_big::copy_constructor_counter = 0;
SUBCASE("def ctor") {
{
meta::uvalue v{};
CHECK(ivec2_big::dtor_counter == 0);
CHECK(ivec2_big::move_ctor_counter == 0);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 0);
CHECK(ivec2_big::move_constructor_counter == 0);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
CHECK(ivec2_big::dtor_counter == 0);
CHECK(ivec2_big::move_ctor_counter == 0);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 0);
CHECK(ivec2_big::move_constructor_counter == 0);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
SUBCASE("val ctor") {
{
meta::uvalue v{ivec2_big{1,2}};
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
CHECK(ivec2_big::dtor_counter == 2);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 2);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
SUBCASE("move ctor") {
@@ -241,13 +241,13 @@ TEST_CASE("meta/meta_utilities/value2/counters/big") {
CHECK_FALSE(v1);
CHECK(v2.cast<ivec2_big>().x == 1);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
CHECK(ivec2_big::dtor_counter == 2);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 2);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
SUBCASE("copy ctor") {
@@ -258,77 +258,77 @@ TEST_CASE("meta/meta_utilities/value2/counters/big") {
CHECK(v1.cast<ivec2_big>().x == 1);
CHECK(v2.cast<ivec2_big>().y == 2);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 1);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 1);
}
CHECK(ivec2_big::dtor_counter == 3);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 1);
CHECK(ivec2_big::destructor_counter == 3);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 1);
}
SUBCASE("swap") {
{
meta::uvalue v1{ivec2_big{1,2}};
meta::uvalue v2{ivec2_big{3,4}};
CHECK(ivec2_big::dtor_counter == 2);
CHECK(ivec2_big::move_ctor_counter == 2);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 2);
CHECK(ivec2_big::move_constructor_counter == 2);
CHECK(ivec2_big::copy_constructor_counter == 0);
v1.swap(v2);
CHECK(v1.cast<ivec2_big>().x == 3);
CHECK(v2.cast<ivec2_big>().x == 1);
CHECK(ivec2_big::dtor_counter == 2);
CHECK(ivec2_big::move_ctor_counter == 2);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 2);
CHECK(ivec2_big::move_constructor_counter == 2);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
CHECK(ivec2_big::dtor_counter == 4);
CHECK(ivec2_big::move_ctor_counter == 2);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 4);
CHECK(ivec2_big::move_constructor_counter == 2);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
}
TEST_CASE("meta/meta_utilities/value2/counters/swap") {
namespace meta = meta_hpp;
ivec2::dtor_counter = 0;
ivec2::move_ctor_counter = 0;
ivec2::copy_ctor_counter = 0;
ivec2::destructor_counter = 0;
ivec2::move_constructor_counter = 0;
ivec2::copy_constructor_counter = 0;
ivec2_big::dtor_counter = 0;
ivec2_big::move_ctor_counter = 0;
ivec2_big::copy_ctor_counter = 0;
ivec2_big::destructor_counter = 0;
ivec2_big::move_constructor_counter = 0;
ivec2_big::copy_constructor_counter = 0;
SUBCASE("empty/small") {
{
meta::uvalue v1{};
meta::uvalue v2{ivec2{1,2}};
CHECK(ivec2::dtor_counter == 1);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 1);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
v1.swap(v2);
CHECK(v1.cast<ivec2>().x == 1);
CHECK_FALSE(v2);
CHECK(ivec2::dtor_counter == 2);
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 2);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
v1.swap(v2);
CHECK_FALSE(v1);
CHECK(v2.cast<ivec2>().y == 2);
CHECK(ivec2::dtor_counter == 3);
CHECK(ivec2::move_ctor_counter == 3);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 3);
CHECK(ivec2::move_constructor_counter == 3);
CHECK(ivec2::copy_constructor_counter == 0);
}
CHECK(ivec2::dtor_counter == 4);
CHECK(ivec2::move_ctor_counter == 3);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 4);
CHECK(ivec2::move_constructor_counter == 3);
CHECK(ivec2::copy_constructor_counter == 0);
}
SUBCASE("empty/big") {
@@ -336,30 +336,30 @@ TEST_CASE("meta/meta_utilities/value2/counters/swap") {
meta::uvalue v1{};
meta::uvalue v2{ivec2_big{3,4}};
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
v1.swap(v2);
CHECK(v1.cast<ivec2_big>().x == 3);
CHECK_FALSE(v2);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
v1.swap(v2);
CHECK_FALSE(v1);
CHECK(v2.cast<ivec2_big>().y == 4);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
CHECK(ivec2_big::dtor_counter == 2);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 2);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
SUBCASE("small/big") {
@@ -367,45 +367,45 @@ TEST_CASE("meta/meta_utilities/value2/counters/swap") {
meta::uvalue v1{ivec2{1,2}};
meta::uvalue v2{ivec2_big{3,4}};
CHECK(ivec2::dtor_counter == 1);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 1);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
v1.swap(v2);
CHECK(v1.cast<ivec2_big>().x == 3);
CHECK(v2.cast<ivec2>().x == 1);
CHECK(ivec2::dtor_counter == 2);
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 2);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
v1.swap(v2);
CHECK(v1.cast<ivec2>().y == 2);
CHECK(v2.cast<ivec2_big>().y == 4);
CHECK(ivec2::dtor_counter == 3);
CHECK(ivec2::move_ctor_counter == 3);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 3);
CHECK(ivec2::move_constructor_counter == 3);
CHECK(ivec2::copy_constructor_counter == 0);
CHECK(ivec2_big::dtor_counter == 1);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 1);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
CHECK(ivec2::dtor_counter == 4);
CHECK(ivec2::move_ctor_counter == 3);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::destructor_counter == 4);
CHECK(ivec2::move_constructor_counter == 3);
CHECK(ivec2::copy_constructor_counter == 0);
CHECK(ivec2_big::dtor_counter == 2);
CHECK(ivec2_big::move_ctor_counter == 1);
CHECK(ivec2_big::copy_ctor_counter == 0);
CHECK(ivec2_big::destructor_counter == 2);
CHECK(ivec2_big::move_constructor_counter == 1);
CHECK(ivec2_big::copy_constructor_counter == 0);
}
}

112
untests/meta_utilities/value_tests.cpp
View File

@@ -21,13 +21,13 @@ namespace
, y{other.y} {
other.x = 0;
other.y = 0;
++move_ctor_counter;
++move_constructor_counter;
}
ivec2(const ivec2& other) noexcept
: x{other.x}
, y{other.y} {
++copy_ctor_counter;
++copy_constructor_counter;
}
ivec2& add(const ivec2& other) {
@@ -39,8 +39,8 @@ namespace
ivec2& operator=(ivec2&& other) = delete;
ivec2& operator=(const ivec2& other) = delete;
public:
static int move_ctor_counter;
static int copy_ctor_counter;
static int move_constructor_counter;
static int copy_constructor_counter;
};
struct ivec3 {
@@ -53,8 +53,8 @@ namespace
ivec3(int x, int y, int z): x{x}, y{y}, z{z} {}
};
int ivec2::move_ctor_counter{0};
int ivec2::copy_ctor_counter{0};
int ivec2::move_constructor_counter{0};
int ivec2::copy_constructor_counter{0};
ivec2 iadd2(ivec2 l, ivec2 r) {
return {l.x + r.x, l.y + r.y};
@@ -73,10 +73,10 @@ TEST_CASE("meta/meta_utilities/value/ivec2") {
namespace meta = meta_hpp;
meta::class_<ivec2>()
.ctor_<int>()
.ctor_<int, int>()
.ctor_<ivec2&&>()
.ctor_<const ivec2&>()
.constructor_<int>()
.constructor_<int, int>()
.constructor_<ivec2&&>()
.constructor_<const ivec2&>()
.member_("x", &ivec2::x)
.member_("y", &ivec2::y);
}
@@ -85,10 +85,10 @@ TEST_CASE("meta/meta_utilities/value/ivec3") {
namespace meta = meta_hpp;
meta::class_<ivec3>()
.ctor_<int>()
.ctor_<int, int, int>()
.ctor_<ivec3&&>()
.ctor_<const ivec3&>()
.constructor_<int>()
.constructor_<int, int, int>()
.constructor_<ivec3&&>()
.constructor_<const ivec3&>()
.member_("x", &ivec3::x)
.member_("y", &ivec3::y)
.member_("z", &ivec3::z);
@@ -98,8 +98,8 @@ TEST_CASE("meta/meta_utilities/value") {
namespace meta = meta_hpp;
using namespace std::string_literals;
ivec2::move_ctor_counter = 0;
ivec2::copy_ctor_counter = 0;
ivec2::move_constructor_counter = 0;
ivec2::copy_constructor_counter = 0;
SUBCASE("cast types") {
static_assert(std::is_same_v<
@@ -189,8 +189,8 @@ TEST_CASE("meta/meta_utilities/value") {
ivec2& vr = v;
meta::uvalue val{vr};
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 1);
CHECK(val.get_type() == meta::resolve_type<ivec2>());
@@ -223,8 +223,8 @@ TEST_CASE("meta/meta_utilities/value") {
const ivec2& vr = v;
meta::uvalue val{vr};
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 1);
CHECK(val.get_type() == meta::resolve_type<ivec2>());
@@ -256,8 +256,8 @@ TEST_CASE("meta/meta_utilities/value") {
ivec2 v{1,2};
meta::uvalue val{std::move(v)};
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
CHECK(val.get_type() == meta::resolve_type<ivec2>());
@@ -284,8 +284,8 @@ TEST_CASE("meta/meta_utilities/value") {
const ivec2 v{1,2};
meta::uvalue val{std::move(v)};
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 1);
CHECK(val.get_type() == meta::resolve_type<ivec2>());
@@ -311,25 +311,25 @@ TEST_CASE("meta/meta_utilities/value") {
SUBCASE("value(value&&)") {
ivec2 v{1,2};
meta::uvalue val_src{std::move(v)};
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
meta::uvalue val_dst{std::move(val_src)};
CHECK(val_dst == ivec2{1,2});
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
}
SUBCASE("value(const meta::value&)") {
const ivec2 v{1,2};
meta::uvalue val_src{v};
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 1);
meta::uvalue val_dst{val_src};
CHECK(val_dst == ivec2{1,2});
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 2);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 2);
CHECK(val_src == ivec2{1,2});
CHECK(val_src.data() != val_dst.data());
@@ -348,39 +348,39 @@ TEST_CASE("meta/meta_utilities/value") {
SUBCASE("value& operator=(value&&)") {
meta::uvalue val_src1{"world"s};
meta::uvalue val_src2{ivec2{1,2}};
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
meta::uvalue val_dst{"hello"s};
val_dst = std::move(val_src1);
CHECK(val_dst == "world"s);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
val_dst = std::move(val_src2);
CHECK(val_dst == ivec2{1,2});
CHECK(ivec2::move_ctor_counter == 3);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 3);
CHECK(ivec2::copy_constructor_counter == 0);
}
SUBCASE("value& operator=(const meta::value&)") {
meta::uvalue val_src1{"world"s};
meta::uvalue val_src2{ivec2{1,2}};
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
meta::uvalue val_dst{"hello"s};
val_dst = val_src1;
CHECK(val_dst == "world"s);
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
val_dst = val_src2;
CHECK(val_dst == ivec2{1,2});
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 1);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 1);
CHECK(val_src2 == ivec2{1,2});
CHECK(val_src2.data() != val_dst.data());
@@ -389,14 +389,14 @@ TEST_CASE("meta/meta_utilities/value") {
SUBCASE("swap") {
meta::uvalue val1{"world"s};
meta::uvalue val2{ivec2{1,2}};
CHECK(ivec2::move_ctor_counter == 1);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 1);
CHECK(ivec2::copy_constructor_counter == 0);
val1.swap(val2);
CHECK(val1 == ivec2{1,2});
CHECK(val2 == "world"s);
CHECK(ivec2::move_ctor_counter == 2);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 2);
CHECK(ivec2::copy_constructor_counter == 0);
swap(val1, val2);
CHECK(val1 == "world"s);
@@ -498,20 +498,20 @@ TEST_CASE("meta/meta_utilities/value") {
{
ivec2 v{1,2};
meta::uvalue vp{&v};
CHECK(ivec2::move_ctor_counter == 0);
CHECK(ivec2::copy_ctor_counter == 0);
CHECK(ivec2::move_constructor_counter == 0);
CHECK(ivec2::copy_constructor_counter == 0);
[[maybe_unused]] meta::uvalue vv1{*vp};
CHECK((ivec2::move_ctor_counter == 0 || ivec2::move_ctor_counter == 2));
CHECK(ivec2::copy_ctor_counter == 1);
CHECK((ivec2::move_constructor_counter == 0 || ivec2::move_constructor_counter == 2));
CHECK(ivec2::copy_constructor_counter == 1);
[[maybe_unused]] meta::uvalue vv2{*std::move(vp)};
CHECK((ivec2::move_ctor_counter == 0 || ivec2::move_ctor_counter == 4));
CHECK(ivec2::copy_ctor_counter == 2);
CHECK((ivec2::move_constructor_counter == 0 || ivec2::move_constructor_counter == 4));
CHECK(ivec2::copy_constructor_counter == 2);
[[maybe_unused]] meta::uvalue vv3{*std::as_const(vp)};
CHECK((ivec2::move_ctor_counter == 0 || ivec2::move_ctor_counter == 6));
CHECK(ivec2::copy_ctor_counter == 3);
CHECK((ivec2::move_constructor_counter == 0 || ivec2::move_constructor_counter == 6));
CHECK(ivec2::copy_constructor_counter == 3);
}
{
meta::uvalue v{std::make_shared<int>(42)};