Partially specialize methods of variadic template classes

I want to write an unmarshaller to extract arguments stored in a msgpack array for individual arguments to a call of sigc::signal::emit(...). I tried this:

template<class... T> class MsgpackAdapter: public MsgpackAdapterBase {
public:
    MsgpackAdapter (sigc::signal<void, T...> &sig)
            : MsgpackAdapterBase (), signal_ (sig)
    {}
protected:
    virtual void do_emit (const msgpack::object_array &mp_args) override;
private:
    sigc::signal<void, T...> signal_;
};

template<class T1>
void MsgpackAdapter<T1>::do_emit (const msgpack::object_array &mp_args)
{
    T1 a1;
    mp_args.ptr[0].convert (a1);
    signal_.emit (a1);
}

template<class T1, class T2>
void MsgpackAdapter<T1, T2>::do_emit (const msgpack::object_array &mp_args)
{
    T1 a1;
    T2 a2;
    mp_args.ptr[0].convert (a1);
    mp_args.ptr[1].convert (a2);
    signal_.emit (a1, a2);
}

and so on for up to 4 arguments. But I get this error message (from vim-youcompleteme using clang 3.9):

'MsgpackAdapter<T1>::' for declaration does not refer into a class, class template or class template partial specialization

It seems I can make partial specializations of the entire class:

template<class T1> class MsgpackAdapter<T1>: public MsgpackAdapterBase { ... };

but I'd rather be able to specialize just the emit method to reduce the amount of copy & paste code. Have I missed something obvious? I think the main difficulty is that do_emit doesn't take templatized arguments.

Another curiosity is that if I try to do it without the variadic template, and use:

template<class T1> class MsgpackAdapter: public MsgpackAdapterBase { ... };
template<class T1, class T2> class MsgpackAdapter: public MsgpackAdapterBase { ... };

I get an error that the second class definition clashes with the first. That's understandable, but I wonder how sigc managed a similar thing without variadic templates.

I have always felt that the most maintainable way to specialise a member function is to defer to a specialised function object:

#include <iostream>

struct object_array
{
};


template<class...Ts>
struct implement_do_emit
{
    template<class This>
    void operator ()(This *that, const object_array& arg) const;
};


template<class... Ts>
struct MsgpackAdapter
{
    friend class implement_do_emit<Ts...>;

    virtual void do_emit(const object_array& mp_args)
    {
        auto impl = implement_do_emit<Ts...>();
        impl(this, mp_args);
    }

};

template<class T>
struct implement_do_emit<T>
{
    template<class This>
    void operator ()(This *that, const object_array& arg) const
    {
        std::cout << "one type version\n";
    }
};

template<class T1, class T2>
struct implement_do_emit<T1, T2>
{
    template<class This>
    void operator ()(This *that, const object_array& arg) const
    {
        std::cout << "two type version\n";
    }
};


int main()
{
    MsgpackAdapter<int> pi {};
    pi.do_emit(object_array());

    MsgpackAdapter<int, int> pii {};
    pii.do_emit(object_array());
}

In C++14:

template<class F>
auto foreach( F&& f ) {
  return [f=std::forward<F>(f)](auto&&...args)mutable{
    using discard=int[];
    (void)discard{0,(void(
      f(decltype(args)(args))
    ),0)...};
  };
}
template<std::size_t...Is>
auto index_over( std::index_sequence<Is...> ) {
  return [](auto&& f)->decltype(auto){
    return decltype(f)(f)( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto index_upto( std::integral_constant<std::size_t, N> ={} ) {
  return index_over( std::make_index_sequence<N>{} );
}


template<class...Ts>
void MsgpackAdapter<Ts...>::do_emit (const msgpack::object_array &mp_args)
{
  std::tuple<Ts...> args;
  index_upto<sizeof...(Ts)>()(
    foreach(
      [&](auto I){
        mp_args.ptr[I].convert(std::get<I>(args));
      }
    )
  );
  index_upto<sizeof...(Ts)>()(
    [&](auto...Is){
      signal_.emit(std::get<Is>(args)...);
    }
  );
}

or somesuch. Live example.

Basically, make a tuple.

Create a pack of indexes into that tuple.

For each index into the tuple, call convert.

Then, call emit getting each element of the tuple.

There are many examples of code on stack overflow that involve passing each argument of a tuple to a function call. That is the emit part.

There are many examples on stack overflow of doing something for each element of a tuple. Doing so with an index is a bit trickier, but at worst you can count if the for each element does things in order.

These can be done in C++11, but in C++14 I can do it all in the function without helper functions.

Description of the above magic code. index_upto returns a lambda. This lambda takes another lambda, then calls it with compile time constants from 0 up to N-1. It does this by calling index_over, which takes a list of indexes.

foreach takes a lambda f. It then returns a lambda that takes any number of arguments, and calls the f once with each one of those arguments. Its implementation is a bit deep mojo involving parameter packs and array initialization.

Composing index_upto and foreach lets you do something for each compile-time value from 0 to N-1. This is how we call .convert.

Just calling index_upto lets us pass all of the arguments at once to emit.

We can do something similar in C++11, but we'd instead write helper functions that take parameter packs and such. It is more than a bit of a pain.

来源：https://stackoverflow.com/questions/42934044/partially-specialize-methods-of-variadic-template-classes

标签

c++