C++26: Индексирование пакетов и метапрограммиро­вание

// До C++26 приходилось использовать ухищрения:
template<size_t N, typename... Ts>
using nth_type = typename std::tuple_element<N, std::tuple<Ts...>>::type;
 
// Или громоздкие рекурсивные решения для значений...

template<typename... Types>
class TypeCollection {};
 
template<auto... Values>
class ValueCollection {};

// Fold-выражения отлично подходят для таких операций:
template<typename... Types>
void printSizes() {
    (std::cout << sizeof(Types) << " ", ...);
}

// Вариант с std::tuple и tuple_element
template<size_t N, typename... Ts>
struct nth_type_impl {
    using type = typename std::tuple_element<N, std::tuple<Ts...>>::type;
};
 
template<size_t N, typename... Ts>
using nth_type = typename nth_type_impl<N, Ts...>::type;

template<size_t N, typename T, typename... Ts>
auto get_nth(T&& first, Ts&&... rest) {
    if constexpr (N == 0)
        return std::forward<T>(first);
    else
        return get_nth<N-1>(std::forward<Ts>(rest)...);
}

template<size_t N, typename... Ts>
auto get_nth_value(Ts&&... args) {
    return std::get<N>(std::forward_as_tuple(std::forward<Ts>(args)...));
}

// Пример ещё одного подхода - через рекурсивное наследование:
template<size_t N, typename... Ts>
struct TypeAt;
 
template<typename T, typename... Ts>
struct TypeAt<0, T, Ts...> {
    using type = T;
};
 
template<size_t N, typename T, typename... Ts>
struct TypeAt<N, T, Ts...> {
    using type = typename TypeAt<N-1, Ts...>::type;
};

// 1. Прямое развертывание в списки (C++11)
template<typename... Args>
void func(Args... args) {
    another_func(args...); // развертывание всех параметров
}
 
// 2. Развертывание с шаблоном (C++11)
template<typename... Args>
void func(Args... args) {
    int dummy[] = { (process(args), 0)... }; // вызов process для каждого аргумента
}
 
// 3. Fold-выражения (C++17)
template<typename... Args>
auto sum(Args... args) {
    return (args + ...); // левая свертка
}

template<typename... Bases>
class MultiInherited : public Bases... {
public:
    // Как тут обратиться к методу только третьего базового класса?
};

// При вызове с N > размера пакета
template<size_t N, typename... Ts>
using NthType = typename NthTypeImpl<N, Ts...>::type;
 
// Может выдать что-то вроде:
// error: no type named 'type' in 'NthTypeImpl<5, int, double, float>'

template <std::size_t I, typename T, typename... Ts>
struct index_element {
    static_assert(I < sizeof...(Ts) + 1, "Index out of bounds");
    using type = 
        std::conditional_t<
            I == 0, 
            T, 
            typename index_element<I - 1, Ts...>::type
        >;
};
 
template <std::size_t I, typename T>
struct index_element<I, T> {
    static_assert(I == 0, "Index out of bounds");
    using type = T;
};

template<typename... Ts>
void someFunc(Ts... args) {
    char dummy[] = {
        (std::cout << args, '0')...
    };
    (void)dummy; // предотвращаем предупреждение о неиспользуемой переменной
}

template<typename... Ts, std::size_t... Is>
void indexed_process(std::tuple<Ts...>& tuple, std::index_sequence<Is...>) {
    // теперь у нас есть доступ к индексам Is...
    (process(Is, std::get<Is>(tuple)), ...);
}
 
template<typename... Ts>
void process_with_indices(Ts&&... args) {
    auto tuple = std::forward_as_tuple(std::forward<Ts>(args)...);
    indexed_process(tuple, std::make_index_sequence<sizeof...(Ts)>{});
}

template<std::size_t N, typename T, typename... Ts>
struct get_type {
    using type = typename get_type<N-1, Ts...>::type;
};
 
template<typename T, typename... Ts>
struct get_type<0, T, Ts...> {
    using type = T;
};

template<std::size_t N, typename T, typename... Ts>
auto get_value(T&& first, Ts&&... rest) {
    if constexpr (N == 0) 
        return std::forward<T>(first);
    else 
        return get_value<N-1>(std::forward<Ts>(rest)...);
}

template<typename... Ts>
auto get_indexed_type() {
    return typeid(Ts...[2]); // Прямой доступ к третьему типу
}
 
template<typename... Ts>
auto get_indexed_value(Ts... values) {
    return values...[2]; // Прямой доступ к третьему значению
}

error: no type named 'type' in 'get_type<5, int, double, float>'

error: invalid index 5 for parameter pack of size 3

template <typename... T>
constexpr auto first(T... values) -> T...[0] {
    return values...[0];
}
 
template <typename... T>
constexpr auto last(T... values) -> T...[sizeof...(values)-1] {
    return values...[sizeof...(values)-1];
}

template <typename... Args>
auto get_middle(Args... args) {
    constexpr auto mid = sizeof...(args) / 2;
    return args...[mid]; 
}

// В выражениях типа
template <typename... Ts>
using third_type = Ts...[2];
 
// В аргументах шаблона
std::tuple<Ts...[0], Ts...[1]> make_pair_tuple(Ts... args);
 
// В выражениях наследования 
template <typename... Bases>
class Derived : public Bases...[0], private Bases...[1] { };
 
// В списках инициализации
template <typename... Types>
void initialize_array() {
    Types...[0] arr[] = { Types...[1]{}, Types...[2]{} };
}

// Вызов first() без аргументов вызовет ошибку:
// error: invalid index 0 for pack 'T' of size 0

template <typename... T>
auto second_and_penultimate(T... args) {
    static_assert(sizeof...(args) >= 2, "Need at least 2 elements");
    
    return std::make_pair(
        args...[1],
        args...[sizeof...(args) - 2]
    );
}

// Функция, которая работает только если первый тип — целочисленный
template <typename... Ts>
std::enable_if_t<std::is_integral_v<Ts...[0]>, void> 
process_if_first_integral(Ts... values) {
    std::cout << "First value: " << values...[0] << std::endl;
}

template <typename... Ts>
    requires std::integral<Ts...[0]> || std::floating_point<Ts...[0]>
auto numeric_operations(Ts... args) {
    auto first = args...[0];
    // Операции с гарантированно числовым first
    return first * 2;
}

// Это НЕ извлекает третий элемент из кортежа!
template <typename... Ts>
auto extract_third(std::tuple<Ts...> tuple) {
    return Ts...[2]; // Извлекает третий ТИП из пакета типов Ts
}
 
// Правильное использование:
template <typename... Ts>
auto extract_third(std::tuple<Ts...> tuple) {
    return std::get<2>(tuple); // Извлекает третий ЭЛЕМЕНТ из кортежа
}

template <typename... Ts>
void correct() {
    using T = Ts...[0]; // Правильно
    // using T = Ts[0]...; // Неправильно
}

template <typename... Ts>
auto empty_pack_test() -> Ts...[0] {
    return {}; // Ошибка при инстанцировании с пустым пакетом
}
 
// Вызовет ошибку примерно такого вида:
// error: invalid index 0 for pack 'Ts' of size 0

template <typename... Ts>
auto complex_indexing() {
    constexpr size_t index = (sizeof(Ts...[0]) > 4) ? 1 : 2;
    return Ts...[index]; // Динамический выбор индекса
}

template <typename... Ts>
auto runtime_index(int i) -> Ts...[i] { // Ошибка!
    return {};
}

// В списке базовых классов
template <typename... Bases>
struct Derived : Bases...[0], Bases...[1] {};
 
// В списке аргументах шаблона
template <typename... Args>
using FirstTwo = std::pair<Args...[0], Args...[1]>;
 
// В списке параметров
template <typename... Params>
void foo(Params...[0] first, Params...[1] second) { /*...*/ }

template <typename... Ts>
constexpr auto safe_access() {
    if constexpr (sizeof...(Ts) > 2) {
        return Ts...[2]; // Будет ошибка, если пакет содержит менее 3 элементов
    } else {
        return Ts...[0]; // Будет ошибка, если пакет пуст
    }
}

template <typename... Ts>
requires (sizeof...(Ts) > 2)
constexpr auto safe_third() {
    return Ts...[2]; // Гарантированно безопасно
}

template <typename... Outer>
struct NestedIndexing {
    template <typename... Inner>
    static auto test() {
        return Inner...[Outer...[0]]; // Индексируем Inner по значению первого элемента Outer
    }
};

template <typename... Args>
requires std::same_as<Args...[0], int> && std::floating_point<Args...[1]>
void numeric_process(Args... args) {
    auto int_value = args...[0];
    auto float_value = args...[1];
    
    // Гарантированно работаем с целым числом и числом с плавающей точкой
    std::cout << "Integer: " << int_value << ", Float: " << float_value << std::endl;
}

template <typename... Types>
auto create_selective_tuple() {
    // Создаём кортеж только из каждого второго типа
    if constexpr (sizeof...(Types) <= 1) {
        return std::tuple<>{};
    } else {
        return std::tuple<Types...[0], Types...[2], Types...[4]>{};
    }
}

template <typename... Elements>
class TypedContainer {
private:
    // Хранение данных в типизированных полях
    Elements...[0] first_;
    Elements...[1] second_;
    std::optional<Elements...[2]> third_;
    
public:
    TypedContainer(Elements...[0] f, Elements...[1] s)
        : first_(f), second_(s), third_(std::nullopt) {}
        
    void set_third(Elements...[2] t) {
        third_ = t;
    }
    
    auto as_tuple() const {
        return std::make_tuple(first_, second_, third_);
    }
};

template <typename... Args>
auto positional_transform(Args... args) {
    if constexpr (sizeof...(Args) >= 3) {
        // Первый элемент умножаем на 2
        auto first = args...[0] * 2;
        
        // Второй элемент преобразуем в строку
        auto second = std::to_string(args...[1]);
        
        // Третий элемент инвертируем (если булевский)
        auto third = [&]() {
            if constexpr (std::is_same_v<Args...[2], bool>) {
                return !args...[2];
            } else {
                return args...[2];
            }
        }();
        
        return std::make_tuple(first, second, third);
    } else {
        // Для коротких пакетов другая логика
        return std::make_tuple(args...);
    }
}

template <typename... Ts>
auto compile_time_dispatcher() {
    if constexpr (std::is_integral_v<Ts...[0]>) {
        // Ветка для целочисленного первого типа
        return [](Ts... args) { return process_integer(args...[0], args...); };
    } else if constexpr (std::is_floating_point_v<Ts...[0]>) {
        // Ветка для вещественного первого типа
        return [](Ts... args) { return process_float(args...[0], args...); };
    } else {
        // Ветка по умолчанию
        return [](Ts... args) { return process_generic(args...); };
    }
}

template <typename... Components>
auto create_entity() {
    Entity e;
    
    // Добавляем компоненты выборочно
    if constexpr (sizeof...(Components) > 0 && 
                  requires { e.add<Components...[0]>(); }) {
        e.add<Components...[0]>();
    }
    
    if constexpr (sizeof...(Components) > 1 && 
                  requires { e.add<Components...[1]>(); }) {
        e.add<Components...[1]>();
    }
    
    // И так далее...
    
    return e;
}

template <typename... Policies>
class ConfigurableSystem {
private:
    using ErrorPolicy = Policies...[0];
    using LoggingPolicy = Policies...[1];
    using AllocationPolicy = Policies...[2];
    
    ErrorPolicy error_handler_;
    LoggingPolicy logger_;
    AllocationPolicy allocator_;
    
public:
    void process() {
        try {
            // Используем политики
            auto ptr = allocator_.allocate(100);
            logger_.log("Allocated memory");
            // ...
        } catch (const std::exception& e) {
            error_handler_.handle(e);
        }
    }
};

template <typename... SupportedTypes>
class GenericProxy {
public:
    template <typename T>
    auto convert(T value) {
        // Проверяем, поддерживается ли тип
        if constexpr ((std::is_same_v<T, SupportedTypes> || ...)) {
            return process<T>(value);
        } else if constexpr (std::is_convertible_v<T, SupportedTypes...[0]>) {
            // Преобразуем к первому поддерживаемому типу
            return process<SupportedTypes...[0]>(
                static_cast<SupportedTypes...[0]>(value)
            );
        } else {
            static_assert(always_false<T>, "Unsupported type");
        }
    }
    
private:
    template <typename T>
    static constexpr bool always_false = false;
    
    template <typename T>
    auto process(T value) {
        // Специфичная для типа обработка
        return value;
    }
};

template <typename... Types>
struct TypeAnalyzer {
    // Проверка, является ли первый тип базовым для второго
    static constexpr bool first_is_base_of_second = 
        std::is_base_of_v<Types...[0], Types...[1]>;
        
    // Общий предок первого и второго типов (если есть)
    using common_type = std::common_type_t<Types...[0], Types...[1]>;
    
    // Является ли какой-либо тип из пакета указателем
    static constexpr bool has_pointer = 
        (std::is_pointer_v<Types> || ...);
        
    // Индекс первого целочисленного типа в пакете
    static constexpr int first_integral_index = []() {
        int result = -1;
        
        [&]<size_t... Is>(std::index_sequence<Is...>) {
            ((result == -1 && std::is_integral_v<Types...[Is]> 
              ? result = Is : 0), ...);
        }(std::make_index_sequence<sizeof...(Types)>{});
        
        return result;
    }();
};

template <typename R, typename... Args>
class Function {
public:
    R operator()(Args... args) const {
        // Можем селективно обрабатывать аргументы
        if constexpr (sizeof...(Args) >= 2) {
            preprocess(args...[0], args...[1]);
        }
        
        return invoke_impl(std::forward<Args>(args)...);
    }
    
private:
    void preprocess(Args...[0]& first, Args...[1]& second) const {
        // Предварительная обработка первых двух аргументов
    }
    
    R invoke_impl(Args... args) const {
        // Реальная реализация
        return R{};
    }
};

T getNth(size_t N, T...)(T args) {
    return args[N]; // Прямая индексация вариадического пакета
}
 
void main() {
    auto result = getNth!(1)(10, 20, 30);
    assert(result == 20);
}

template <typename... Ts>
struct first_type {
    using type = Ts...[0];
};

template <typename... Types>
class OptimizedTuple {
private:
    // Прямой доступ к типам через индексирование
    Types...[0] first_;
    Types...[1] second_;
    // Остальные поля хранятся в сжатой форме...
 
public:
    OptimizedTuple(Types... args)
        : first_(args...[0]), second_(args...[1]) {
        // Инициализация остальных полей
    }
 
    auto& get_first() { return first_; }
    auto& get_second() { return second_; }
};

// До C++26
template <typename T, typename... Rest>
void serialize(OutputBuffer& buffer, T&& first, Rest&&... rest) {
    serialize_single(buffer, std::forward<T>(first));
    if constexpr (sizeof...(Rest) > 0) {
        serialize(buffer, std::forward<Rest>(rest)...);
    }
}
 
// С C++26
template <typename... Args>
void serialize(OutputBuffer& buffer, Args... args) {
    if constexpr (sizeof...(args) > 0) {
        serialize_single(buffer, args...[0]);
        
        // Рекурсивный вызов с оставшимися аргументами
        [&]<size_t... Is>(std::index_sequence<Is...>) {
            serialize(buffer, args...[Is + 1]...);
        }(std::make_index_sequence<sizeof...(args) - 1>{});
    }
}

template <typename... Components>
class EntityFactory {
public:
    auto create_entity() {
        Entity entity;
        
        // Условное добавление компонентов на основе их типа
        if constexpr (sizeof...(Components) > 0) {
            if constexpr (std::is_same_v<Components...[0], PhysicsComponent>) {
                add_physics_component(entity);
            } else {
                entity.add_component<Components...[0]>();
            }
        }
        
        // Аналогично для других компонентов...
        
        return entity;
    }
 
private:
    void add_physics_component(Entity& entity) {
        // Специальная логика для физических компонентов
        entity.add_component<PhysicsComponent>(physics_world_);
    }
    
    PhysicsWorld physics_world_;
};

// До C++26
template <typename Sequence, typename Index>
struct at_impl;
 
template <typename Head, typename... Tail, typename Index>
struct at_impl<type_sequence<Head, Tail...>, std::integral_constant<size_t, 0>> {
    using type = Head;
};
 
template <typename Head, typename... Tail, size_t N>
struct at_impl<type_sequence<Head, Tail...>, std::integral_constant<size_t, N>> {
    using type = typename at_impl<type_sequence<Tail...>,
                    std::integral_constant<size_t, N-1>>::type;
};
 
// После C++26
template <typename... Types, size_t N>
auto at(type_sequence<Types...>, std::integral_constant<size_t, N>) {
    return type_wrapper<Types...[N]>{};
}

template <typename... Columns>
class TableBuilder {
public:
    template <typename... Values>
    requires (sizeof...(Values) == sizeof...(Columns))
    void insert(Values... values) {
        std::string query = "INSERT INTO " + table_name_ + " VALUES (";
        
        // Добавляем значения с правильной типизацией
        (append_value(query, values, get_column_type<Columns>()), ...);
        
        query += ")";
        execute_query(query);
    }
    
    auto select_first_column() {
        return SelectBuilder<Columns...[0]>(table_name_);
    }
 
private:
    std::string table_name_;
    
    template <typename Column>
    auto get_column_type() {
        // Возвращаем тип SQL на основе типа C++
    }
    
    template <typename T>
    void append_value(std::string& query, T value, std::string_view type) {
        // Форматируем значение в соответствии с типом
    }
};

#if __cpp_pack_indexing >= 202301
// Используем прямое индексирование пакетов
template <size_t N, typename... Ts>
using nth_type = Ts...[N];
#else
// Используем старый подход
template <size_t N, typename... Ts>
using nth_type = typename nth_type_impl<N, Ts...>::type;
#endif

template <typename... Tasks>
class ParallelExecutor {
public:
    auto execute(Tasks... tasks) {
        if constexpr (sizeof...(Tasks) <= 3) {
            // Для небольшого числа задач используем прямое выполнение
            return std::make_tuple(tasks()...);
        } else {
            // Первые 3 задачи запускаем в отдельных потоках
            auto future1 = std::async(std::launch::async, tasks...[0]);
            auto future2 = std::async(std::launch::async, tasks...[1]);
            auto future3 = std::async(std::launch::async, tasks...[2]);
            
            // Остальные выполняем последовательно в текущем потоке
            [&]<size_t... Is>(std::index_sequence<Is...>) {
                // Захватываем результаты выполнения оставшихся задач
                (execute_and_store(tasks...[Is + 3], Is + 3), ...);
            }(std::make_index_sequence<sizeof...(Tasks) - 3>{});
            
            // Собираем и возвращаем результаты
            return collect_results();
        }
    }
 
private:
    template <typename Task>
    void execute_and_store(Task task, size_t index) {
        results_[index] = task();
    }
    
    auto collect_results() {
        // Собираем результаты из futures и сохранённых значений
    }
    
    std::array<std::any, sizeof...(Tasks)> results_;
};

template <typename... Args>
void ASSERT_EQUAL(Args... args) {
    static_assert(sizeof...(args) == 2, "ASSERT_EQUAL requires exactly two arguments");
    
    // Теперь легко извлекаем и сравниваем значения
    auto actual = args...[0];
    auto expected = args...[1];
    
    // Более точная диагностика при ошибке
    if (actual != expected) {
        // Генерация детального сообщения об ошибке
    }
}