variadic template with macros

Solution for variadic template with macros
is Given Below:

I want to achieve something like this(To create a generic message invoke and receive mechanism, so that all the clients can use it.) Is it possible? I need a macro so that any type of method can be called. Please suggest if there is a better way to achieve it.

#define ASYNC_INVOKE_3ARG(PROXY, REAL_PROXYNAME, ARG_LIST, CALLBACK, METHOD,   
                          ...)                                                 
  PROXY.setResetListener ARG_LIST(true, ++PROXY.mSeqNr, std::move(CALLBACK));  
  PROXY->METHOD(__VA_ARGS__ std::bind(                                         
      &ClientAbstraction<REAL_PROXYNAME>::responseFunc ARG_LIST, &PROXY,       
      PROXY.mSeqNr, std::placeholders::_1, std::placeholders::_2,              
      std::placeholders::_3));

class Worker {
public:
  void DoSomething(const std::function<void(int, char, bool)> &aCallback) {
    std::thread([aCallback]() {
      std::this_thread::sleep_for(std::chrono::seconds(4));
      aCallback(10, 'A', true);
    }).detach();
  }
};
template <class proxyclass_> class ClientAbstraction {
public:
  ClientAbstraction() : mProxy(std::make_shared<proxyclass_>()) {}
  std::shared_ptr<proxyclass_> operator->() { return mProxy; }
  template <typename... _attribs>
  void responseFunc(std::uint64_t aSequenceNumber,
                    const _attribs &...Attributes) {
    typedef std::function<void(const _attribs &...)> Listener;
    Listener func =
        setResetListener(false, aSequenceNumber, (Listener) nullptr);
    if (func) {
      func(Attributes...);
    } else {
      std::cout << "could not find matching callback function "
                << __PRETTY_FUNCTION__ << "n";
    }
  }
  template <typename... _attribs>
  std::function<void(const _attribs &...)>
  setResetListener(bool isSet, std::uint64_t aSeqNum,
                   std::function<void(const _attribs &...)> &&func) {
    typedef std::function<void(const _attribs &...)> Listener;
    static std::unordered_map<std::uint64_t, Listener> ListenerMap;
    if (isSet) {
      ListenerMap.insert(std::make_pair(aSeqNum, std::move(func)));
      return std::move(func);
    } else {
      auto it = ListenerMap.find(aSeqNum);
      Listener returnfunc = nullptr;
      if (it != ListenerMap.end()) {
        returnfunc = nullptr;
      }
      return returnfunc;
    }
  }
  std::uint64_t mSeqNr;
private:
  std::shared_ptr<proxyclass_> mProxy;
};

class Caller {
public:
  Caller() {
    const auto callback = [this](int, char, bool) {
      std::cout << "callback receivedn";
    };
    ASYNC_INVOKE_3ARG(mWorker, Worker, <int COMMA char COMMA bool>, callback,
                      DoSomething);
  }
private:
  ClientAbstraction<Worker> mWorker;
};

I am mostly facing issues while using the macros to pass the templated parameter as well as callback function from the clients.