type_traits.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
#ifndef FENNEC_LANG_TYPE_TRAITS_H
#define FENNEC_LANG_TYPE_TRAITS_H
 
 
#include <fennec/lang/intrinsics.h>
#include <fennec/lang/type_transforms.h>
#include <fennec/lang/detail/_type_traits.h>
 
namespace fennec
{
 
constexpr inline bool is_constant_evaluated() noexcept {
    if consteval {
        return true;
    } else {
        return false;
    }
}
 
 
// fennec::is_void =====================================================================================================
 
template<typename T> struct is_void
    : detail::_is_void<remove_cvref_t<T>>{};
 
template<typename T> constexpr bool_t is_void_v = is_void<T>::value;
 
 
 
// fennec::is_null_pointer =============================================================================================
 
template<typename T> struct is_null_pointer
    : detail::_is_null_pointer<remove_cvref_t<T>>{};
 
template<typename T> constexpr bool_t is_null_pointer_v = is_null_pointer<T>::value;
 
 
 
// fennec::is_bool =====================================================================================================
 
template<typename T> struct is_bool
    : detail::_is_bool<remove_cvref_t<T>>{};
 
template<typename T> constexpr bool_t is_bool_v = is_bool<T>::value;
 
 
 
// fennec::is_integral =================================================================================================
 
template<typename T> struct is_integral
    : detail::_is_integral<remove_cvref_t<T>> {};
 
template<typename T> constexpr bool_t is_integral_v = is_integral<T>::value;
 
 
 
// fennec::is_floating_point ===========================================================================================
 
template<typename T> struct is_floating_point
    : detail::_is_floating_point<remove_cvref_t<T>>{};
 
template<typename T> constexpr bool_t is_floating_point_v = is_floating_point<T> {};
 
 
 
// fennec::is_array ====================================================================================================
 
#ifdef FENNEC_BUILTIN_IS_ARRAY
 
template<typename T> struct is_array
    : bool_constant<FENNEC_BUILTIN_IS_ARRAY(T)> {};
 
#else
 
template<typename T> struct is_array
    : false_type {};
 
// overload for a sized array type
template<typename T, size_t N> struct is_array<T[N]>
    : true_type {};
 
// overload for a generic array type
template<typename T> struct is_array<T[]>
    : true_type {};
 
#endif
 
template<typename T> constexpr bool_t is_array_v = is_array<T>::value;
 
 
 
// fennec::is_enum ====================================================================================================
 
template<typename T> struct is_enum
    : bool_constant<FENNEC_BUILTIN_IS_ENUM(T)> {};
 
template<typename T> constexpr size_t is_enum_v = is_enum<T>::value;
 
 
 
// fennec::is_union ====================================================================================================
 
template<typename T> struct is_union
    : bool_constant<FENNEC_BUILTIN_IS_UNION(T)> {};
 
template<typename T> constexpr size_t is_union_v = is_union<T>::value;
 
 
 
// fennec::is_class ====================================================================================================
 
template<typename T> struct is_class
    : bool_constant<FENNEC_BUILTIN_IS_CLASS(T)> {};
 
template<typename T> constexpr size_t is_class_v = is_class<T>::value;
 
 
 
// fennec::is_function =================================================================================================
 
template<typename T> struct is_function
    : bool_constant<FENNEC_BUILTIN_IS_FUNCTION(T)> {};
 
template<typename T> constexpr size_t is_function_v = is_function<T>::value;
 
 
 
// fennec::is_pointer ==================================================================================================
 
template<typename T> struct is_pointer
    : detail::_is_pointer<remove_cvref_t<T>>{};
 
template<typename T> constexpr bool_t is_pointer_v = is_pointer<T> {};
 
 
 
// fennec::is_lvalue_reference =========================================================================================
 
template<typename T> struct is_lvalue_reference
    : detail::_is_lvalue_reference<T>{};
 
template<typename T> constexpr bool_t is_lvalue_reference_v = is_lvalue_reference<T> {};
 
 
 
// fennec::is_rvalue_reference =========================================================================================
 
template<typename T> struct is_rvalue_reference
    : detail::_is_rvalue_reference<T>{};
 
template<typename T> constexpr bool_t is_rvalue_reference_v = is_rvalue_reference<T> {};
 
 
 
// fennec::is_member_function_pointer ==================================================================================
 
template<typename T> struct is_member_function_pointer
    : bool_constant<FENNEC_BUILTIN_IS_MEMBER_FUNCTION_POINTER(T)> {};
 
template<typename T> constexpr bool_t is_member_function_pointer_v = is_member_function_pointer<T> {};
 
 
 
// fennec::is_member_object_pointer ====================================================================================
 
template<typename T> struct is_member_object_pointer
    : bool_constant<FENNEC_BUILTIN_IS_MEMBER_OBJECT_POINTER(T)> {};
 
template<typename T> constexpr bool_t is_member_object_pointer_v = is_member_object_pointer<T> {};
 
 
 
// fennec::is_arithmetic ===============================================================================================
 
template<typename T> struct is_arithmetic
    : bool_constant<is_integral_v<T> or is_floating_point_v<T>>{};
 
template<typename T> constexpr bool_t is_arithmetic_v = is_arithmetic<T>::value;
 
 
// fennec::is_fundamental ==============================================================================================
 
template<typename T> struct is_fundamental
    : bool_constant<is_arithmetic_v<T> or is_void_v<T> or is_null_pointer_v<T>>{};
 
template<typename T> constexpr bool_t is_fundamental_v = is_fundamental<T>::value;
 
 
 
// fennec::is_scalar ===================================================================================================
 
template<typename T> struct is_scalar
    : bool_constant<is_arithmetic_v<T> or is_enum_v<T> or is_pointer_v<T>>{};
 
template<typename T> constexpr bool_t is_scalar_v = is_scalar<T>::value;
 
 
 
// fennec::is_object ===================================================================================================
 
template<typename T> struct is_object : bool_constant<FENNEC_BUILTIN_IS_OBJECT(T)> {};
 
template<typename T> constexpr bool_t is_object_v = is_object<T>::value;
 
 
 
// fennec::is_compound =================================================================================================
 
template<typename T> struct is_compound : bool_constant<not is_fundamental_v<T>> {};
 
template<typename T> constexpr bool_t is_compound_v = is_compound<T>::value;
 
 
 
// fennec::is_reference ================================================================================================
 
template<typename T> struct is_reference
    : detail::_is_reference<T>{};
 
template<typename T> constexpr bool_t is_reference_v = is_reference<T> {};
 
 
 
// fennec::is_member_pointer ===========================================================================================
 
template<typename T> struct is_member_pointer
    : bool_constant<FENNEC_BUILTIN_IS_MEMBER_POINTER(T)> {};
 
template<typename T> constexpr bool_t is_member_pointer_v = is_member_pointer<T> {};
 
 
 
// fennec::is_trivial ==================================================================================================
 
template<typename T> struct is_trivial : bool_constant<FENNEC_BUILTIN_IS_TRIVIAL(T)> {};
 
template<typename T> constexpr bool_t is_trivial_v = is_trivial<T>{};
 
 
 
// fennec::is_trivially_copyable =======================================================================================
 
template<typename T> struct is_trivially_copyable : bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_COPYABLE(T)> {};
 
template<typename T> constexpr bool_t is_trivially_copyable_v = is_trivially_copyable<T>{};
 
 
 
// fennec::is_standard_layout ==========================================================================================
 
template<typename T> struct is_standard_layout : bool_constant<FENNEC_BUILTIN_IS_STANDARD_LAYOUT(T)> {};
 
template<typename T> constexpr bool_t is_standard_layout_v = is_standard_layout<T>{};
 
 
 
// fennec::has_unique_object_representations ===========================================================================
 
template<typename T> struct has_unique_object_representations
    : bool_constant<FENNEC_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS(remove_cv_t<T>)> {};
 
template<typename T> constexpr bool_t has_unique_object_representations_v = has_unique_object_representations<T>{};
 
 
 
// fennec::is_empty ====================================================================================================
 
template<typename T> struct is_empty : bool_constant<FENNEC_BUILTIN_IS_EMPTY(T)> {};
 
template<typename T> constexpr bool_t is_empty_v = is_empty<T>{};
 
 
 
// fennec::is_polymorphic ==============================================================================================
 
template<typename T> struct is_polymorphic : bool_constant<FENNEC_BUILTIN_IS_POLYMORPHIC(T)> {};
 
template<typename T> constexpr bool_t is_polymorphic_v = is_polymorphic<T>{};
 
 
 
// fennec::is_abstract =================================================================================================
 
template<typename T> struct is_abstract : bool_constant<FENNEC_BUILTIN_IS_ABSTRACT(T)> {};
 
template<typename T> constexpr bool_t is_abstract_v = is_abstract<T>{};
 
 
 
// fennec::is_complete =================================================================================================
 
template<typename T> struct is_complete : detail::_is_complete<T>::type {};
 
template<typename T> constexpr bool_t is_complete_v = is_complete<T>{};
 
 
 
// fennec::is_final =================================================================================================
 
template<typename T> struct is_final : bool_constant<FENNEC_BUILTIN_IS_FINAL(T)> {};
 
template<typename T> constexpr bool_t is_final_v = is_final<T>{};
 
 
 
// fennec::is_aggregate =================================================================================================
 
template<typename T> struct is_aggregate : bool_constant<FENNEC_BUILTIN_IS_AGGREGATE(T)> {};
 
template<typename T> constexpr bool_t is_aggregate_v = is_aggregate<T>{};
 
 
 
// fennec::is_signed =================================================================================================
 
 
template<typename T> struct is_signed
    : detail::_is_signed<remove_cvref_t<T>> {};
 
template<typename T> constexpr bool_t is_signed_v = is_signed<T>::value;
 
 
 
// fennec::is_unsigned =================================================================================================
 
 
template<typename T> struct is_unsigned
    : detail::_is_unsigned<remove_cvref_t<T>> {};
 
    template<typename T> constexpr bool_t is_unsigned_v = is_unsigned<T>::value;
 
 
// fennec::is_same =====================================================================================================
 
template<typename T0, typename T1> struct is_same : false_type {};
 
// true case
template<typename T> struct is_same<T, T> : true_type {};
 
template<typename T0, typename T1> constexpr bool_t is_same_v = is_same<T0, T1> {};
 
 
// fennec::is_base_of ==================================================================================================
 
template<typename Base, typename Derived> struct is_base_of : bool_constant<
    is_class_v<Base> and is_class_v<Derived> and decltype(detail::_is_base_of<Base, Derived>(0))::value
> {};
 
template<typename Base, typename Derived> constexpr bool_t is_base_of_v = is_base_of<Base, Derived> {};
 
 
 
// fennec::is_convertible ==============================================================================================
 
template<typename FromT, typename ToT> struct is_convertible
    : bool_constant<FENNEC_BUILTIN_IS_CONVERTIBLE(FromT, ToT)> {};
 
template<typename FromT, typename ToT> constexpr bool_t is_convertible_v = is_convertible<FromT, ToT>{};
 
 
 
// fennec::is_constructible ============================================================================================
 
template<typename ClassT, typename...ArgsT> struct is_constructible
    : bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, ArgsT...)> {};
 
template<typename ClassT, typename...ArgsT> constexpr bool_t is_constructible_v = is_constructible<ClassT, ArgsT...>{};
 
 
 
// fennec::is_trivially_constructible ==================================================================================
 
template<typename ClassT> struct is_trivially_constructible
    : bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE(ClassT)> {};
 
template<typename ClassT> constexpr bool_t is_trivially_constructible_v = is_trivially_constructible<ClassT>{};
 
 
 
// fennec::is_default_constructible ====================================================================================
 
template<typename ClassT> struct is_default_constructible
    : bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT,)> {};
 
template<typename ClassT> constexpr bool_t is_default_constructible_v = is_default_constructible<ClassT>{};
 
 
 
// fennec::is_copy_constructible =======================================================================================
 
template<typename ClassT> struct is_copy_constructible
    : bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
 
template<typename ClassT, typename...ArgsT> constexpr bool_t is_copy_constructible_v = is_copy_constructible<ClassT>{};
 
 
 
// fennec::is_move_constructible =======================================================================================
 
template<typename ClassT> struct is_move_constructible
    : bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_rvalue_reference_t<ClassT>)> {};
 
template<typename ClassT, typename...ArgsT> constexpr bool_t is_move_constructible_v = is_move_constructible<ClassT>{};
 
 
 
// fennec::is_assignable ===============================================================================================
 
template<typename ClassAT, typename ClassBT> struct is_assignable
    : bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(ClassAT, ClassBT)> {};
 
template<typename ClassT, typename...ArgsT> constexpr bool_t is_assignable_v = is_assignable<ClassT, ArgsT...>{};
 
 
 
// fennec::is_copy_assignable ==========================================================================================
 
template<typename ClassT> struct is_copy_assignable
    : bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
 
template<typename ClassT> constexpr bool_t is_copy_assignable_v = is_copy_assignable<ClassT>{};
 
 
 
// fennec::is_move_assignable ==========================================================================================
 
template<typename ClassT> struct is_move_assignable
    : bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
 
template<typename ClassT> constexpr bool_t is_move_assignable_v = is_move_assignable<ClassT>{};
 
 
 
// fennec::is_destructible =============================================================================================
 
template<typename ClassT> struct is_destructible
    : detail::_is_destructible<ClassT>::type {};
 
template<typename ClassT> constexpr bool_t is_destructible_v = is_destructible<ClassT>{};
 
 
 
// fennec::is_trivially_destructible ===================================================================================
 
template<typename ClassT> struct is_trivially_destructible
    : bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE(ClassT)> {};
 
template<typename ClassT> constexpr bool_t is_trivially_destructible_v = is_trivially_destructible<ClassT>{};
 
 
 
// fennec::is_nothrow_destructible =====================================================================================
 
template<typename ClassT> struct is_nothrow_destructible
    : detail::_is_nothrow_destructible<ClassT>::type {};
 
template<typename ClassT> constexpr bool_t is_nothrow_destructible_v = is_nothrow_destructible<ClassT>{};
 
 
 
// fennec::is_iterable =================================================================================================
 
template<typename T> struct is_iterable : decltype(detail::_is_iterable<T>(0)) {};
 
template<typename T> constexpr bool_t is_iterable_v = is_iterable<T>{};
 
 
 
// fennec::is_indexable ================================================================================================
 
template<typename T> struct is_indexable : decltype(detail::_is_indexable<T>(0)) {};
 
template<typename T> constexpr bool_t is_indexable_v = is_indexable<T>{};
 
 
 
// fennec::is_mappable =================================================================================================
 
template<typename T> struct is_mappable : decltype(detail::_is_mappable<T>(0)) {};
 
template<typename T> constexpr bool_t is_mappable_v = is_mappable<T>{};
 
 
}
 
#endif // FENNEC_LANG_TYPE_TRAITS_H