udp_client.h

Go to the documentation of this file.

#pragma once

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

namespace xtd {
  namespace net {
    namespace sockets {
      class udp_client : public xtd::object {
        class async_result_socket : public xtd::object, public xtd::iasync_result {
        public:
          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_receive : public async_result_socket {
        public:
          async_result_receive(std::any async_state) : async_result_socket(async_state) {}
          std::vector<byte_t> buffer_;
          xtd::net::ip_end_point remote_end_point_;
        };

        class async_result_send : public async_result_socket {
        public:
          async_result_send(std::any async_state) : async_result_socket(async_state) {}
          size_t number_of_bytes_sent_;
        };

      public:
        udp_client();
        explicit udp_client(uint16_t 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_t port, xtd::net::sockets::address_family addressFamily);
        udp_client(const xtd::ustring& hostname, uint16_t port);

        udp_client(udp_client&&) = default;
        udp_client(const udp_client&) = default;
        ~udp_client();
        udp_client& operator=(const udp_client&) = default;
        friend std::ostream& operator <<(std::ostream& os, const udp_client& uc) noexcept {return os << uc.to_string();}
        bool operator==(const udp_client& s) const {return data_ == s.data_;};
        bool operator!=(const udp_client& s) const {return !operator==(s);};

        size_t available() const;
        
        xtd::net::sockets::socket client() const noexcept;
        udp_client& client(const xtd::net::sockets::socket& value) noexcept;

        bool dont_fragment() const;
        udp_client& dont_fragment(bool value);

        bool enable_broadcast() const;
        udp_client& enable_broadcast(bool value);
        
        bool exclusive_address_use() const;
        udp_client& exclusive_address_use(bool value);

        bool multicast_loopback() const;
        udp_client& multicast_loopback(bool value);
        
        byte_t ttl() const;
        udp_client& ttl(byte_t value);

        void allow_nat_traversal(bool allowed);
        
        std::shared_ptr<xtd::iasync_result> begin_receive(xtd::async_callback callback, const std::any& state);

        std::shared_ptr<xtd::iasync_result> begin_send(const std::vector<byte_t>& dgram, size_t bytes, const xtd::ustring& hostname, uint16_t port, xtd::async_callback callback, const std::any& state);
        
        std::shared_ptr<xtd::iasync_result> begin_send(const std::vector<byte_t>& dgram, size_t bytes, const xtd::net::ip_end_point& end_point, xtd::async_callback callback, const std::any& state);
        std::shared_ptr<xtd::iasync_result> begin_send(const std::vector<byte_t>& dgram, size_t bytes, xtd::async_callback callback, const std::any& state);

        void close();
        
        void connect(const xtd::net::ip_end_point& end_point);
        void connect(const xtd::net::ip_address& ip_address, uint16_t port);
        void connect(const xtd::ustring& hostname, uint16_t port);

        void drop_multicast_group(const xtd::net::ip_address& multicast_address);
        void drop_multicast_group(const xtd::net::ip_address& multicast_address, uint32_t if_index);

        std::vector<byte_t> end_receive(std::shared_ptr<xtd::iasync_result> async_result, xtd::net::ip_end_point& remote_end_point);

        size_t end_send(std::shared_ptr<xtd::iasync_result> async_result);

        void join_multicast_group(const xtd::net::ip_address& multicast_address);
        void join_multicast_group(uint32_t if_index, const xtd::net::ip_address& multicast_address);
        void join_multicast_group(const xtd::net::ip_address& multicast_address, byte_t ttl);
        void join_multicast_group(const xtd::net::ip_address& multicast_address, const xtd::net::ip_address& local_address);

        std::vector<byte_t> receive(xtd::net::ip_end_point& remote_end_point);
        
        size_t send(const std::vector<byte_t>& dgram, size_t bytes, const xtd::ustring& hostname, uint16_t port);
        size_t send(const std::vector<byte_t>& dgram, size_t bytes, const xtd::net::ip_end_point& end_point);
        size_t send(const std::vector<byte_t>& dgram, size_t bytes);

      protected:        
        bool active() const noexcept;
        udp_client& active(bool value) noexcept;

      private:
        udp_client(const xtd::net::sockets::socket& socket);
        struct data;
        std::shared_ptr<data> data_;
      };
    }
  }
}