tcp_listener.h

Go to the documentation of this file.

#pragma once

#include "tcp_client.h"

namespace xtd {
  namespace net {
    namespace sockets {
      class core_export_ tcp_listener : public xtd::object {
        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_;}
          std::shared_mutex& async_mutex() override {return async_mutex_;}
          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;
          std::shared_mutex async_mutex_;
          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_;
        };
        
      public:
        
        explicit tcp_listener(const xtd::net::ip_end_point& local_end_point);
        
        tcp_listener(const xtd::net::ip_address& ip_address, uint16_t port);
        
        tcp_listener(tcp_listener&&) = default;
        tcp_listener(const tcp_listener&) = default;
        ~tcp_listener();
        tcp_listener& operator=(const tcp_listener&) = default;
        friend std::ostream& operator <<(std::ostream& os, const tcp_listener& tl) noexcept {return os << tl.to_string();}
        bool operator==(const tcp_listener& s) const {return data_ == s.data_;};
        bool operator!=(const tcp_listener& s) const {return !operator==(s);};
        
        
        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();
        
        std::shared_ptr<xtd::iasync_result> begin_accept_socket(xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_accept_tcp_client(xtd::async_callback callback, const std::any& state);
        
        static tcp_listener create(uint16_t port);
        
        xtd::net::sockets::socket end_accept_socket(std::shared_ptr<xtd::iasync_result> async_result);
        
        xtd::net::sockets::tcp_client end_accept_tcp_client(std::shared_ptr<xtd::iasync_result> async_result);
        
        bool pending();
        
        void start();
        
        void start(size_t backlog);
        
        void stop();
        
      protected:
        
        bool active() const noexcept;
        
      private:
        struct data;
        std::shared_ptr<data> data_;
      };
    }
  }
}