type_sequences.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_SEQUENCES_H
#define FENNEC_LANG_TYPE_SEQUENCES_H
 
 
#include <fennec/lang/detail/_type_sequences.h>
 
namespace fennec
{
 
 
template<typename...TypesT> struct type_sequence {};
 
 
// fennec::first_element ===============================================================================================
 
template<typename...TypesT> struct first_element : detail::_first_element<TypesT...> {};
 
template<typename...TypesT> using first_element_t = typename first_element<TypesT...>::type;
 
 
 
// fennec::nth_element =================================================================================================
 
template<size_t n, typename...TypesT> struct nth_element : detail::_nth_element<n, 0, TypesT...> {};
 
template<size_t n, typename...TypesT> using nth_element_t = nth_element<n, TypesT...>::type;
 
 
 
// fennec::replace_first_element =======================================================================================
 
template<typename ClassT, typename SubT> struct replace_first_element { };
 
// Implementation
template<
    template<typename, typename...> class ClassT              // The Base Template
,   typename SubT, typename OriginT                           // The Original Type and Type to Substitute
,   typename... RestT>                                        // The Rest of the Parameter Pack
struct replace_first_element<ClassT<OriginT, RestT...>, SubT> // Specialization
    { using type = ClassT<SubT, RestT...>; };                 // Definition
 
 
 
// fennec::max_element_size ============================================================================================
 
template<typename...Ts> struct max_element_size : detail::_max_element_size<0, Ts...> {};
 
template<typename...Ts> constexpr size_t max_element_size_v = max_element_size<Ts...>::value;
 
 
 
// fennec::find_element ================================================================================================
 
template<typename T, typename...Ts> struct find_element : detail::_find_element<0, T, Ts...> {};
 
template<typename T, typename...Ts> constexpr size_t find_element_v = find_element<T, Ts...>::value;
 
 
 
// fennec::search_element ==============================================================================================
 
 
template<template<typename> typename SearchT, typename...TypesT> struct search_element : detail::_search_element<SearchT, TypesT...> {};
 
template<template<typename> typename SearchT, typename...TypesT> using search_element_t = search_element<SearchT, TypesT...>::type;
 
 
template<template<typename, typename...> typename, typename, typename...> struct search_element_args;
 
template<template<typename, typename...> typename SearchT, typename...TypesT, typename...ArgsT>
struct search_element_args<SearchT, type_sequence<ArgsT...>, TypesT...>
    : detail::_search_element_args<SearchT, detail::_type_sequence<ArgsT...>, TypesT...> {
};
 
 
 
 
// fennec::contains_element ============================================================================================
 
template<typename T, typename...Ts> struct contains_element : bool_constant<(is_same_v<T, Ts> or ...)> {};
 
template<typename T, typename...Ts> constexpr bool contains_element_v = contains_element<T, Ts...>::value;
 
 
 
// fennec::is_unique ===================================================================================================
 
template<typename...Ts> struct is_unique    : false_type {};
 
// Single type case
template<typename T>  struct is_unique<T> : true_type {};
 
// Recursion case
template<typename T, typename...Ts> requires(not is_same_v<T, Ts> && ...)
struct is_unique<T, Ts...> : is_unique<Ts...> {};
 
template<typename...Ts> constexpr bool is_unique_v = is_unique<Ts...>::value;
 
}
 
 
#endif // FENNEC_LANG_VARIADICS_H