Вопрос по языку C++ и типам std::function и std::variant.

У меня есть свой шаблонный тип функтора:

template<typename InputIteratorType, typename OutputIteratorType>
using BasicFormatValueFilter = std::function< OutputIteratorType( InputIteratorType  // begin
                                                                , InputIteratorType  // end
                                                                , OutputIteratorType
                                                                )
                                            >;

Танный тип функтора может быть специализирован любыми типами
InputIteratorType и OutputIteratorType.

Требуется определить, содержится ли какая-либо специализация
шаблона BasicFormatValueFilter в типе, определённом с использованием
std::variant.

Также необходимо определить типы, которыми был специализирован шаблон
BasicFormatValueFilter.

Шаг 1: Проверка, является ли тип специализацией BasicFormatValueFilter

#include <type_traits>
#include <functional>
#include <variant>

// Шаблон для проверки, является ли тип специализацией BasicFormatValueFilter
template<typename>
struct is_basic_format_value_filter : std::false_type {};

template<typename InputIt, typename OutputIt>
struct is_basic_format_value_filter<
    std::function<OutputIt(InputIt, InputIt, OutputIt)>
> : std::true_type {};

// Удобная обёртка для проверки
template<typename T>
inline constexpr bool is_basic_format_value_filter_v = 
    is_basic_format_value_filter<T>::value;

Шаг 2: Определение параметров InputIteratorType и OutputIteratorType

template<typename>
struct basic_format_value_filter_traits;

template<typename InputIt, typename OutputIt>
struct basic_format_value_filter_traits<
    std::function<OutputIt(InputIt, InputIt, OutputIt)>
> {
    using input_iterator_type = InputIt;
    using output_iterator_type = OutputIt;
};

Шаг 3: Проверка всех типов в std::variant

Вариант 1: Проверка, содержит ли variant хотя бы один такой тип

template<typename Variant>
struct variant_contains_basic_format_value_filter;

template<typename... Ts>
struct variant_contains_basic_format_value_filter<std::variant<Ts...>> 
    : std::disjunction<is_basic_format_value_filter<Ts>...> {};

template<typename Variant>
inline constexpr bool variant_contains_basic_format_value_filter_v =
    variant_contains_basic_format_value_filter<Variant>::value;

Вариант 2: Получение списка всех BasicFormatValueFilter в variant

template<typename... Ts>
struct get_basic_format_value_filters {
    using type = decltype(std::tuple_cat(
        std::conditional_t<
            is_basic_format_value_filter_v<Ts>,
            std::tuple<Ts>,
            std::tuple<>
        >{}...
    ));
};

template<typename... Ts>
using get_basic_format_value_filters_t = 
    typename get_basic_format_value_filters<Ts...>::type;

Пример использования

#include <iostream>

int main() {
    using MyVariant = std::variant<
        int,
        std::function<int*(const int*, const int*, int*)>,
        double,
        std::function<char*(const char*, const char*, char*)>
    >;

    // Проверка, содержит ли variant хотя бы один BasicFormatValueFilter
    constexpr bool contains = variant_contains_basic_format_value_filter_v<MyVariant>;
    std::cout << "Contains BasicFormatValueFilter: " << contains << "\n";

    // Получение списка всех BasicFormatValueFilter в variant
    using Filters = get_basic_format_value_filters_t<
        int,
        std::function<int*(const int*, const int*, int*)>,
        double,
        std::function<char*(const char*, const char*, char*)>
    >;

    static_assert(std::tuple_size_v<Filters> == 2, "Should have 2 filters");

    // Извлечение параметров первого фильтра
    using FirstFilter = std::tuple_element_t<0, Filters>;
    using Traits = basic_format_value_filter_traits<FirstFilter>;
    using InputIt = Traits::input_iterator_type;
    using OutputIt = Traits::output_iterator_type;

    static_assert(std::is_same_v<InputIt, const int*>, "InputIt should be const int*");
    static_assert(std::is_same_v<OutputIt, int*>, "OutputIt should be int*");

    return 0;
}

Вывод

Обнаружение и Анализ Специализаций BasicFormatValueFilter в std::variant

Проверка наличия специализации BasicFormatValueFilter в std::variant

Базовая реализация trait-класса для определения типа

// Проверка, является ли тип специализацией BasicFormatValueFilter
template<typename T>
struct is_basic_format_value_filter : std::false_type {};

// Специализация для BasicFormatValueFilter
template<typename InputIteratorType, typename OutputIteratorType>
struct is_basic_format_value_filter<
    std::function<OutputIteratorType(
        InputIteratorType, InputIteratorType, OutputIteratorType)>> 
    : std::true_type {};

// Вспомогательная переменная для упрощения использования
template<typename T>
inline constexpr bool is_basic_format_value_filter_v = 
    is_basic_format_value_filter<T>::value;

Проверка содержимого std::variant

// Метафункция для проверки std::variant
template<typename Variant>
struct variant_contains_basic_format_value_filter;

// Специализация для std::variant
template<typename... Ts>
struct variant_contains_basic_format_value_filter<std::variant<Ts...>> {
    static constexpr bool value = (is_basic_format_value_filter_v<Ts> || ...);
};

// Вспомогательная переменная
template<typename Variant>
inline constexpr bool variant_contains_basic_format_value_filter_v = 
    variant_contains_basic_format_value_filter<Variant>::value;

Извлечение типов из специализации BasicFormatValueFilter

// Trait для извлечения типов из BasicFormatValueFilter
template<typename T>
struct basic_format_value_filter_traits {
    static constexpr bool is_basic_format_value_filter = false;
    // Пустые типы по умолчанию
};

// Специализация для извлечения типов
template<typename InputIteratorType, typename OutputIteratorType>
struct basic_format_value_filter_traits<
    std::function<OutputIteratorType(
        InputIteratorType, InputIteratorType, OutputIteratorType)>> {
    static constexpr bool is_basic_format_value_filter = true;
    using input_iterator_type = InputIteratorType;
    using output_iterator_type = OutputIteratorType;
};

Поиск специализаций внутри std::variant

// Рекурсивный поиск первой специализации в пакете типов
template<typename... Ts>
struct find_first_basic_format_value_filter;

// Базовый случай: пустой пакет
template<>
struct find_first_basic_format_value_filter<> {
    static constexpr bool found = false;
    using type = void;
};

// Рекурсивный случай
template<typename T, typename... Rest>
struct find_first_basic_format_value_filter<T, Rest...> {
private:
    using next = find_first_basic_format_value_filter<Rest...>;
public:
    static constexpr bool found = is_basic_format_value_filter_v<T> ? 
                                  true : next::found;
    using type = std::conditional_t<is_basic_format_value_filter_v<T>, 
                                  T, typename next::type>;
};

// Извлечение типов из std::variant
template<typename Variant>
struct extract_first_basic_format_value_filter;

template<typename... Ts>
struct extract_first_basic_format_value_filter<std::variant<Ts...>> {
    using find_result = find_first_basic_format_value_filter<Ts...>;
    static constexpr bool found = find_result::found;
    using type = typename find_result::type;
    
    template<typename U>
    using extract_traits = basic_format_value_filter_traits<U>;
    
    using traits = std::conditional_t<found, 
                                    extract_traits<type>, 
                                    basic_format_value_filter_traits<void>>;
    
    using input_iterator_type = typename traits::input_iterator_type;
    using output_iterator_type = typename traits::output_iterator_type;
};

Пример использования

#include <iostream>
#include <type_traits>
#include <functional>
#include <variant>
#include <string>
#include <vector>

// Определение BasicFormatValueFilter
template<typename InputIteratorType, typename OutputIteratorType>
using BasicFormatValueFilter = std::function<OutputIteratorType(
    InputIteratorType, InputIteratorType, OutputIteratorType)>;

// Здесь идут наши метафункции, определённые выше

int main() {
    // Пример std::variant с специализацией BasicFormatValueFilter
    using VariantType = std::variant<
        int, 
        double, 
        BasicFormatValueFilter<std::string::iterator, std::vector<char>::iterator>,
        std::string
    >;
    
    // Проверка наличия специализации
    constexpr bool has_filter = variant_contains_basic_format_value_filter_v<VariantType>;
    std::cout << "Variant contains BasicFormatValueFilter: " 
              << (has_filter ? "true" : "false") << std::endl;
    
    // Извлечение типов
    using ExtractResult = extract_first_basic_format_value_filter<VariantType>;
    std::cout << "Found filter: " << (ExtractResult::found ? "true" : "false") << std::endl;
    
    // Использование извлечённых типов
    if constexpr (ExtractResult::found) {
        // Для примера, просто выведем информацию о том, что мы нашли
        std::cout << "Input iterator is std::string::iterator: " 
                  << std::is_same_v<ExtractResult::input_iterator_type, std::string::iterator> 
                  << std::endl;
        std::cout << "Output iterator is std::vector<char>::iterator: " 
                  << std::is_same_v<ExtractResult::output_iterator_type, std::vector<char>::iterator> 
                  << std::endl;
    }
    
    return 0;
}

Заключение