Add is_array

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"]]

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

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; }

asl/object.hpp

@@ -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

asl/object_tests.cpp

@@ -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; }

asl/ptr.hpp

@@ -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

asl/ptr_tests.cpp

@@ -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; }