boost::asio и boost::bind error

Question

Эти вопросы немного раздражают, я не могу получить следующий код для компиляции. Вам нужно будет скомпилировать код ниже.

У меня возникли некоторые проблемы с boost asio, я пытаюсь абстрагировать логику принятия соединений в единую абстракцию, чтобы я мог инициировать соединение для окон именованных каналов и доменных сокетов Unix равномерно с обычным TCP/IP.

В приведенном ниже коде показаны 3 класса, первые 2 являются реализациями принятия TCP-соединений, а третий класс ниже представляет собой универсальный класс, который реализован в терминах первого 2. У меня возникли проблемы с boost::bind звонки. Проблема, вероятно, заключается в моем понимании семантики.

Если я сделаю TcpDestinationAcceptor::handle_accept обычная функция-член (--ie, а не функция-член шаблона), в результате чего я не передаю AcceptHandler параметр. Код компилируется нормально. Примечание: я не удаляю статус функции шаблона из TcpDestinationAcceptor::StartAccepting,

Примечание: я уже начал работать над другим дизайном, но все же я хотел бы продолжить этот дизайн, если это возможно.

Автономный код:

#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/bind.hpp>
#include <boost/asio/placeholders.hpp>

class TcpDestinationConnection
{
public:
  typedef boost::asio::ip::tcp::socket t_io_object;
  TcpDestinationConnection(boost::asio::io_service & io_s)
    : m_io_object(io_s) {} ;
  t_io_object & io_object() { return m_io_object; }
private:
  t_io_object m_io_object;
};

class TcpDestinationAcceptor
{
public:
  typedef boost::asio::ip::tcp::acceptor t_acceptor;
  typedef boost::shared_ptr<TcpDestinationConnection> t_connection_ptr;


  TcpDestinationAcceptor( boost::asio::io_service & io_s)
    : m_io_service(io_s),
      m_acceptor(io_s) 
  {
    m_acceptor.open(boost::asio::ip::tcp::v4());
  }

  TcpDestinationAcceptor( boost::asio::io_service & io_s , 
                          const boost::asio::ip::tcp::endpoint & endpoint)
    : m_io_service(io_s),
      m_acceptor(io_s, endpoint) 
    {
      m_acceptor.open(boost::asio::ip::tcp::v4());
    }

  t_acceptor & acceptor() { return m_acceptor; } 

  template<typename AcceptHandler>
  void StartAccepting(AcceptHandler h)
  {   
    t_connection_ptr new_session(new TcpDestinationConnection(m_io_service));

    m_acceptor.async_accept(  new_session->io_object(),
                              boost::bind(  &TcpDestinationAcceptor::handle_accept<AcceptHandler>, this,
                                              boost::asio::placeholders::error, new_session, h));
  }

  template<typename AcceptHandler>
  void handle_accept(const boost::system::error_code & err, t_connection_ptr cur, AcceptHandler h)  {
  }
private:
  boost::asio::io_service & m_io_service;
  boost::asio::ip::tcp::acceptor m_acceptor;
};

template<typename t_acceptor>
class ConnectionOracle
{
public:
  ConnectionOracle()
    : m_io_service(),
      m_acceptor(m_io_service) {}

  typename t_acceptor::t_acceptor & native_acceptor() { return m_acceptor.acceptor(); }
  boost::asio::io_service & io_service() { return m_io_service; }

  void StartConnection( typename t_acceptor::t_connection_ptr connection,
                        boost::system::error_code & error)
  {

  }
  void Begin()
  {
    m_acceptor.StartAccepting(  boost::bind(  &ConnectionOracle::StartConnection,this,
                                              _1,
                                              boost::asio::placeholders::error));
    m_io_service.run();
  } 
private:
  boost::asio::io_service m_io_service;
  t_acceptor m_acceptor;
};

int main()
{
  ConnectionOracle<TcpDestinationAcceptor> ConOracle;
  ConOracle.native_acceptor().
    bind(boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(),50000));
  ConOracle.Begin();

  return 0;
}