460nm/asl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add is_array

Browse Source
This commit is contained in:
Steven Le Rouzic
2024-08-23 19:12:42 +02:00
parent add3e12550
commit ea795dcccb
7 changed files with 20 additions and 219 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
asl/BUILD.bazel
View File

@ -3,8 +3,6 @@ cc_library(
hdrs = [
"integers.hpp",
"meta.hpp",
"object.hpp",
"ptr.hpp",
"utility.hpp",
],
visibility = ["//visibility:public"],
@ -19,4 +17,4 @@ cc_library(
deps = [
":asl",
],
) for name in ["integers", "meta", "object", "ptr"]]
) for name in ["integers", "meta"]]

6
asl/meta.hpp
View File

@ -117,4 +117,10 @@ template<typename T> concept is_func = _is_func_helper<tame_t<T>>::value;
template<typename T> concept is_object = !is_void<T> && !is_ref<T> && !is_func<T>;
template<typename T> struct _is_array_helper : false_type {};
template<typename T> struct _is_array_helper<T[]> : true_type {};
template<typename T, int N> struct _is_array_helper<T[N]> : true_type {};
template<typename T> concept is_array = _is_array_helper<T>::value;
} // namespace asl

13
asl/meta_tests.cpp
View File

@ -132,4 +132,17 @@ static_assert(!asl::is_object<void>);
static_assert(!asl::is_object<void(int)>);
static_assert(!asl::is_object<int(float) const && noexcept>);
static_assert(!asl::is_array<Struct>);
static_assert(!asl::is_array<int>);
static_assert(!asl::is_array<int*>);
static_assert(!asl::is_array<int Struct::*>);
static_assert(!asl::is_array<int (Struct::*)(float)>);
static_assert(asl::is_array<int[]>);
static_assert(asl::is_array<int[45]>);
static_assert(!asl::is_array<Enum>);
static_assert(!asl::is_array<int&>);
static_assert(!asl::is_array<void>);
static_assert(!asl::is_array<void(int)>);
static_assert(!asl::is_array<int(float) const && noexcept>);
int main() { return 0; }

26
asl/object.hpp
View File

@ -1,26 +0,0 @@
#pragma once
#include "asl/ptr.hpp"
namespace asl {
template<typename T>
class object final
{
using wrapped = devoid_t<un_qual_t<typename ptr<T>::pointee>>;
ASL_NO_UNIQUE_ADDRESS wrapped m_value;
public:
object() requires default_constructible<wrapped> = default;
object(const object&) = default;
object(object&&) = default;
object& operator=(const object&) = default;
object& operator=(object&&) = default;
~object() = default;
};
} // namespace asl

70
asl/object_tests.cpp
View File

@ -1,70 +0,0 @@
#include "asl/object.hpp"
#include "asl/test_types.hpp"
static_assert(asl::is_object<asl::object<void>>);
static_assert(asl::is_object<asl::object<int>>);
static_assert(asl::is_object<asl::object<int&>>);
static_assert(asl::is_object<asl::object<int()>>);
static_assert(asl::is_empty<asl::object<void>>);
static_assert(asl::is_empty<asl::object<asl::empty>>);
static_assert(sizeof(asl::object<int>) == 4);
static_assert(sizeof(asl::object<int*>) == sizeof(void*));
static_assert(sizeof(asl::object<int&>) == sizeof(void*));
static_assert(sizeof(asl::object<int()>) == sizeof(void*));
static_assert(asl::default_constructible<asl::object<int>>);
static_assert(asl::default_constructible<asl::object<TriviallyDefaultConstructible>>);
static_assert(asl::default_constructible<asl::object<DefaultConstructible>>);
static_assert(!asl::default_constructible<asl::object<NonDefaultConstructible>>);
static_assert(asl::trivially_default_constructible<asl::object<int>>);
static_assert(asl::trivially_default_constructible<asl::object<TriviallyDefaultConstructible>>);
static_assert(!asl::trivially_default_constructible<asl::object<DefaultConstructible>>);
static_assert(!asl::trivially_default_constructible<asl::object<NonDefaultConstructible>>);
static_assert(asl::copy_constructible<asl::object<int>>);
static_assert(asl::copy_constructible<asl::object<TriviallyCopyConstructible>>);
static_assert(asl::copy_constructible<asl::object<CopyConstructible>>);
static_assert(!asl::copy_constructible<asl::object<NonCopyConstructible>>);
static_assert(asl::trivially_copy_constructible<asl::object<int>>);
static_assert(asl::trivially_copy_constructible<asl::object<TriviallyCopyConstructible>>);
static_assert(!asl::trivially_copy_constructible<asl::object<CopyConstructible>>);
static_assert(!asl::trivially_copy_constructible<asl::object<NonCopyConstructible>>);
static_assert(asl::move_constructible<asl::object<int>>);
static_assert(asl::move_constructible<asl::object<TriviallyMoveConstructible>>);
static_assert(asl::move_constructible<asl::object<MoveConstructible>>);
static_assert(!asl::move_constructible<asl::object<NonMoveConstructible>>);
static_assert(asl::trivially_move_constructible<asl::object<int>>);
static_assert(asl::trivially_move_constructible<asl::object<TriviallyMoveConstructible>>);
static_assert(!asl::trivially_move_constructible<asl::object<MoveConstructible>>);
static_assert(!asl::trivially_move_constructible<asl::object<NonMoveConstructible>>);
static_assert(asl::copy_assignable<asl::object<int>>);
static_assert(asl::copy_assignable<asl::object<CopyAssignable>>);
static_assert(asl::copy_assignable<asl::object<TriviallyCopyAssignable>>);
static_assert(!asl::copy_assignable<asl::object<NoCopyAssignable>>);
static_assert(asl::trivially_copy_assignable<asl::object<int>>);
static_assert(!asl::trivially_copy_assignable<asl::object<CopyAssignable>>);
static_assert(asl::trivially_copy_assignable<asl::object<TriviallyCopyAssignable>>);
static_assert(!asl::trivially_copy_assignable<asl::object<NoCopyAssignable>>);
static_assert(asl::move_assignable<asl::object<int>>);
static_assert(asl::move_assignable<asl::object<MoveAssignable>>);
static_assert(asl::move_assignable<asl::object<TriviallyMoveAssignable>>);
static_assert(!asl::move_assignable<asl::object<NoMoveAssignable>>);
static_assert(asl::trivially_move_assignable<asl::object<int>>);
static_assert(!asl::trivially_move_assignable<asl::object<MoveAssignable>>);
static_assert(asl::trivially_move_assignable<asl::object<TriviallyMoveAssignable>>);
static_assert(!asl::trivially_move_assignable<asl::object<NoMoveAssignable>>);
static_assert(asl::trivially_destructible<asl::object<int>>);
static_assert(asl::trivially_destructible<asl::object<TriviallyDestructible>>);
static_assert(!asl::trivially_destructible<asl::object<HasDestructor>>);
int main() { return 0; }

108
asl/ptr.hpp
View File

@ -1,108 +0,0 @@
#pragma once
#include "asl/integers.hpp"
#include "asl/meta.hpp"
#include "asl/utility.hpp"
namespace asl {
constexpr auto addr(auto&& ref) { return __builtin_addressof(ref); }
namespace ptr_internal {
template<is_object T>
class object_meta
{
public:
using pointee = T;
using metadata = empty;
};
template<is_void T>
class void_meta
{
public:
using pointee = T;
using metadata = empty;
};
template<typename T>
class array_meta;
template<is_object T, isize_t N>
class array_meta<T[N]>
{
public:
using pointee = T[N];
using metadata = empty;
};
template<is_object T>
class array_meta<T[]>
{
public:
using pointee = T;
using metadata = isize_t;
};
template<typename T>
class ptr_like_meta
{
static_assert(is_func<T> || is_ref<T>);
public:
using pointee = as_raw_ptr_t<T>;
using metadata = empty;
};
template<typename T>
constexpr auto get_meta()
{
if constexpr (is_object<T>)
{
return object_meta<T>{};
}
else if constexpr (is_void<T>)
{
return void_meta<T>{};
}
else if constexpr (is_array<T>)
{
return array_meta<T>{};
}
else if constexpr (is_ref<T> || is_func<T>)
{
return ptr_like_meta<T>{};
}
}
template<typename T>
using meta = decltype(get_meta<T>());
} // namespace ptr_internal
template<typename T>
concept is_ptr_metadata = requires
{
requires is_object<typename T::pointee> || is_void<typename T::pointee> || is_array<typename T::pointee>;
requires is_object<typename T::metadata>;
};
template<typename T>
class ptr final
{
using meta = ptr_internal::meta<T>;
static_assert(is_ptr_metadata<meta>);
public:
using pointee = meta::pointee;
using metadata = meta::metadata;
private:
pointee* m_ptr = nullptr;
ASL_NO_UNIQUE_ADDRESS metadata m_metadata;
public:
};
} // namespace asl

12
asl/ptr_tests.cpp
View File

@ -1,12 +0,0 @@
#include "asl/ptr.hpp"
static_assert(sizeof(asl::ptr<int>) == sizeof(int*));
static_assert(sizeof(asl::ptr<void>) == sizeof(void*));
static_assert(sizeof(asl::ptr<int[]>) == 2 * sizeof(int*));
static_assert(sizeof(asl::ptr<int[25]>) == sizeof(int*));
static_assert(sizeof(asl::ptr<int*>) == sizeof(int**));
static_assert(sizeof(asl::ptr<void(*)()>) == sizeof(void*));
static_assert(sizeof(asl::ptr<void()>) == sizeof(void*));
static_assert(sizeof(asl::ptr<int&>) == sizeof(int*));
int main() { return 0; }