Add is_array

7 files changed, 20 insertions, 219 deletions

diff --git a/asl/BUILD.bazel b/asl/BUILD.bazel
index fbbceed..c5f443e 100644
--- a/asl/BUILD.bazel
+++ b/asl/BUILD.bazel
@@ -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"]]

diff --git a/asl/meta.hpp b/asl/meta.hpp
index be5fa50..b3e0697 100644
--- a/asl/meta.hpp
+++ b/asl/meta.hpp
@@ -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

diff --git a/asl/meta_tests.cpp b/asl/meta_tests.cpp
index 1844e53..c2b27f4 100644
--- a/asl/meta_tests.cpp
+++ b/asl/meta_tests.cpp
@@ -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; }

diff --git a/asl/object.hpp b/asl/object.hpp
deleted file mode 100644
index e45376d..0000000
--- a/asl/object.hpp
+++ /dev/null
@@ -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

diff --git a/asl/object_tests.cpp b/asl/object_tests.cpp
deleted file mode 100644
index e3d7d8d..0000000
--- a/asl/object_tests.cpp
+++ /dev/null
@@ -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; }

diff --git a/asl/ptr.hpp b/asl/ptr.hpp
deleted file mode 100644
index 1da3f4e..0000000
--- a/asl/ptr.hpp
+++ /dev/null
@@ -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

diff --git a/asl/ptr_tests.cpp b/asl/ptr_tests.cpp
deleted file mode 100644
index 316ae1d..0000000
--- a/asl/ptr_tests.cpp
+++ /dev/null
@@ -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; }