tcp_client.h

Go to the documentation of this file.

#pragma once

#include "../../object.h"
#include "../../ustring.h"
#include "../ip_end_point.h"
#include "network_stream.h"
#include "socket.h"

namespace xtd {
  namespace net {
    namespace sockets {
      class tcp_listener;
      
      class core_export_ tcp_client : public xtd::object {
      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::ustring& hostname, uint16_t port);
        
        tcp_client(tcp_client&&) = default;
        tcp_client(const tcp_client&) = default;
        ~tcp_client();
        tcp_client& operator=(const tcp_client&) = default;
        friend std::ostream& operator <<(std::ostream& os, const tcp_client& tc) noexcept {return os << tc.to_string();}
        bool operator==(const tcp_client& s) const {return data_ == s.data_;};
        bool operator!=(const tcp_client& s) const {return !operator==(s);};
        
        
        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_t receive_timeout() const;
        tcp_client& receive_timeout(int32_t value);
        
        size_t send_buffer_size() const;
        tcp_client& send_buffer_size(size_t value);
        
        int32_t send_timeout() const;
        tcp_client& send_timeout(int32_t value);
        
        
        std::shared_ptr<xtd::iasync_result> begin_connect(const xtd::net::ip_address& address, uint16_t port, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_connect(const std::vector<xtd::net::ip_address>& addresses, uint16_t port, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_connect(const xtd::ustring& host, uint16_t 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_t port);
        void connect(const xtd::ustring& hostname, uint16_t port);
        
        void end_connect(std::shared_ptr<xtd::iasync_result> async_result);
        
        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);
        struct data;
        std::shared_ptr<data> data_;
      };
    }
  }
}