udp_client.hpp

Go to the documentation of this file.

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

namespace xtd {
  namespace net {
    namespace sockets {
      class core_export_ udp_client : public xtd::object, public xtd::iequatable<udp_client> {
        class async_result_socket : public xtd::object, public xtd::iasync_result {
        public:
          explicit async_result_socket(const xtd::any_object& async_state) : async_state_(async_state) {}
          xtd::any_object 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_;};
          
          xtd::any_object 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_receive : public async_result_socket {
        public:
          explicit async_result_receive(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::array<xtd::byte> buffer_;
          xtd::net::ip_end_point remote_end_point_;
        };
        
        class async_result_send : public async_result_socket {
        public:
          explicit async_result_send(const xtd::any_object& async_state) : async_result_socket(async_state) {}
          xtd::size number_of_bytes_sent_ = 0;
        };
        
        struct data;
        
      public:
        
        udp_client();
        explicit udp_client(uint16 port);
        explicit udp_client(const xtd::net::ip_end_point& local_end_point);
        explicit udp_client(xtd::net::sockets::address_family address_Family);
        udp_client(uint16 port, xtd::net::sockets::address_family addressFamily);
        udp_client(const xtd::string& hostname, uint16 port);
        
        udp_client(udp_client&&) = default;
        udp_client(const udp_client&) = default;
        ~udp_client();
        auto operator =(const udp_client&) -> udp_client& = default;
        auto operator =(udp_client&&) -> udp_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 -> udp_client&;
        
        [[nodiscard]] auto dont_fragment() const -> bool;
        auto dont_fragment(bool value) -> udp_client&;
        
        [[nodiscard]] auto enable_broadcast() const -> bool;
        auto enable_broadcast(bool value) -> udp_client&;
        
        [[nodiscard]] auto exclusive_address_use() const -> bool;
        auto exclusive_address_use(bool value) -> udp_client&;
        
        [[nodiscard]] auto multicast_loopback() const -> bool;
        auto multicast_loopback(bool value) -> udp_client&;
        
        [[nodiscard]] auto ttl() const -> xtd::byte;
        auto ttl(xtd::byte value) -> udp_client&;
        
        
        auto allow_nat_traversal(bool allowed) -> void;
        
        auto begin_receive(xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_send(const xtd::array<xtd::byte>& dgram, xtd::size bytes, const xtd::string& hostname, uint16 port, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        
        auto begin_send(const xtd::array<xtd::byte>& dgram, xtd::size bytes, const xtd::net::ip_end_point& end_point, xtd::async_callback callback, const xtd::any_object& state) -> xtd::sptr<xtd::iasync_result>;
        auto begin_send(const xtd::array<xtd::byte>& dgram, xtd::size bytes, 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& 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 drop_multicast_group(const xtd::net::ip_address& multicast_address) -> void;
        auto drop_multicast_group(const xtd::net::ip_address& multicast_address, uint32 if_index) -> void;
        
        auto end_receive(xtd::sptr<xtd::iasync_result> async_result, xtd::net::ip_end_point& remote_end_point) -> xtd::array<xtd::byte>;
        
        auto end_send(xtd::sptr<xtd::iasync_result> async_result) -> xtd::size;
        
        [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override;
        [[nodiscard]] auto equals(const udp_client& other) const noexcept -> bool override;
        
        auto join_multicast_group(const xtd::net::ip_address& multicast_address) -> void;
        auto join_multicast_group(uint32 if_index, const xtd::net::ip_address& multicast_address) -> void;
        auto join_multicast_group(const xtd::net::ip_address& multicast_address, xtd::byte ttl) -> void;
        auto join_multicast_group(const xtd::net::ip_address& multicast_address, const xtd::net::ip_address& local_address) -> void;
        
        [[nodiscard]] auto receive(xtd::net::ip_end_point& remote_end_point) -> xtd::array<xtd::byte>;
        
        auto send(const xtd::array<xtd::byte>& dgram, xtd::size bytes, const xtd::string& hostname, uint16 port) -> xtd::size;
        auto send(const xtd::array<xtd::byte>& dgram, xtd::size bytes, const xtd::net::ip_end_point& end_point) -> xtd::size;
        auto send(const xtd::array<xtd::byte>& dgram, xtd::size bytes) -> xtd::size;
        
      protected:
        
        [[nodiscard]] auto active() const noexcept -> bool;
        auto active(bool value) noexcept -> udp_client&;
        
      private:
        udp_client(const xtd::net::sockets::socket& socket);
        
        xtd::sptr<data> data_;
      };
    }
  }
}