tcphost.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2014-2015, 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_TCPHOST_HPP
#define CPPWAMP_TCPHOST_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <string>
#include "api.hpp"
#include "config.hpp"
#include "rawsockoptions.hpp"
#include "internal/socketoptions.hpp"
 
// Forward declaration
namespace boost { namespace asio { namespace ip { class tcp; }}}
 
namespace wamp
{
 
namespace internal { class TcpOpener; } // Forward declaration
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API TcpOptions
{
public:
    TcpOptions& withBroadcast(bool enabled = true);
 
    TcpOptions& withDebug(bool enabled = true);
 
    TcpOptions& withDoNotRoute(bool enabled = true);
 
    TcpOptions& withKeepAlive(bool enabled = true);
 
    TcpOptions& withLinger(bool enabled, int timeout);
 
    TcpOptions& withOutOfBandInline(bool enabled);
 
    TcpOptions& withReceiveBufferSize(int size);
 
    TcpOptions& withReceiveLowWatermark(int size);
 
    TcpOptions& withReuseAddress(bool enabled = true);
 
    TcpOptions& withSendBufferSize(int size);
 
    TcpOptions& withSendLowWatermark(int size);
 
    TcpOptions& withUnicastHops(int hops);
 
    TcpOptions& withIpV6Only(bool enabled = true);
 
    TcpOptions& withNoDelay(bool enabled = true);
 
private:
    template <typename TOption, typename... TArgs>
    TcpOptions& set(TArgs... args);
 
    template <typename TSocket> void applyTo(TSocket& socket) const;
 
    internal::SocketOptionList<boost::asio::ip::tcp> options_;
 
    friend class internal::TcpOpener;
 
    /* Implementation note: Explicit template instantiation does not seem
       to play nice with CRTP, so it was not feasible to factor out the
       commonality with UdsOptions as a mixin (not without giving up the
       fluent API). */
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API TcpHost
{
public:
    static constexpr RawsockMaxLength defaultMaxRxLength =
        RawsockMaxLength::MB_16;
 
    TcpHost(
        std::string hostName,     
        std::string serviceName,  
        TcpOptions options = {},  
        RawsockMaxLength maxRxLength
            = defaultMaxRxLength  
    );
 
    TcpHost(
        std::string hostName,     
        unsigned short port,      
        TcpOptions options = {},  
        RawsockMaxLength maxRxLength
            = defaultMaxRxLength  
    );
 
    TcpHost& withOptions(TcpOptions options);
 
    TcpHost& withMaxRxLength(RawsockMaxLength length);
 
    const std::string& hostName() const;
 
    const std::string& serviceName() const;
 
    const TcpOptions& options() const;
 
    RawsockMaxLength maxRxLength() const;
 
 
    CPPWAMP_DEPRECATED TcpHost& withBroadcast(bool enabled = true)
    {
        options_.withBroadcast(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withDebug(bool enabled = true)
    {
        options_.withDebug(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withDoNotRoute(bool enabled = true)
    {
        options_.withDoNotRoute(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withKeepAlive(bool enabled = true)
    {
        options_.withKeepAlive(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withLinger(bool enabled, int timeout)
    {
        options_.withLinger(enabled, timeout);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withOutOfBandInline(bool enabled)
    {
        options_.withOutOfBandInline(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withReceiveBufferSize(int size)
    {
        options_.withReceiveBufferSize(size);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withReceiveLowWatermark(int size)
    {
        options_.withReceiveLowWatermark(size);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withReuseAddress(bool enabled = true)
    {
        options_.withReuseAddress(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withSendBufferSize(int size)
    {
        options_.withSendBufferSize(size);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withSendLowWatermark(int size)
    {
        options_.withSendLowWatermark(size);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withUnicastHops(int hops)
    {
        options_.withUnicastHops(hops);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withIpV6Only(bool enabled = true)
    {
        options_.withIpV6Only(enabled);
        return *this;
    }
 
    CPPWAMP_DEPRECATED TcpHost& withNoDelay(bool enabled = true)
    {
        options_.withNoDelay(enabled);
        return *this;
    }
 
private:
    std::string hostName_;
    std::string serviceName_;
    TcpOptions options_;
    RawsockMaxLength maxRxLength_;
};
 
} // namespace wamp
 
#ifndef CPPWAMP_COMPILED_LIB
#include "./internal/tcphost.ipp"
#endif
 
#endif // CPPWAMP_TCPHOST_HPP