tcp_listener.hpp

Go to the documentation of this file.

 
#pragma once
#include "tcp_client.hpp"
#include "../../threading/manual_reset_event.hpp"
#include "../../iequatable.hpp"
 
namespace xtd {
  namespace net {
    namespace sockets {
      class core_export_ tcp_listener : public xtd::object, public xtd::iequatable<tcp_listener> {
        class async_result_socket : public xtd::object, public xtd::iasync_result {
        public:
          explicit async_result_socket(std::any async_state) : async_state_(async_state) {}
          std::any async_state() const noexcept override {return async_state_;}
          xtd::threading::wait_handle& async_wait_handle() noexcept override {return async_event_;}
          bool completed_synchronously() const noexcept override {return false;}
          bool is_completed() const noexcept override {return is_completed_;};
          
          std::any async_state_;
          bool is_completed_ = false;
          xtd::threading::manual_reset_event async_event_;
          xtd::net::sockets::socket_error error_code_ = xtd::net::sockets::socket_error::success;
          std::exception_ptr exception_;
        };
        
        class async_result_accept_socket : public async_result_socket {
        public:
          explicit async_result_accept_socket(std::any async_state) : async_result_socket(async_state) {}
          xtd::net::sockets::socket socket_;
        };
        
        class async_result_accept_tcp_client : public async_result_socket {
        public:
          explicit async_result_accept_tcp_client(std::any async_state) : async_result_socket(async_state) {}
          xtd::net::sockets::tcp_client tcp_client_;
        };
        
        struct data;
        
      public:
        
        explicit tcp_listener(const xtd::net::ip_end_point& local_end_point);
        
        tcp_listener(const xtd::net::ip_address& ip_address, uint16 port);
        
        tcp_listener(tcp_listener&&) = default;
        tcp_listener(const tcp_listener&) = default;
        ~tcp_listener();
        tcp_listener& operator =(const tcp_listener&) = default;
        
        
        bool exclusive_address_use() const;
        tcp_listener& exclusive_address_use(bool value);
        
        const xtd::net::end_point& local_end_point() const noexcept;
        
        xtd::net::sockets::socket server() const noexcept;
        
        
        xtd::net::sockets::socket accept_socket();
        
        xtd::net::sockets::tcp_client accept_tcp_client();
        
        xtd::sptr<xtd::iasync_result> begin_accept_socket(xtd::async_callback callback, const std::any& state);
        
        xtd::sptr<xtd::iasync_result> begin_accept_tcp_client(xtd::async_callback callback, const std::any& state);
        
        xtd::net::sockets::socket end_accept_socket(xtd::sptr<xtd::iasync_result> async_result);
        
        xtd::net::sockets::tcp_client end_accept_tcp_client(xtd::sptr<xtd::iasync_result> async_result);
        
        using object::equals;
        bool equals(const tcp_listener& s) const noexcept override;
        
        bool pending();
        
        void start();
        
        void start(size_t backlog);
        
        void stop();
 
        
        static tcp_listener create(uint16 port);
 
      protected:
        
        bool active() const noexcept;
        
      private:
        xtd::sptr<data> data_;
      };
    }
  }
}