tcp_client.hpp

Go to the documentation of this file.

#pragma once
#include "network_stream.hpp"
#include "socket.hpp"
#include "../ip_end_point.hpp"
#include "../../iequatable.hpp"
#include "../../object.hpp"
#include "../../string.hpp"

namespace xtd {
  namespace net {
    namespace sockets {
      class tcp_listener;
      
      class core_export_ tcp_client : public xtd::object, public xtd::iequatable<tcp_client> {
        struct data;
        
      public:
        
        tcp_client();
        explicit tcp_client(const xtd::net::ip_end_point& end_point);
        explicit tcp_client(xtd::net::sockets::address_family address_family);
        tcp_client(const xtd::string& hostname, uint16 port);
        
        tcp_client(tcp_client&&) = default;
        tcp_client(const tcp_client&) = default;
        ~tcp_client();
        auto operator =(tcp_client&&) -> tcp_client& = default;
        auto operator =(const tcp_client&) -> tcp_client& = default;
        
        
        [[nodiscard]] auto available() const -> xtd::size;
        
        [[nodiscard]] auto client() const noexcept -> xtd::net::sockets::socket;
        auto client(const xtd::net::sockets::socket& value) noexcept -> tcp_client&;
        
        [[nodiscard]] auto connected() const noexcept -> bool;
        
        [[nodiscard]] auto exclusive_address_use() const -> bool;
        auto exclusive_address_use(bool value) -> tcp_client&;
        
        [[nodiscard]] auto linger_state() const -> xtd::net::sockets::linger_option;
        auto linger_state(const xtd::net::sockets::linger_option& value) -> tcp_client&;
        
        [[nodiscard]] auto no_delay() const -> bool;
        auto no_delay(bool value) -> tcp_client&;
        
        [[nodiscard]] auto receive_buffer_size() const -> xtd::size;
        auto receive_buffer_size(xtd::size value) -> tcp_client&;
        
        [[nodiscard]] auto receive_timeout() const -> xtd::int32;
        auto receive_timeout(xtd::int32 value) -> tcp_client&;
        
        [[nodiscard]] auto send_buffer_size() const -> xtd::size;
        auto send_buffer_size(xtd::size value) -> tcp_client&;
        
        [[nodiscard]] auto send_timeout() const -> xtd::int32;
        auto send_timeout(xtd::int32 value) -> tcp_client&;
        
        
        auto begin_connect(const xtd::net::ip_address& address, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_connect(const xtd::array<xtd::net::ip_address>& addresses, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_connect(const xtd::string& host, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto close() -> void;
        
        auto connect(const xtd::net::ip_end_point& remote_end_point) -> void;
        auto connect(const xtd::net::ip_address& ip_address, uint16 port) -> void;
        auto connect(const xtd::string& hostname, uint16 port) -> void;
        
        auto end_connect(xtd::sptr<xtd::iasync_result> async_result) -> void;
        
        auto equals(const object& obj) const noexcept -> bool override;
        auto equals(const tcp_client& other) const noexcept -> bool override;
        
        [[nodiscard]] auto get_stream() const -> xtd::net::sockets::network_stream;
        
      protected:
        
        [[nodiscard]] auto active() const noexcept -> bool;
        auto active(bool value) noexcept -> tcp_client&;
        
      private:
        friend tcp_listener;
        explicit tcp_client(const xtd::net::sockets::socket& socket);
        
        xtd::sptr<data> data_;
      };
    }
  }
}