TcpSocket.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
 
#pragma once
 
#include <asio/System.h>
#include <asio/Context.h>
#include <asio/Socket.h>
 
#include <FMEThirdPartyWarningsDisable.h>
#include <boost/asio/ip/tcp.hpp>
#include <memory>
#include <FMEThirdPartyWarningsRestore.h>
 
 
namespace asio {
 
  // Note: inline this class completely or export base class and do NOT export a class whose base classes is not.
  // Whether it is a realy problem here is still unclear, but this should be handled. At least in cases of same problem with
  // derivations of std::runtime_error this would cause subtle problems.
  class ASYNCHRONOUSIO_EXPORT TcpSocket : public Socket
  {
  public:
 
    TcpSocket(std::shared_ptr<Context> context);
 
    ~TcpSocket() override;
 
    template<typename ConnectCompletionHandler>
    void async_connect(const std::string& host, const unsigned short port, ConnectCompletionHandler&& handler)
    {
      using DnsQuery = boost::asio::ip::tcp::resolver::query;
      using TcpResolver = boost::asio::ip::tcp::resolver;
      using EndpointIterator = TcpResolver::iterator;
 
      auto query = DnsQuery(host == "localhost" ? "127.0.0.1" : host, std::to_string(port));
#if defined(MLAB_CMAKE_BUILDSYSTEM)
// See https://stackoverflow.com/questions/67281460/boostasio-get-io-service-alternative-in-boost-1-70/67773642#67773642
// for resolution of deprecation of get_io_service().
#if BOOST_VERSION >= 107000
#define GET_IO_SERVICE(s) ((boost::asio::io_context&)(s).get_executor().context())
#else
#define GET_IO_SERVICE(s) ((s).get_io_service())
#endif      
      
      auto resolver = std::make_shared<TcpResolver>(GET_IO_SERVICE(socket));
#else      
      auto resolver = std::make_shared<TcpResolver>(socket.get_io_service());
#endif
      
 
      resolver->async_resolve(query,
        [this, handler, resolver](const ErrorCode& ec_resolve, const EndpointIterator& iterator) {
          if (!ec_resolve) {
            socket.async_connect(iterator->endpoint(), handler);
          }
          else {
            handler(ec_resolve);
          }
      });
    }
 
    bool is_open() const;
 
    bool is_valid() const override;
 
    void async_read(void* buffer, const std::size_t buffer_size, const CompletionHandler& handler) override;
 
    void async_write(const void* buffer, const std::size_t buffer_size, const CompletionHandler& handler) override;
 
    void close() override;
 
    TcpSocket(const TcpSocket&) = delete;
 
    TcpSocket& operator=(const TcpSocket&) = delete;
 
  protected:
 
    friend class TcpAcceptor;
 
    std::shared_ptr<Context> context;
 
    boost::asio::ip::tcp::socket socket;
  };
 
}