tcp_client.h

Go to the documentation of this file.

 
#pragma once
#include "network_stream.h"
#include "socket.h"
#include "../ip_end_point.h"
#include "../../iequatable.h"
#include "../../object.h"
#include "../../string.h"
 
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();
        tcp_client& operator =(const tcp_client&) = default;
        
        
        size_t available() const;
        
        xtd::net::sockets::socket client() const noexcept;
        tcp_client& client(const xtd::net::sockets::socket& value) noexcept;
        
        bool connected() const noexcept;
        
        bool exclusive_address_use() const;
        tcp_client& exclusive_address_use(bool value);
        
        xtd::net::sockets::linger_option linger_state() const;
        tcp_client& linger_state(const xtd::net::sockets::linger_option& value);
        
        bool no_delay() const;
        tcp_client& no_delay(bool value);
        
        size_t receive_buffer_size() const;
        tcp_client& receive_buffer_size(size_t value);
        
        int32 receive_timeout() const;
        tcp_client& receive_timeout(int32 value);
        
        size_t send_buffer_size() const;
        tcp_client& send_buffer_size(size_t value);
        
        int32 send_timeout() const;
        tcp_client& send_timeout(int32 value);
        
        
        xtd::sptr<xtd::iasync_result> begin_connect(const xtd::net::ip_address& address, uint16 port, xtd::async_callback callback, const std::any& state);
        xtd::sptr<xtd::iasync_result> begin_connect(const std::vector<xtd::net::ip_address>& addresses, uint16 port, xtd::async_callback callback, const std::any& state);
        xtd::sptr<xtd::iasync_result> begin_connect(const xtd::string& host, uint16 port, xtd::async_callback callback, const std::any& state);
        
        void close();
        
        void connect(const xtd::net::ip_end_point& remote_end_point);
        void connect(const xtd::net::ip_address& ip_address, uint16 port);
        void connect(const xtd::string& hostname, uint16 port);
        
        void end_connect(xtd::sptr<xtd::iasync_result> async_result);
        
        using object::equals;
        bool equals(const tcp_client& s) const noexcept override;
        
        xtd::net::sockets::network_stream get_stream() const;
        
      protected:
        
        bool active() const noexcept;
        tcp_client& active(bool value) noexcept;
        
      private:
        friend tcp_listener;
        explicit tcp_client(const xtd::net::sockets::socket& socket);
        
        xtd::sptr<data> data_;
      };
    }
  }
}