fennec-org/fennec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Documentation of containers, core, and format

Browse Source
This commit is contained in:
Medusa Slockbower
2025-12-18 00:00:36 -05:00
parent e7503ed92f
commit 9e6f00eb60
57 changed files with 2007 additions and 805 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/fennec/lang/assert.h
View File

@@ -46,18 +46,18 @@
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// assert(expr, desc)
/// <td width="50%" style="vertical-align: top">
/// Make an assertion with expression `expr` and provide a description `desc`. Only halts in debug mode.
/// Make an assertion with expression \f$expr\f$ and provide a description \f$desc\f$. Only halts in debug mode.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// assertf(expr, desc)
/// <td width="50%" style="vertical-align: top">
/// Make an assertion with expression `expr` and provide a description `desc`. Always halts.
/// Make an assertion with expression \f$expr\f$ and provide a description \f$desc\f$. Always halts.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// assertd(expr, desc)
/// <td width="50%" style="vertical-align: top">
/// Make an assertion, ***only in debug mode***, with expression `expr` and provide a description `desc`.
/// This should be used when the branching caused by `assert` would hinder performance in release mode.
/// Make an assertion, ***only in debug mode***, with expression \f$expr\f$ and provide a description \f$desc\f$.
/// This should be used when the branching caused by \f$assert\f$ would hinder performance in release mode.
///
/// </table>
///

8
include/fennec/lang/conditional_types.h
View File

@@ -90,12 +90,12 @@ using conditional_t
= typename conditional<B, TrueT, FalseT>::type;
// specialization of fennec::conditional for `true` case
// specialization of fennec::conditional for \f$true\f$ case
template<typename T, typename F>
struct conditional<true, T, F> : type_identity<T>{};
// specialization of fennec::conditional for `false` case
// specialization of fennec::conditional for \f$false\f$ case
template<typename T, typename F>
struct conditional<false, T, F> : type_identity<F>{};
@@ -105,7 +105,7 @@ struct conditional<false, T, F> : type_identity<F>{};
///
/// \brief Detect whether `DetectT<ArgsT...>` is a valid type
///
/// \details Selects `DetectT<ArgsT...>` if it exists, otherwise selects `DefaultT` The chosen type is stored in `detect::type` and
/// \details Selects `DetectT<ArgsT...>` if it exists, otherwise selects \f$DefaultT\f$ The chosen type is stored in `detect::type` and
/// a boolean value is stored in `detect::is_detected` representing whether `DetectT<ArgsT...>` is found.
/// \tparam DefaultT Default type
/// \tparam DetectT Type to detect
@@ -138,7 +138,7 @@ struct detect<DefaultT, DetectT, ArgsT...>
///
/// \brief Leverage SFINAE to conditionally enable a function or class at compile-time
///
/// \details If `B` is `true`, define a public member type `type`. Otherwise, there is no member. <br>
/// \details If \f$B\f$ is \f$true\f$, define a public member type \f$type\f$. Otherwise, there is no member. <br>
/// **Example Usage**
/// \code{.cpp}
/// template<typename TypeT,

14
include/fennec/lang/intrinsics.h
View File

@@ -55,44 +55,44 @@
/// `FENNEC_HAS_BUILTIN_IS_CONVERTIBLE` <br>
/// `B FENNEC_BUILTIN_IS_CONVERTIBLE(X, Y)`
/// <td width="50%" style="vertical-align: top">
/// Checks if type `X` can be converted to type `Y`.
/// Checks if type \f$X\f$ can be converted to type \f$Y\f$.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// `FENNEC_HAS_BUILTIN_IS_EMPTY` <br>
/// `B FENNEC_BUILTIN_IS_EMPTY(X)`
/// <td width="50%" style="vertical-align: top">
/// Checks if type `X` stores no data.
/// Checks if type \f$X\f$ stores no data.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// `FENNEC_HAS_BUILTIN_IS_POLYMORPHIC` <br>
/// `B FENNEC_BUILTIN_IS_POLYMORPHIC(X)`
/// <td width="50%" style="vertical-align: top">
/// Checks if type `X` is polymorphic, this is for classes only thus checks only for subtyping
/// Checks if type \f$X\f$ is polymorphic, this is for classes only thus checks only for subtyping
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// `FENNEC_HAS_BUILTIN_IS_FINAL` <br>
/// `B FENNEC_BUILTIN_IS_FINAL(X)`
/// <td width="50%" style="vertical-align: top">
/// Checks if type `X` is final, meaning a function or class cannot be derived from.
/// Checks if type \f$X\f$ is final, meaning a function or class cannot be derived from.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// `FENNEC_HAS_BUILTIN_IS_ABSTRACT` <br>
/// `B FENNEC_BUILTIN_IS_ABSTRACT(X)`
/// <td width="50%" style="vertical-align: top">
/// Opposite of `FENNEC_BUILTIN_IS_FINAL`, checks if abstract, meaning `X` has at least one pure virtual function.
/// Opposite of `FENNEC_BUILTIN_IS_FINAL`, checks if abstract, meaning \f$X\f$ has at least one pure virtual function.
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// `FENNEC_HAS_BUILTIN_IS_STANDARD_LAYOUT` <br>
/// `B FENNEC_BUILTIN_IS_STANDARD_LAYOUT(X)`
/// <td width="50%" style="vertical-align: top">
/// Checks if `X` has a standard layout, here is [full criteria](https://www.cppreference.com/w/cpp/language/classes.html#Standard-layout_class)
/// Checks if \f$X\f$ has a standard layout, here is [full criteria](https://www.cppreference.com/w/cpp/language/classes.html#Standard-layout_class)
/// for this trait
///
/// <tr><td width="50%" style="vertical-align: top"> <br>
/// `FENNEC_HAS_BUILTIN_IS_CONSTRUCTIBLE` <br>
/// `B FENNEC_BUILTIN_IS_CONSTRUCTIBLE(X, ...)`
/// <td width="50%" style="vertical-align: top">
/// Checks if type `X` is constructible with args `...`, such that `X::X(...)` exists.
/// Checks if type \f$X\f$ is constructible with args `...`, such that `X::X(...)` exists.
///
/// </table>
///

2
include/fennec/lang/metasequences.h
View File

@@ -80,7 +80,7 @@ namespace fennec
///
/// \brief metaprogramming sequence
///
/// \details Stores a sequence of values of type `ValueT` as a template pack.
/// \details Stores a sequence of values of type \f$ValueT\f$ as a template pack.
/// You can access the parameter pack in another template function, i.e.
/// \code{cpp}
/// template<typename TypeT, TypeT...Values>

6
include/fennec/lang/type_sequences.h
View File

@@ -97,7 +97,7 @@ template<size_t n, typename...TypesT> using nth_element_t = nth_element<n, Types
// fennec::replace_first_element =======================================================================================
///
/// \brief Take a Template with a Pack `ClassT<ArgsT...>` and replace the first `ArgT` of `ArgsT...` with `SubT`
/// \brief Take a Template with a Pack `ClassT<ArgsT...>` and replace the first \f$ArgT\f$ of `ArgsT...` with \f$SubT\f$
template<typename ClassT, typename SubT> struct replace_first_element { };
// Implementation
@@ -127,7 +127,7 @@ template<typename...Ts> constexpr size_t max_element_size_v = max_element_size<T
// fennec::find_element ================================================================================================
///
/// \brief Finds the index of `T` in `Ts`, if `T` is not found, results in `sizeof...(Ts)`
/// \brief Finds the index of \f$T\f$ in \f$Ts\f$, if \f$T\f$ is not found, results in `sizeof...(Ts)`
/// \tparam T The type to find
/// \tparam Ts The type sequence to check
template<typename T, typename...Ts> struct find_element : detail::_find_element<0, T, Ts...> {};
@@ -169,7 +169,7 @@ struct search_element_args<SearchT, type_sequence<ArgsT...>, TypesT...>
// fennec::contains_element ============================================================================================
///
/// \brief Checks if the type sequence `Ts...` contains `T`
/// \brief Checks if the type sequence `Ts...` contains \f$T\f$
/// \tparam T The type to find
/// \tparam Ts The type sequence to check
template<typename T, typename...Ts> struct contains_element : bool_constant<(is_same_v<T, Ts> or ...)> {};

140
include/fennec/lang/type_traits.h
View File

@@ -649,7 +649,7 @@ template<typename T> constexpr bool_t is_pointer_v = is_pointer<T> {};
///
/// \brief Check if \p T is of a floating point type
///
/// \details Checks if type `T` is a floating point type and store it in `is_same::value`.
/// \details Checks if type \f$T\f$ is a floating point type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_lvalue_reference
: detail::_is_lvalue_reference<T>{};
@@ -666,7 +666,7 @@ template<typename T> constexpr bool_t is_lvalue_reference_v = is_lvalue_referenc
///
/// \brief Check if \p T is of a floating point type
///
/// \details Checks if type `T` is a floating point type and store it in `is_same::value`.
/// \details Checks if type \f$T\f$ is a floating point type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_rvalue_reference
: detail::_is_rvalue_reference<T>{};
@@ -683,7 +683,7 @@ template<typename T> constexpr bool_t is_rvalue_reference_v = is_rvalue_referenc
///
/// \brief Check if \p T is a pointer to a member function
///
/// \details Checks if type `T` is pointer to a member function and store it in `is_member_function_pointer::value`.
/// \details Checks if type \f$T\f$ is pointer to a member function and store it in `is_member_function_pointer::value`.
/// \tparam T type to check
template<typename T> struct is_member_function_pointer
: bool_constant<FENNEC_BUILTIN_IS_MEMBER_FUNCTION_POINTER(T)> {};
@@ -700,7 +700,7 @@ template<typename T> constexpr bool_t is_member_function_pointer_v = is_member_f
///
/// \brief Check if \p T is a pointer to a member object
///
/// \details Checks if type `T` is pointer to a member object and store it in `is_member_object_pointer::value`.
/// \details Checks if type \f$T\f$ is pointer to a member object and store it in `is_member_object_pointer::value`.
/// \tparam T type to check
template<typename T> struct is_member_object_pointer
: bool_constant<FENNEC_BUILTIN_IS_MEMBER_OBJECT_POINTER(T)> {};
@@ -722,7 +722,7 @@ template<typename T> constexpr bool_t is_member_object_pointer_v = is_member_obj
///
/// \brief Check if \p T is an arithmetic type
///
/// \details Checks if type `T` is a built-in type with arithmetic operators and store it in `is_same::value`.
/// \details Checks if type \f$T\f$ is a built-in type with arithmetic operators and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_arithmetic
: bool_constant<is_integral_v<T> or is_floating_point_v<T>>{};
@@ -753,7 +753,7 @@ template<typename T> constexpr bool_t is_fundamental_v = is_fundamental<T>::valu
///
/// \brief Check if \p T is an arithmetic type
///
/// \details Checks if type `T` is a built-in type with arithmetic operators and store it in `is_scalar::value`.
/// \details Checks if type \f$T\f$ is a built-in type with arithmetic operators and store it in `is_scalar::value`.
/// \tparam T type to check
template<typename T> struct is_scalar
: bool_constant<is_arithmetic_v<T> or is_enum_v<T> or is_pointer_v<T>>{};
@@ -770,7 +770,7 @@ template<typename T> constexpr bool_t is_scalar_v = is_scalar<T>::value;
///
/// \brief Check if \p T is an object
///
/// \details Checks if type `T` is an object and store it in `is_object::value`.
/// \details Checks if type \f$T\f$ is an object and store it in `is_object::value`.
/// \tparam T type to check
template<typename T> struct is_object : bool_constant<FENNEC_BUILTIN_IS_OBJECT(T)> {};
@@ -786,7 +786,7 @@ template<typename T> constexpr bool_t is_object_v = is_object<T>::value;
///
/// \brief Check if \p T is a object compound type
///
/// \details Checks if type `T` is an object and store it in `is_compound::value`.
/// \details Checks if type \f$T\f$ is an object and store it in `is_compound::value`.
/// \tparam T type to check
template<typename T> struct is_compound : bool_constant<not is_fundamental_v<T>> {};
@@ -802,7 +802,7 @@ template<typename T> constexpr bool_t is_compound_v = is_compound<T>::value;
///
/// \brief Check if \p T is of a reference type
///
/// \details Checks if type `T` is a reference type and store it in `is_reference::value`.
/// \details Checks if type \f$T\f$ is a reference type and store it in `is_reference::value`.
/// \tparam T type to check
template<typename T> struct is_reference
: detail::_is_reference<T>{};
@@ -819,7 +819,7 @@ template<typename T> constexpr bool_t is_reference_v = is_reference<T> {};
///
/// \brief Check if \p T is a pointer to a member
///
/// \details Checks if type `T` is pointer to a member and store it in `is_member_function_pointer::value`.
/// \details Checks if type \f$T\f$ is pointer to a member and store it in `is_member_function_pointer::value`.
/// \tparam T type to check
template<typename T> struct is_member_pointer
: bool_constant<FENNEC_BUILTIN_IS_MEMBER_POINTER(T)> {};
@@ -841,7 +841,7 @@ template<typename T> constexpr bool_t is_member_pointer_v = is_member_pointer<T>
///
/// \brief Check if \p T is of a const type
///
/// \details Checks if type `T` is a const type and store it in `is_same::value`.
/// \details Checks if type \f$T\f$ is a const type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_const
: detail::_is_const<T>{};
@@ -858,7 +858,7 @@ template<typename T> constexpr bool_t is_const_v = is_const<T> {};
///
/// \brief Check if \p T is of a volatile type
///
/// \details Checks if type `T` is a volatile type and store it in `is_same::value`.
/// \details Checks if type \f$T\f$ is a volatile type and store it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_volatile
: detail::_is_volatile<T>{};
@@ -873,9 +873,9 @@ template<typename T> constexpr bool_t is_volatile_v = is_volatile<T> {};
// fennec::is_trivial --------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is trivial
/// \brief Check if type \f$T\f$ is trivial
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_trivial : bool_constant<FENNEC_BUILTIN_IS_TRIVIAL(T)> {};
@@ -889,9 +889,9 @@ template<typename T> constexpr bool_t is_trivial_v = is_trivial<T>{};
// fennec::is_trivially_copyable ---------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is trivially_copyable
/// \brief Check if type \f$T\f$ is trivially_copyable
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_trivially_copyable : bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_COPYABLE(T)> {};
@@ -905,9 +905,9 @@ template<typename T> constexpr bool_t is_trivially_copyable_v = is_trivially_cop
// fennec::is_standard_layout ------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is standard_layout
/// \brief Check if type \f$T\f$ is standard_layout
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_standard_layout : bool_constant<FENNEC_BUILTIN_IS_STANDARD_LAYOUT(T)> {};
@@ -921,9 +921,9 @@ template<typename T> constexpr bool_t is_standard_layout_v = is_standard_layout<
// fennec::has_unique_object_representations ---------------------------------------------------------------------------
///
/// \brief Check if type `T` has unique object representations
/// \brief Check if type \f$T\f$ has unique object representations
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct has_unique_object_representations
: bool_constant<FENNEC_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS(remove_cv_t<T>)> {};
@@ -938,9 +938,9 @@ template<typename T> constexpr bool_t has_unique_object_representations_v = has_
// fennec::is_empty ----------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is empty
/// \brief Check if type \f$T\f$ is empty
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_empty : bool_constant<FENNEC_BUILTIN_IS_EMPTY(T)> {};
@@ -954,9 +954,9 @@ template<typename T> constexpr bool_t is_empty_v = is_empty<T>{};
// fennec::is_polymorphic ----------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is polymorphic
/// \brief Check if type \f$T\f$ is polymorphic
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_polymorphic : bool_constant<FENNEC_BUILTIN_IS_POLYMORPHIC(T)> {};
@@ -970,9 +970,9 @@ template<typename T> constexpr bool_t is_polymorphic_v = is_polymorphic<T>{};
// fennec::is_abstract -------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is abstract
/// \brief Check if type \f$T\f$ is abstract
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_abstract : bool_constant<FENNEC_BUILTIN_IS_ABSTRACT(T)> {};
@@ -986,9 +986,9 @@ template<typename T> constexpr bool_t is_abstract_v = is_abstract<T>{};
// fennec::is_complete -------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is complete
/// \brief Check if type \f$T\f$ is complete
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_complete : detail::_is_complete<T>::type {};
@@ -1002,9 +1002,9 @@ template<typename T> constexpr bool_t is_complete_v = is_complete<T>{};
// fennec::is_final -------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is final
/// \brief Check if type \f$T\f$ is final
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_final : bool_constant<FENNEC_BUILTIN_IS_FINAL(T)> {};
@@ -1018,9 +1018,9 @@ template<typename T> constexpr bool_t is_final_v = is_final<T>{};
// fennec::is_aggregate -------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is aggregate
/// \brief Check if type \f$T\f$ is aggregate
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_aggregate : bool_constant<FENNEC_BUILTIN_IS_AGGREGATE(T)> {};
@@ -1037,7 +1037,7 @@ template<typename T> constexpr bool_t is_aggregate_v = is_aggregate<T>{};
///
/// \brief Check if \p T is of a signed integral
///
/// \details Checks if type `T` is a signed type i.e. `T(-1) < T(0)` and stores it in `is_same::value`.
/// \details Checks if type \f$T\f$ is a signed type i.e. `T(-1) < T(0)` and stores it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_signed
: detail::_is_signed<remove_cvref_t<T>> {};
@@ -1055,7 +1055,7 @@ template<typename T> constexpr bool_t is_signed_v = is_signed<T>::value;
///
/// \brief Check if \p T is of an unsigned integral
///
/// \details Checks if type `T` is an unsigned type i.e. `T(-1) > T(0)` and stores it in `is_same::value`.
/// \details Checks if type \f$T\f$ is an unsigned type i.e. `T(-1) > T(0)` and stores it in `is_same::value`.
/// \tparam T type to check
template<typename T> struct is_unsigned
: detail::_is_unsigned<remove_cvref_t<T>> {};
@@ -1172,9 +1172,9 @@ template<typename T> constexpr bool_t is_scoped_enum_v = is_scoped_enum<T>::valu
// fennec::is_convertible ----------------------------------------------------------------------------------------------
///
/// \brief Check if type `T0` can be converted `T1`
/// \brief Check if type \f$T0\f$ can be converted \f$T1\f$
///
/// \details Checks if `TypeT0`
/// \details Checks if \f$TypeT0\f$
/// \tparam FromT First type
/// \tparam ToT Second type
template<typename FromT, typename ToT> struct is_convertible
@@ -1191,8 +1191,8 @@ template<typename FromT, typename ToT> constexpr bool_t is_convertible_v = is_co
// fennec::is_constructible --------------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` can be constructed with `ArgsT,` i.e. `ClassT(ArgsT...)`.
/// This may be read as "is `ClassT` constructible with `ArgsT`"
/// \brief Check if \f$ClassT\f$ can be constructed with `ArgsT,` i.e. `ClassT(ArgsT...)`.
/// This may be read as "is \f$ClassT\f$ constructible with \f$ArgsT\f$"
/// \tparam ClassT The class type to test
/// \tparam ArgsT The arguments for the specific constructor
template<typename ClassT, typename...ArgsT> struct is_constructible
@@ -1207,7 +1207,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_constructible_v
// fennec::is_trivially_constructible ----------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially constructible
/// \brief Check if \f$ClassT\f$ is trivially constructible
/// \tparam ClassT The class type to test
/// \tparam ArgsT The arguments for the specific constructor
template<typename ClassT, typename...ArgsT> struct is_trivially_constructible
@@ -1222,7 +1222,7 @@ template<typename ClassT> constexpr bool_t is_trivially_constructible_v = is_tri
// fennec::is_nothrow_constructible ------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow constructible
/// \brief Check if \f$ClassT\f$ is nothrow constructible
/// \tparam ClassT The class type to test
/// \tparam ArgsT The arguments for the specific constructor
template<typename ClassT, typename...ArgsT> struct is_nothrow_constructible
@@ -1237,7 +1237,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_constructible_v = is_nothr
// fennec::is_default_constructible ------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is default constructible
/// \brief Check if \f$ClassT\f$ is default constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_default_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT)> {};
@@ -1251,7 +1251,7 @@ template<typename ClassT> constexpr bool_t is_default_constructible_v = is_defau
// fennec::is_trivially_default_constructible --------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially default constructible
/// \brief Check if \f$ClassT\f$ is trivially default constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_default_constructible
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_CONSTRUCTIBLE(ClassT)> {};
@@ -1265,7 +1265,7 @@ template<typename ClassT> constexpr bool_t is_trivially_default_constructible_v
// fennec::is_nothrow_default_constructible --------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow default constructible
/// \brief Check if \f$ClassT\f$ is nothrow default constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_default_constructible
: bool_constant<FENNEC_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE(ClassT)> {};
@@ -1279,7 +1279,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_default_constructible_v =
// fennec::is_copy_constructible ---------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is copy constructible
/// \brief Check if \f$ClassT\f$ is copy constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_copy_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1293,7 +1293,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_copy_constructib
// fennec::is_trivially_copy_constructible -----------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially copy constructible
/// \brief Check if \f$ClassT\f$ is trivially copy constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_copy_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1307,7 +1307,7 @@ template<typename ClassT> struct is_trivially_copy_constructible
// fennec::is_nothrow_copy_constructible -------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow copy constructible
/// \brief Check if \f$ClassT\f$ is nothrow copy constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_copy_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1321,7 +1321,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_nothrow_copy_con
// fennec::is_move_constructible ---------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is move constructible
/// \brief Check if \f$ClassT\f$ is move constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_move_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_rvalue_reference_t<ClassT>)> {};
@@ -1335,7 +1335,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_move_constructib
// fennec::is_trivially_move_constructible -----------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially move constructible
/// \brief Check if \f$ClassT\f$ is trivially move constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_move_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1349,7 +1349,7 @@ template<typename ClassT> struct is_trivially_move_constructible
// fennec::is_nothrow_move_constructible -------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow move constructible
/// \brief Check if \f$ClassT\f$ is nothrow move constructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_move_constructible
: bool_constant<FENNEC_BUILTIN_IS_CONSTRUCTIBLE(ClassT, add_lvalue_reference_t<const ClassT>)> {};
@@ -1363,7 +1363,7 @@ template<typename ClassT, typename...ArgsT> constexpr bool_t is_nothrow_move_con
// fennec::is_assignable -----------------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is assignable
/// \brief Check if \f$ClassT\f$ is assignable
/// \tparam ClassAT The class type to test
/// \tparam ClassBT The arguments for the specific constructor
template<typename ClassAT, typename ClassBT> struct is_assignable
@@ -1378,7 +1378,7 @@ template<typename ClassAT, typename ClassBT> constexpr bool_t is_assignable_v =
// fennec::is_trivially_assignable -------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially assignable
/// \brief Check if \f$ClassT\f$ is trivially assignable
/// \tparam ClassAT The class type to test
/// \tparam ClassBT The arguments for the specific constructor
template<typename ClassAT, typename ClassBT> struct is_trivially_assignable
@@ -1394,7 +1394,7 @@ template<typename ClassAT, typename ClassBT> constexpr bool_t is_trivially_assig
// fennec::is_nothrow_assignable ---------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow assignable
/// \brief Check if \f$ClassT\f$ is nothrow assignable
/// \tparam ClassAT The class type to test
/// \tparam ClassBT The arguments for the specific constructor
template<typename ClassAT, typename ClassBT> struct is_nothrow_assignable
@@ -1409,7 +1409,7 @@ template<typename ClassAT, typename ClassBT> constexpr bool_t is_nothrow_assigna
// fennec::is_copy_assignable ------------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is copy assignable
/// \brief Check if \f$ClassT\f$ is copy assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_copy_assignable
: bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
@@ -1423,7 +1423,7 @@ template<typename ClassT> constexpr bool_t is_copy_assignable_v = is_copy_assign
// fennec::is_trivially_copy_assignable --------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially_copy assignable
/// \brief Check if \f$ClassT\f$ is trivially_copy assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_copy_assignable
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
@@ -1437,7 +1437,7 @@ template<typename ClassT> constexpr bool_t is_trivially_copy_assignable_v = is_t
// fennec::is_nothrow_copy_assignable ----------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow_copy assignable
/// \brief Check if \f$ClassT\f$ is nothrow_copy assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_copy_assignable
: bool_constant<FENNEC_BUILTIN_IS_NOTHROW_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_lvalue_reference_t<const ClassT>)> {};
@@ -1451,7 +1451,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_copy_assignable_v = is_not
// fennec::is_move_assignable ------------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is move assignable
/// \brief Check if \f$ClassT\f$ is move assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_move_assignable
: bool_constant<FENNEC_BUILTIN_IS_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
@@ -1465,7 +1465,7 @@ template<typename ClassT> constexpr bool_t is_move_assignable_v = is_move_assign
// fennec::is_trivially_move_assignable --------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially_move assignable
/// \brief Check if \f$ClassT\f$ is trivially_move assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_move_assignable
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
@@ -1479,7 +1479,7 @@ template<typename ClassT> constexpr bool_t is_trivially_move_assignable_v = is_t
// fennec::is_nothrow_move_assignable --------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow_move assignable
/// \brief Check if \f$ClassT\f$ is nothrow_move assignable
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_move_assignable
: bool_constant<FENNEC_BUILTIN_IS_NOTHROW_ASSIGNABLE(add_lvalue_reference_t<ClassT>, add_rvalue_reference_t<ClassT>)> {};
@@ -1493,7 +1493,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_move_assignable_v = is_not
// fennec::is_destructible ---------------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is destructible
/// \brief Check if \f$ClassT\f$ is destructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_destructible
: detail::_is_destructible<ClassT>::type {};
@@ -1507,7 +1507,7 @@ template<typename ClassT> constexpr bool_t is_destructible_v = is_destructible<C
// fennec::is_trivially_destructible -----------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is trivially destructible
/// \brief Check if \f$ClassT\f$ is trivially destructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_trivially_destructible
: bool_constant<FENNEC_BUILTIN_IS_TRIVIALLY_DESTRUCTIBLE(ClassT)> {};
@@ -1521,7 +1521,7 @@ template<typename ClassT> constexpr bool_t is_trivially_destructible_v = is_triv
// fennec::is_nothrow_destructible -------------------------------------------------------------------------------------
///
/// \brief Check if `ClassT` is nothrow destructible
/// \brief Check if \f$ClassT\f$ is nothrow destructible
/// \tparam ClassT The class type to test
template<typename ClassT> struct is_nothrow_destructible
: detail::_is_nothrow_destructible<ClassT>::type {};
@@ -1542,7 +1542,7 @@ template<typename ClassT> constexpr bool_t is_nothrow_destructible_v = is_nothro
///
/// \brief Check if the two types are identical
///
/// \details Checks if `T0` and `T1` are identical and store it in `is_same::value`
/// \details Checks if \f$T0\f$ and \f$T1\f$ are identical and store it in `is_same::value`
/// \tparam T0 first type to check
/// \tparam T1 second type to check
template<typename T0, typename T1> struct is_same : false_type {};
@@ -1561,9 +1561,9 @@ template<typename T0, typename T1> constexpr bool_t is_same_v = is_same<T0, T1>
// fennec::is_base_of --------------------------------------------------------------------------------------------------
///
/// \brief Check if `Derived` has a base type of `Base`
/// \brief Check if \f$Derived\f$ has a base type of \f$Base\f$
///
/// \details Checks if `Base` is a base type of `Derived` and stores it in `is_base_of::value`
/// \details Checks if \f$Base\f$ is a base type of \f$Derived\f$ and stores it in `is_base_of::value`
/// \tparam Base base type to check
/// \tparam Derived derived type to check
template<typename Base, typename Derived> struct is_base_of : bool_constant<
@@ -1581,9 +1581,9 @@ template<typename Base, typename Derived> constexpr bool_t is_base_of_v = is_bas
// fennec::is_iterable -------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is iterable
/// \brief Check if type \f$T\f$ is iterable
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_iterable : decltype(detail::_is_iterable<T>(0)) {};
@@ -1597,9 +1597,9 @@ template<typename T> constexpr bool_t is_iterable_v = is_iterable<T>{};
// fennec::is_indexable ------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is indexable
/// \brief Check if type \f$T\f$ is indexable
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_indexable : decltype(detail::_is_indexable<T>(0)) {};
@@ -1613,9 +1613,9 @@ template<typename T> constexpr bool_t is_indexable_v = is_indexable<T>{};
// fennec::is_mappable -------------------------------------------------------------------------------------------------
///
/// \brief Check if type `T` is mappable
/// \brief Check if type \f$T\f$ is mappable
///
/// \details Checks if `T`
/// \details Checks if \f$T\f$
/// \tparam T type to check
template<typename T> struct is_mappable : decltype(detail::_is_mappable<T>(0)) {};

22
include/fennec/lang/type_transforms.h
View File

@@ -138,7 +138,7 @@ template<typename T> using decay_t = typename decay<T>::type;
///
/// \brief adds a pointer level to \p T
///
/// \details adds a pointer to the provided type such that `T` becomes `T*`
/// \details adds a pointer to the provided type such that \f$T\f$ becomes `T*`
/// \tparam T Resultant Type
template<typename T> struct add_pointer : detail::_add_pointer<T>{};
@@ -150,7 +150,7 @@ template<typename T> using add_pointer_t = typename add_pointer<T>::type;
///
/// \brief removes a pointer level from \p T
///
/// \details removes a pointer from the provided type such that `T*` becomes `T`
/// \details removes a pointer from the provided type such that `T*` becomes \f$T\f$
/// \tparam T Resultant Type
template<typename T> struct remove_pointer : detail::_remove_pointer<T> {};
@@ -162,7 +162,7 @@ template<typename T> using remove_pointer_t = typename remove_pointer<T>::type;
///
/// \brief removes all pointer levels from \p T
///
/// \details removes all pointers from the provided type such that `T*`, `T**`, etc. becomes `T`
/// \details removes all pointers from the provided type such that `T*`, `T**`, etc. becomes \f$T\f$
/// \tparam T Resultant Type
template<typename T> struct strip_pointers : conditional_t<
detail::_is_pointer<T>::value,
@@ -179,7 +179,7 @@ template<typename T> using strip_pointers_t = strip_pointers<T>::type;
///
/// \brief add a reference to \p T
///
/// \details adds a pointer to the provided type such that `T` becomes `T&`
/// \details adds a pointer to the provided type such that \f$T\f$ becomes `T&`
/// \tparam T Resultant Type
template<typename T> struct add_reference : type_identity<T&> {};
@@ -191,7 +191,7 @@ template<typename T> using add_reference_t = typename add_reference<T>::type;
///
/// \brief remove a reference from \p T
///
/// \details removes references from the provided type such that `T&` and `T&&` become `T`
/// \details removes references from the provided type such that `T&` and `T&&` become \f$T\f$
/// \tparam T Reference Type
template<typename T> struct remove_reference : type_identity<T> {};
@@ -236,7 +236,7 @@ template<typename T> using add_rvalue_reference_t = typename add_rvalue_referen
///
/// \brief add the const qualifier to the provided type \p T
///
/// \details adds const qualification to the provided type such that `T` becomes `const T`
/// \details adds const qualification to the provided type such that \f$T\f$ becomes `const T`
/// \tparam T Reference Type
template<typename T> struct add_const : detail::_add_const<T> {};
@@ -248,7 +248,7 @@ template<typename T> using add_const_t = typename add_const<T>::type;
///
/// \brief remove the const qualifier from the provided type \p T
///
/// \details removes const qualification from the provided type such that `const T` becomes `T`
/// \details removes const qualification from the provided type such that `const T` becomes \f$T\f$
/// \tparam T Reference Type
template<typename T> struct remove_const : detail::_remove_const<T> {};
@@ -261,7 +261,7 @@ template<typename T> using remove_const_t = typename remove_const<T>::type;
///
/// \brief add the volatile qualifier to the provided type \p T
///
/// \details removes references from the provided type such that `T` becomes `volatile T`
/// \details removes references from the provided type such that \f$T\f$ becomes `volatile T`
/// \tparam T Reference Type
template<typename T> struct add_volatile : detail::_add_volatile<T> {};
@@ -273,7 +273,7 @@ template<typename T> using add_volatile_t = typename add_volatile<T>::type;
///
/// \brief remove the volatile qualifier from the provided type \p T
///
/// \details removes references from the provided type such that `volatile T` becomes `T`
/// \details removes references from the provided type such that `volatile T` becomes \f$T\f$
/// \tparam T Reference Type
template<typename T> struct remove_volatile : detail::_remove_volatile<T> {};
@@ -286,7 +286,7 @@ template<typename T> using remove_volatile_t = typename remove_volatile<T>::type
///
/// \brief remove the volatile qualifier from the provided type \p T
///
/// \details removes references from the provided type such that `T`, `const T`, and `volatile T` become
/// \details removes references from the provided type such that \f$T\f$, `const T`, and `volatile T` become
/// `const volatile T`
/// \tparam T Reference Type
template<typename T> struct add_cv : detail::_add_cv<T> {};
@@ -301,7 +301,7 @@ template<typename T> using add_cv_t = typename add_cv<T>::type;
/// \brief remove the const and volatile qualifiers from the provided type \p T
///
/// \details removes const and volatile from the provided type such that `const T`, `volatile T`, and
/// `const volatile T` become `T`
/// `const volatile T` become \f$T\f$
/// \tparam T Reference Type
template<typename T> struct remove_cv : detail::_remove_cv<T> {};

2
include/fennec/lang/types.h
View File

@@ -247,7 +247,7 @@ namespace fennec
using uintptr_t = uintptr_t; ///< \brief Unsigned Integer Capable of Holding a Pointer to void
using intmax_t = intmax_t; ///< \brief Maximum Width Signed Integer Type
using uintmax_t = uintmax_t; ///< \brief Maximum Width Unsigned Integer Type
using size_t = size_t; ///< \brief Unsigned Integer Type Returned By `sizeof`, `sizeof...`, and `alignof`
using size_t = size_t; ///< \brief Unsigned Integer Type Returned By \f$sizeof\f$, `sizeof...`, and \f$alignof\f$
using ptrdiff_t = __PTRDIFF_TYPE__; ///< \brief Signed Integer Type Returned by the Subtraction of two Pointers
struct empty_t {};