udp_client.h

 
#pragma once
 
#include <system/string.h>
#include <system/shared_ptr.h>
#include <system/object.h>
#include <system/idisposable.h>
#include <system/iasyncresult.h>
#include <system/async_callback.h>
#include <system/array.h>
#include <net/sockets/socket.h>
#include <net/sockets/address_family.h>
#include <net/ip_end_point.h>
#include <net/ip_address.h>
#include <cstdint>
 
namespace System { namespace Net { namespace Sockets {
 
class ASPOSECPP_SHARED_CLASS UdpClient : public System::IDisposable
{
    typedef UdpClient ThisType;
    typedef System::IDisposable BaseType;
 
    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
    ASPOSECPP_SHARED_RTTI_INFO_DECL();
 
public:
    ASPOSECPP_SHARED_API System::SharedPtr<Socket> get_Client();
    ASPOSECPP_SHARED_API void set_Client(System::SharedPtr<Socket> value);
    /*
    ASPOSECPP_SHARED_API int32_t get_Available();
    ASPOSECPP_SHARED_API int16_t get_Ttl();
    ASPOSECPP_SHARED_API void set_Ttl(int16_t value);
    ASPOSECPP_SHARED_API bool get_DontFragment();
    ASPOSECPP_SHARED_API void set_DontFragment(bool value);
    ASPOSECPP_SHARED_API bool get_MulticastLoopback();
    ASPOSECPP_SHARED_API void set_MulticastLoopback(bool value);
    ASPOSECPP_SHARED_API bool get_EnableBroadcast();
    ASPOSECPP_SHARED_API void set_EnableBroadcast(bool value);
    ASPOSECPP_SHARED_API bool get_ExclusiveAddressUse();
    ASPOSECPP_SHARED_API void set_ExclusiveAddressUse(bool value);
    */
 
    ASPOSECPP_SHARED_API UdpClient();
    ASPOSECPP_SHARED_API UdpClient(AddressFamily family);
    ASPOSECPP_SHARED_API UdpClient(int32_t port);
    ASPOSECPP_SHARED_API UdpClient(int32_t port, AddressFamily family);
    ASPOSECPP_SHARED_API UdpClient(System::SharedPtr<IPEndPoint> localEP);
    ASPOSECPP_SHARED_API UdpClient(String hostname, int32_t port);
    ASPOSECPP_SHARED_API void Close();
    ASPOSECPP_SHARED_API void Dispose() override;
    ASPOSECPP_SHARED_API void Connect(String hostname, int32_t port);
    ASPOSECPP_SHARED_API void Connect(System::SharedPtr<IPAddress> addr, int32_t port);
    ASPOSECPP_SHARED_API void Connect(System::SharedPtr<IPEndPoint> endPoint);
 
    ASPOSECPP_SHARED_API int32_t Send(System::ArrayPtr<uint8_t> dgram, int32_t bytes,
                                      System::SharedPtr<IPEndPoint> endPoint);
    ASPOSECPP_SHARED_API int32_t Send(System::ArrayPtr<uint8_t> dgram, int32_t bytes, String hostname, int32_t port);
    ASPOSECPP_SHARED_API int32_t Send(System::ArrayPtr<uint8_t> dgram, int32_t bytes);
 
    ASPOSECPP_SHARED_API System::ArrayPtr<uint8_t> Receive(System::SharedPtr<IPEndPoint>& remoteEP);
 
protected:
    ASPOSECPP_SHARED_API bool get_Active();
    ASPOSECPP_SHARED_API void set_Active(bool value);
    ASPOSECPP_SHARED_API virtual void Dispose(bool disposing);
    ASPOSECPP_SHARED_API ~UdpClient() override;
 
private:
    static const int32_t MaxUDPSize;
    System::SharedPtr<Socket> m_ClientSocket;
    bool m_Active;
    System::ArrayPtr<uint8_t> m_Buffer;
    AddressFamily m_Family;
    bool m_CleanedUp;
    bool m_IsBroadcast;
 
    void FreeResources();
    void CheckForBroadcast(System::SharedPtr<IPAddress> ipAddress);
    static bool IsBroadcast(System::SharedPtr<IPAddress> address);
    void createClientSocket();
};
 
}}} // namespace System::Net::Sockets