metasequences.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_SEQUENCES_H
#define FENNEC_LANG_SEQUENCES_H
 
 
#include <fennec/lang/type_traits.h>
 
namespace fennec
{
 
// fennec::metasequence ====================================================================================================
 
template<typename ValueT, ValueT...Values> struct metasequence
{
    using value_type = ValueT;
 
    using type = metasequence;
 
    inline static constexpr size_t size() noexcept {
        return sizeof...(Values);
    }
};
 
 
 
// fennec::integer_metasequence ============================================================================================
 
template<typename IntT, IntT...Values> requires(is_integral_v<IntT>)
struct integer_metasequence : metasequence<IntT, Values...>
{
    using value_type = IntT;
 
    using type = integer_metasequence;
 
    inline static constexpr size_t size() noexcept {
        return sizeof...(Values);
    }
};
 
 
template<typename IntT, size_t N> struct make_integer_metasequence;
 
template<typename IntT, size_t N> using  make_integer_metasequence_t = typename make_integer_metasequence<IntT, N>::type;
 
 
 
// fennec::index_metasequence ==============================================================================================
 
template<size_t...Indices> struct index_metasequence : integer_metasequence<size_t, Indices...>
{
    using value_type = size_t;
 
    using type = index_metasequence;
 
    inline static constexpr size_t size() noexcept {
        return sizeof...(Indices);
    }
};
 
 
template<size_t N> struct make_index_metasequence;
 
template<size_t N> using  make_index_metasequence_t = typename make_index_metasequence<N>::type;
 
 
 
// fennec::concat_metasequence =============================================================================================
 
template<typename SequenceT0, typename SequenceT1> struct concat_metasequence;
 
template<typename SequenceT0, typename SequenceT1> using concat_metasequence_t
    = typename concat_metasequence<SequenceT0, SequenceT1>::type;
 
 
 
// Internal ============================================================================================================
 
// Implementation for Generating an integer_sequence
template<typename T, size_t N> struct make_integer_metasequence : concat_metasequence_t<make_integer_metasequence_t<T, N / 2>, make_integer_metasequence_t<T, N - N / 2>>{};
 
// Base Case of N=0
template<typename T> struct make_integer_metasequence<T, 0> : integer_metasequence<T> {};
 
// Base Case of N=1
template<typename T> struct make_integer_metasequence<T, 1> : integer_metasequence<T, 0>{};
 
 
// Implementation for Generating an index_sequence
template<size_t N> struct make_index_metasequence : concat_metasequence_t<make_index_metasequence_t<N / 2>, make_index_metasequence_t<N - N / 2>>{};
 
// Base Case of N=0
template<> struct make_index_metasequence<0> : index_metasequence<> {};
 
// Base Case of N=1
template<> struct make_index_metasequence<1> : index_metasequence<0>{};
 
 
// Specialization for integer sequences
template<typename T, T...SequenceV0, T...SequenceV1>
struct concat_metasequence<integer_metasequence<T, SequenceV0...>, integer_metasequence<T, SequenceV1...>>
    : integer_metasequence<T, SequenceV0..., (sizeof...(SequenceV0) + SequenceV1)...>{};
 
// Specialization for index sequences
template<size_t...SequenceV0, size_t...SequenceV1>
struct concat_metasequence<index_metasequence<SequenceV0...>, index_metasequence<SequenceV1...>>
    : index_metasequence<SequenceV0..., (sizeof...(SequenceV0) + SequenceV1)...>{};
 
 
 
}
 
#endif // FENNEC_LANG_SEQUENCES_H