Блог

Я вообще не вижу, как это можно было бы реализовать.

У меня есть неполный шаблон класса, используемый для «переопределения» некоторых методов.
Это один из рабочих примеров:

 template<typename...>
struct make_completion;

struct ServiceTraits
{
    using mode_type = ModeType;
    using warning_type = Waring;
    using error_type = Error;
    using iteration_result_type = IterationResu<

    using steering_type = Steering;

    using sync_tag_t = decltype(asio::use_future);
};

template<typename SignatureT>
struct make_completion<ServiceTraits, SignatureT>
{
    template<typename CompletionToken>
    auto operator()(ServiceTraits, CompletionToken amp;amp;completionToken)
    {
        using result_type = asio::async_result<std::decay_t<CompletionToken>, SignatureT>;
        using completion_handler = typename result_type::completion_handler_type;

        completion_handler handler{ std::forward<CompletionToken>(completionToken) };
        result_type result{ handler };

        return Completion<result_type, completion_handler>{ std::move(result), std::move(handler) };
    }
};

 

Я хочу собрать traits класс с помощью наследования, поэтому, например, у меня было бы несколько классов признаков, а затем произвольно объединить их.

Например:

 template<typename ResultT, typename HandlerT>
struct completion
{
   using result_type = ResultT;
   using handler_type = HandlerT;
   result_type resu<
   handler_type handler;
};

// this would be inherited from
struct asio_traits
{
   using sync_tag_t = decltype(asio::use_future);
};
 

Проблема в том, что я не могу использовать что-то подобное std::enable_if в специализации.
Это не будет компилироваться:

 template<typename DerivedTraits,
         typename SignatureT,
         typename = std::enable_if_t<std::is_base_of_v<asio_traits, DerivedTraits>>>
struct eos::method::make_completion<DerivedTraits, SignatureT>
{
   // impl here...
};
 

Можно ли как-то использовать условие для специализации шаблона класса?

Что-то в этом роде, возможно:

 template <typename...>
struct make_completion_tag;

template <typename Tag, typename...>
struct make_completion_impl;

template <typename... Ts>
struct make_completion : public make_completion_impl<
    typename make_completion_tag<Ts...>::type,
    Ts...>
{};

struct asio_traits_based_tag;
template <typename DerivedTraits, typename SignatureT>
struct make_completion_impl<asio_traits_based_tag, DerivedTraits, SignatureT> {
  // Your specialization here
};
 

Теперь осталось только вернуть make_completion_tag::type правильный тег. Например.

 template <typename DerivedTraits, typename SignatureT>
struct make_completion_tag<DerivedTraits, SignatureT> {
  using type = std::conditional_t<
      std::is_base_of_v<asio_traits, DerivedTraits>,
      asio_traits_based_tag, void>;
};
 

ИЗМЕНИТЬ: немного другой подход, который предоставляет внешнюю точку настройки:

 template <typename Tag, typename...>
struct make_completion_impl;

void make_completion_selector(...);

template <typename... Ts>
struct make_completion : public make_completion_impl<
    decltype(make_completion_selector(static_cast<Ts*>(nullptr)...)),
    Ts...>
{};
 

Теперь у пользователя есть два варианта. Если типы позволяют, они могут специализироваться make_completion напрямую:

 template <AnotherType>
struct make_completion<SpecificType, AnotherType> {
  // Your specialization here
};
 

В более сложном случае они могут объявить соответствующим образом ограниченную перегрузку make_completion_selector возврата типа тега и специализироваться make_completion_impl на этом теге:

 struct asio_traits_based_tag;
template <typename DerivedTraits, typename SignatureT>
struct make_completion_impl<asio_traits_based_tag, DerivedTraits, SignatureT> {
  // Your specialization here
};

template <typename DerivedTraits, typename SignatureT>
std::enable_if_t<std::is_base_of_v<asio_traits, DerivedTraits>,
                 asio_traits_based_tag>
make_completion_selector(DerivedTraits*, SignatureT*);