Puedo crear un servidor TCP simple que pueda responder a un cliente, pero no sé cómo crear un servidor que pueda manejar múltiples clientes a la vez. Me he referido a ejemplos como el servidor asíncrono diurno TCP, pero solo envía los datos al cliente. Lo que necesito crear es mantener viva la conexión mientras exista el cliente. Tanto el cliente como el servidor se comunicarán en Json. Considere un caso donde el cliente dará{"hello":"Client"} y el servidor debe responder{"Hello":"Server"}y decir otro{"message":"How are you?"} y su respuesta{"response" : "Fine"}. Necesito manejar múltiples clientes a la vez. Leí la documentación del servidor de chat, pero es demasiado difícil de comprender. ¿Alguien puede dar un flujo básico de cómo iniciar el código usandoBoost.Asio? Gracias.

A continuación se muestra el código dado:

#include <ctime>
#include <iostream>
#include <string>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include <json/reader.h>
#include <json/writer.h>

Json::Value GetRootFromJson(std::string json)
{
    Json::Value root;
    Json::Reader reader;
    bool success = reader.parse(json, root);
    return root;
}

std::string GetJsonFromRoot(Json::Value root)
{
    Json::FastWriter writer;
    std::string json = writer.write(root);
    return json;

}

using boost::asio::ip::tcp;

std::string make_daytime_string()
{
  using namespace std; // For time_t, time and ctime;
  time_t now = time(0);
  return ctime(&now);
}

class tcp_connection
  : public boost::enable_shared_from_this<tcp_connection>
{
public:
  typedef boost::shared_ptr<tcp_connection> pointer;

  static pointer create(boost::asio::io_service& io_service)
  {
    return pointer(new tcp_connection(io_service));
  }

  tcp::socket& socket()
  {
    return socket_;
  }

  void start()
  {
    //message_ = make_daytime_string();

    //Read from client, make json and send appropriate response
    boost::asio::async_read(socket_, boost::asio::buffer(message_),
    boost::bind(&tcp_connection::handle_read, shared_from_this(),
        boost::asio::placeholders::error,
        boost::asio::placeholders::bytes_transferred));
    std::string messageP(message_);
    std::cout << messageP << std::endl;
    Json::Value root = GetRootFromJson(messageP);
    std::string isHello = root["hello"].asString();
    std::string isMessage = root["message"].asString();
    if(!isHello.empty())
    {
        std::string messageTemp = "{\"Hello\":\"Server\"}";
        boost::asio::async_write(socket_, boost::asio::buffer(messageTemp),
        boost::bind(&tcp_connection::handle_write, shared_from_this(),
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
    }

    if(!isMessage.empty())
    {
        std::string messageTemp = "{\"response\":\"Fine\"}";
        boost::asio::async_write(socket_, boost::asio::buffer(messageTemp),
        boost::bind(&tcp_connection::handle_write, shared_from_this(),
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
    }



    /*
    boost::asio::async_write(socket_, boost::asio::buffer(message_),
        boost::bind(&tcp_connection::handle_write, shared_from_this(),
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
    */
  }

private:
  tcp_connection(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }

  void handle_write(const boost::system::error_code& /*error*/,
      size_t /*bytes_transferred*/)
  {
  }
  void handle_read(const boost::system::error_code& /*error*/,
      size_t /*bytes_transferred*/)
  {
      std::cout << "Handle Read of connection\n";
  }

  tcp::socket socket_;
  std::string message_;
};

class tcp_server
{
public:
  tcp_server(boost::asio::io_service& io_service)
    : acceptor_(io_service, tcp::endpoint(tcp::v4(), 1936))
  {
    start_accept();
  }

private:
  void start_accept()
  {
    tcp_connection::pointer new_connection ,=
      tcp_connection::create(acceptor_.get_io_service());

    acceptor_.async_accept(new_connection->socket(),
        boost::bind(&tcp_server::handle_accept, this, new_connection,
          boost::asio::placeholders::error));
  }

  void handle_accept(tcp_connection::pointer new_connection,
      const boost::system::error_code& error)
  {
    if (!error)
    {
        std::cout << "A client connected" << std::endl;
      new_connection->start();
    }

    start_accept();
  }

  tcp::acceptor acceptor_;
};

int main()
{
  try
  {
    boost::asio::io_service io_service;
    tcp_server server(io_service);
    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}

Ejecutar esto me da:

Error 2 error C2679: binario '=': no se encontró ningún operador que tome un operando a la derecha del tipo 'const boost :: asio :: const_buffer' (o no hay conversión aceptable) C: \ boost_1_55_0_dyn \ boost \ asio \ detailconsuming_buffers .hpp 175

Editar: He agregado un código de cliente muy simple, que enviará"{\"Hello\":\"Client\"}" al servidor y espera la salida. Pero el código del servidor, dado porsehe no pudo entrarhandle_read

#include <iostream>
#include <boost/array.hpp>
#include <boost/asio.hpp>

using boost::asio::ip::tcp;

int main(int argc, char* argv[])
{
  try
  {

    boost::asio::io_service io_service;

    tcp::resolver resolver(io_service);
    tcp::resolver::query query("localhost", "1936");
    tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);

    tcp::socket socket(io_service);
    boost::asio::connect(socket, endpoint_iterator);

    std::string message = "{\"hello\":\"Client\"}";
    std::cout << "Sending the message: " << message << std::endl;
    socket.send(boost::asio::buffer(message));
    std::cout << "Sent the message: " << message << std::endl;
    boost::asio::streambuf buf;
    size_t len;
    std::string messageReceived;
    boost::asio::streambuf::mutable_buffers_type mbuf = buf.prepare(512);
    std::cout << "Now receiving message\n";
    std::string messageServer;
    try
    {
        boost::asio::streambuf buf;
        size_t len;
        boost::asio::streambuf::mutable_buffers_type mbuf = buf.prepare(512);
        do {
            len = socket.receive(mbuf);
            std::cout << len << std::endl;
            std::string str(boost::asio::buffers_begin(mbuf), boost::asio::buffers_begin(mbuf) + len);
            messageServer = messageServer + str;
        } while (len>=512); 
    }
    catch (boost::system::system_error err)
    {
        std::cout << err.code() << " " << err.what();
    }

    std::cout << messageServer << std::endl;
  }
  catch (std::exception& e)
  {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}

¿Es esta la forma correcta de implementar el servidor? Gracias.