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

fix internal class vs const class types resolving

Browse Source
This commit is contained in:
BlackMATov
2023-03-10 04:32:04 +07:00
parent 139f075d77
commit ae0d402fa2
2 changed files with 65 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
develop/untests/meta_issues/random_issue_2.cpp Normal file
View File

@@ -0,0 +1,52 @@
/*******************************************************************************
* 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-2023, by Matvey Cherevko (blackmatov@gmail.com)
******************************************************************************/
#include <meta.hpp/meta_all.hpp>
#include <doctest/doctest.h>
namespace
{
struct A {};
enum class E {};
}
TEST_CASE("meta/meta_issues/random/2") {
namespace meta = meta_hpp;
CHECK(meta::resolve_type<A[]>() == meta::resolve_type<const A[]>());
CHECK(meta::resolve_type<A[]>() == meta::resolve_type<volatile A[]>());
CHECK(meta::resolve_type<A[]>() == meta::resolve_type<const volatile A[]>());
CHECK(meta::resolve_type<A>() == meta::resolve_type<const A>());
CHECK(meta::resolve_type<A>() == meta::resolve_type<volatile A>());
CHECK(meta::resolve_type<A>() == meta::resolve_type<const volatile A>());
CHECK(meta::resolve_type<E>() == meta::resolve_type<const E>());
CHECK(meta::resolve_type<E>() == meta::resolve_type<volatile E>());
CHECK(meta::resolve_type<E>() == meta::resolve_type<const volatile E>());
CHECK(meta::resolve_type<int>() == meta::resolve_type<const int>());
CHECK(meta::resolve_type<int>() == meta::resolve_type<volatile int>());
CHECK(meta::resolve_type<int>() == meta::resolve_type<const volatile int>());
meta::detail::type_registry& r = meta::detail::type_registry::instance();
CHECK(r.resolve_array_type<A[]>() == r.resolve_array_type<const A[]>());
CHECK(r.resolve_array_type<A[]>() == r.resolve_array_type<volatile A[]>());
CHECK(r.resolve_array_type<A[]>() == r.resolve_array_type<const volatile A[]>());
CHECK(r.resolve_class_type<A>() == r.resolve_class_type<const A>());
CHECK(r.resolve_class_type<A>() == r.resolve_class_type<volatile A>());
CHECK(r.resolve_class_type<A>() == r.resolve_class_type<const volatile A>());
CHECK(r.resolve_enum_type<E>() == r.resolve_enum_type<const E>());
CHECK(r.resolve_enum_type<E>() == r.resolve_enum_type<volatile E>());
CHECK(r.resolve_enum_type<E>() == r.resolve_enum_type<const volatile E>());
CHECK(r.resolve_number_type<int>() == r.resolve_number_type<const int>());
CHECK(r.resolve_number_type<int>() == r.resolve_number_type<volatile int>());
CHECK(r.resolve_number_type<int>() == r.resolve_number_type<const volatile int>());
}

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

@@ -126,67 +126,67 @@ namespace meta_hpp::detail
public:
template < array_kind Array >
[[nodiscard]] array_type resolve_array_type() {
return array_type{resolve_array_type_data<Array>()};
return array_type{resolve_array_type_data<std::remove_cv_t<Array>>()};
}
template < class_kind Class >
[[nodiscard]] class_type resolve_class_type() {
return class_type{resolve_class_type_data<Class>()};
return class_type{resolve_class_type_data<std::remove_cv_t<Class>>()};
}
template < class_kind Class, typename... Args >
[[nodiscard]] constructor_type resolve_constructor_type() {
return constructor_type{resolve_constructor_type_data<Class, Args...>()};
return constructor_type{resolve_constructor_type_data<std::remove_cv_t<Class>, Args...>()};
}
template < class_kind Class >
[[nodiscard]] destructor_type resolve_destructor_type() {
return destructor_type{resolve_destructor_type_data<Class>()};
return destructor_type{resolve_destructor_type_data<std::remove_cv_t<Class>>()};
}
template < enum_kind Enum >
[[nodiscard]] enum_type resolve_enum_type() {
return enum_type{resolve_enum_type_data<Enum>()};
return enum_type{resolve_enum_type_data<std::remove_cv_t<Enum>>()};
}
template < function_pointer_kind Function >
[[nodiscard]] function_type resolve_function_type() {
return function_type{resolve_function_type_data<Function>()};
return function_type{resolve_function_type_data<std::remove_cv_t<Function>>()};
}
template < member_pointer_kind Member >
[[nodiscard]] member_type resolve_member_type() {
return member_type{resolve_member_type_data<Member>()};
return member_type{resolve_member_type_data<std::remove_cv_t<Member>>()};
}
template < method_pointer_kind Method >
[[nodiscard]] method_type resolve_method_type() {
return method_type{resolve_method_type_data<Method>()};
return method_type{resolve_method_type_data<std::remove_cv_t<Method>>()};
}
template < nullptr_kind Nullptr >
[[nodiscard]] nullptr_type resolve_nullptr_type() {
return nullptr_type{resolve_nullptr_type_data<Nullptr>()};
return nullptr_type{resolve_nullptr_type_data<std::remove_cv_t<Nullptr>>()};
}
template < number_kind Number >
[[nodiscard]] number_type resolve_number_type() {
return number_type{resolve_number_type_data<Number>()};
return number_type{resolve_number_type_data<std::remove_cv_t<Number>>()};
}
template < pointer_kind Pointer >
[[nodiscard]] pointer_type resolve_pointer_type() {
return pointer_type{resolve_pointer_type_data<Pointer>()};
return pointer_type{resolve_pointer_type_data<std::remove_cv_t<Pointer>>()};
}
template < reference_kind Reference >
[[nodiscard]] reference_type resolve_reference_type() {
return reference_type{resolve_reference_type_data<Reference>()};
return reference_type{resolve_reference_type_data<std::remove_cv_t<Reference>>()};
}
template < void_kind Void >
[[nodiscard]] void_type resolve_void_type() {
return void_type{resolve_void_type_data<Void>()};
return void_type{resolve_void_type_data<std::remove_cv_t<Void>>()};
}
private: