socket_async_event_args.h

Go to the documentation of this file.

 
#pragma once
#include "ip_packet_information.h"
#include "socket.h"
#include "socket_flags.h"
#include "socket_async_operation.h"
#include "send_packets_element.h"
#include "transmit_file_options.h"
#include "../../any.h"
#include "../../delegate.h"
#include "../../event.h"
#include "../../event_args.h"
#include <memory>
#include <vector>
 
#undef unix
 
namespace xtd {
  namespace net {
    namespace sockets {
      class core_export_ socket_async_event_args : public xtd::event_args {
      public:
        
        socket_async_event_args() = default;
        explicit socket_async_event_args(bool suppress_execution_context_flow);
        
        
        xtd::net::sockets::socket accept_socket() const noexcept;
        socket_async_event_args& accept_socket(const xtd::net::sockets::socket& value) noexcept;
        
        const std::vector<xtd::byte>& buffer() const noexcept;
        std::vector<xtd::byte>& buffer() noexcept;
        
        
        void set_buffer(const std::vector<xtd::byte>& memory_buffer);
        
        void set_buffer(size_t offset, size_t count);
        void set_buffer(const std::vector<xtd::byte>& buffer, size_t offset, size_t count);
        
        
        xtd::event<socket_async_event_args, xtd::delegate<void(const socket_async_event_args&)>> completed;
        
      protected:
        
        virtual void on_complete(const socket_async_event_args& e);
        
      private:
        friend socket;
        xtd::net::sockets::socket accept_socket_;
        std::vector<xtd::byte> buffer_;
        std::vector<std::vector<xtd::byte>> buffer_list_;
        size_t bytes_transferred_ = 0;
        xtd::uptr<xtd::exception> connect_by_name_error_;
        xtd::net::sockets::socket connect_socket_;
        size_t count_ = 0;
        bool disconnect_reuse_socket_ = false;
        xtd::net::sockets::socket_async_operation last_operation = xtd::net::sockets::socket_async_operation::none;
        std::vector<xtd::byte> memory_buffer_;
        size_t offset_ = 0;
        xtd::net::sockets::ip_packet_information receive_message_from_packet_info_;
        xtd::uptr<xtd::net::end_point> remote_end_point_;
        std::vector<xtd::net::sockets::send_packets_element> send_packets_elements_;
        xtd::net::sockets::transmit_file_options send_packets_flags_ = xtd::net::sockets::transmit_file_options::use_default_worker_thread;
        size_t send_packets_send_size_ = 0;
        xtd::net::sockets::socket_error socket_error_ = xtd::net::sockets::socket_error::success;
        xtd::net::sockets::socket_flags socket_flags_ = xtd::net::sockets::socket_flags::none;
        std::any user_token_;
      };
    }
  }
}