Çoklu yayınlarla çağrı işlevleri

Question

Bir kapsayıcıya üye işlevlerinin bir listesini depolayabilir ve daha sonra farklı sayıda yayın varsa daha sonra onları arayabilir miyim.

Sadece küçük bir şeyi kaçırdığımı hissediyorum ama bu ne kadar uzaktayım.

template<typename T> 
class RPCServer 
{ 
public: 
    RPCServer(const std::string host, const int port) {} 
     // Store the method pointers 
    template<typename F> 
    void register_method(const T discriminant, F func) { 
     m_callbacks.emplace_back(discriminant,func); 
    } 

    template<typename... Args> 
    void run(T subject, Args... args) { 
     auto func = std::find(std::begin(m_callbacks), std::end(m_callbacks), subject); 
     if (func != std::end(m_callbacks)) { 
      auto res = std::get<1>(*func)(args...); // This doesn't compile 
     } 

    } 

    ~RPCServer() = default; 
private: 
     // Store 
    std::vector<std::tuple<T, boost::any>> m_callbacks; 
}; 

class Impl 
{ 
public: 
    // RPC methods 
    void send_data(std::string data) {} 
    int get_details(int input) { return 0; } 
}; 

G/depolayan işlevler güvenle yazın üyesi bir dizi almak nasıl burada

using namespace std::placeholders; 
Impl impl; 
RPCServer<std::string> server("localhost",1234); 
server.register_method("foo", std::bind(&Impl::send_data, impl, _1)); 
server.register_method("bar", std::bind(&Impl::get_details, impl, _1)); 
server.run("foo", "blah"s); // This should call send_data with 'blah' as a arg 
auto result = server.run("bar", 1); // Call get_details passing in 1 

ayarlayın.

Answer 1

Bağdaştırıcı şablonu oluşturmaya ne dersiniz? bir kanıtı kavram kodu: otomatik omg2 farklı bağımsız değişken aldı = funcCaller (printSomeMore) `/ geri bir` vektör foo = {OMG, omg2 depolamak mümkün olacaktır `eklendiğinde

#include <iostream> 
#include <functional> 

template<typename T0, typename... TS> struct FunCaller { 
    template<class F> FunCaller(F &&f): f(f) {} 
    template<typename... More> T0 operator()(TS &&... as, More &&...) { 
      return f(as...); 
    } 
private: 
    std::function<T0(TS...)> f; 
}; 
template<typename T0, typename... TS> inline FunCaller<T0, TS...> funCaller(T0(&&f)(TS...)) { return FunCaller<T0, TS...>(f); } 

std::ostream &printSome(std::string const &s1, std::string const &s2) { return std::cout << s1 << ", " << s2 << std::endl; } 

int main() { 
    auto omg = funCaller(printSome); 
    omg("Hello", "world!", "This", "is", "cocaine", "speaking"); 
}