udp_client.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_ASIO_UDP_CLIENT_H
#define CPPSERVER_ASIO_UDP_CLIENT_H
 
#include "udp_resolver.h"
 
#include "system/uuid.h"
#include "time/timespan.h"
 
#include <mutex>
#include <vector>
 
namespace CppServer {
namespace Asio {


class UDPClient : public std::enable_shared_from_this<UDPClient>
{
public:

    UDPClient(const std::shared_ptr<Service>& service, const std::string& address, int port);

    UDPClient(const std::shared_ptr<Service>& service, const std::string& address, const std::string& scheme);

    UDPClient(const std::shared_ptr<Service>& service, const asio::ip::udp::endpoint& endpoint);
    UDPClient(const UDPClient&) = delete;
    UDPClient(UDPClient&&) = delete;
    virtual ~UDPClient() = default;
 
    UDPClient& operator=(const UDPClient&) = delete;
    UDPClient& operator=(UDPClient&&) = delete;

    const CppCommon::UUID& id() const noexcept { return _id; }

    std::shared_ptr<Service>& service() noexcept { return _service; }
    std::shared_ptr<asio::io_context>& io_context() noexcept { return _io_context; }
    asio::io_context::strand& strand() noexcept { return _strand; }
    asio::ip::udp::endpoint& endpoint() noexcept { return _endpoint; }
    asio::ip::udp::socket& socket() noexcept { return _socket; }

    const std::string& address() const noexcept { return _address; }
    const std::string& scheme() const noexcept { return _scheme; }
    int port() const noexcept { return _port; }

    uint64_t bytes_pending() const noexcept { return _bytes_sending; }
    uint64_t bytes_sent() const noexcept { return _bytes_sent; }
    uint64_t bytes_received() const noexcept { return _bytes_received; }
    uint64_t datagrams_sent() const noexcept { return _datagrams_sent; }
    uint64_t datagrams_received() const noexcept { return _datagrams_received; }

    bool option_reuse_address() const noexcept { return _option_reuse_address; }
    bool option_reuse_port() const noexcept { return _option_reuse_port; }
    bool option_multicast() const noexcept { return _option_multicast; }
    size_t option_receive_buffer_limit() const noexcept { return _receive_buffer_limit; }
    size_t option_receive_buffer_size() const;
    size_t option_send_buffer_limit() const noexcept { return _send_buffer_limit; }
    size_t option_send_buffer_size() const;

    bool IsConnected() const noexcept { return _connected; }


    virtual bool Connect();

    virtual bool Connect(const std::shared_ptr<UDPResolver>& resolver);

    virtual bool Disconnect() { return DisconnectInternal(); }

    virtual bool Reconnect();


    virtual bool ConnectAsync();

    virtual bool ConnectAsync(const std::shared_ptr<UDPResolver>& resolver);

    virtual bool DisconnectAsync() { return DisconnectInternalAsync(false); }

    virtual bool ReconnectAsync();


    virtual void JoinMulticastGroup(const std::string& address);

    virtual void LeaveMulticastGroup(const std::string& address);


    virtual void JoinMulticastGroupAsync(const std::string& address);

    virtual void LeaveMulticastGroupAsync(const std::string& address);


    virtual size_t Send(const void* buffer, size_t size);

    virtual size_t Send(std::string_view text) { return Send(text.data(), text.size()); }

    virtual size_t Send(const asio::ip::udp::endpoint& endpoint, const void* buffer, size_t size);

    virtual size_t Send(const asio::ip::udp::endpoint& endpoint, std::string_view text) { return Send(endpoint, text.data(), text.size()); }


    virtual size_t Send(const void* buffer, size_t size, const CppCommon::Timespan& timeout);

    virtual size_t Send(std::string_view text, const CppCommon::Timespan& timeout) { return Send(text.data(), text.size(), timeout); }

    virtual size_t Send(const asio::ip::udp::endpoint& endpoint, const void* buffer, size_t size, const CppCommon::Timespan& timeout);

    virtual size_t Send(const asio::ip::udp::endpoint& endpoint, std::string_view text, const CppCommon::Timespan& timeout) { return Send(endpoint, text.data(), text.size(), timeout); }


    virtual bool SendAsync(const void* buffer, size_t size);

    virtual bool SendAsync(std::string_view text) { return SendAsync(text.data(), text.size()); }

    virtual bool SendAsync(const asio::ip::udp::endpoint& endpoint, const void* buffer, size_t size);

    virtual bool SendAsync(const asio::ip::udp::endpoint& endpoint, std::string_view text) { return SendAsync(endpoint, text.data(), text.size()); }


    virtual size_t Receive(asio::ip::udp::endpoint& endpoint, void* buffer, size_t size);

    virtual std::string Receive(asio::ip::udp::endpoint& endpoint, size_t size);


    virtual size_t Receive(asio::ip::udp::endpoint& endpoint, void* buffer, size_t size, const CppCommon::Timespan& timeout);

    virtual std::string Receive(asio::ip::udp::endpoint& endpoint, size_t size, const CppCommon::Timespan& timeout);

    virtual void ReceiveAsync();


    void SetupReuseAddress(bool enable) noexcept { _option_reuse_address = enable; }

    void SetupReusePort(bool enable) noexcept { _option_reuse_port = enable; }

    void SetupMulticast(bool enable) noexcept { _option_reuse_address = enable; _option_multicast = enable; }

    void SetupReceiveBufferLimit(size_t limit) noexcept { _receive_buffer_limit = limit; }

    void SetupReceiveBufferSize(size_t size);

    void SetupSendBufferLimit(size_t limit) noexcept { _send_buffer_limit = limit; }

    void SetupSendBufferSize(size_t size);
 
protected:
    virtual void onConnecting() {}
    virtual void onConnected() {}
    virtual void onDisconnecting() {}
    virtual void onDisconnected() {}


    virtual void onJoinedMulticastGroup(const std::string& address) {}

    virtual void onLeftMulticastGroup(const std::string& address) {}


    virtual void onReceived(const asio::ip::udp::endpoint& endpoint, const void* buffer, size_t size) {}

    virtual void onSent(const asio::ip::udp::endpoint& endpoint, size_t sent) {}


    virtual void onError(int error, const std::string& category, const std::string& message) {}
 
private:
    // Client Id
    CppCommon::UUID _id;
    // Asio service
    std::shared_ptr<Service> _service;
    // Asio IO context
    std::shared_ptr<asio::io_context> _io_context;
    // Asio service strand for serialized handler execution
    asio::io_context::strand _strand;
    bool _strand_required;
    // Server address, scheme & port
    std::string _address;
    std::string _scheme;
    int _port;
    // Server endpoint & client socket
    asio::ip::udp::endpoint _endpoint;
    asio::ip::udp::socket _socket;
    std::atomic<bool> _resolving;
    std::atomic<bool> _connected;
    // Client statistic
    uint64_t _bytes_sending;
    uint64_t _bytes_sent;
    uint64_t _bytes_received;
    uint64_t _datagrams_sent;
    uint64_t _datagrams_received;
    // Receive and send endpoints
    asio::ip::udp::endpoint _receive_endpoint;
    asio::ip::udp::endpoint _send_endpoint;
    // Receive buffer
    bool _receiving;
    size_t _receive_buffer_limit{0};
    std::vector<uint8_t> _receive_buffer;
    HandlerStorage _receive_storage;
    // Send buffer
    bool _sending;
    size_t _send_buffer_limit{0};
    std::vector<uint8_t> _send_buffer;
    HandlerStorage _send_storage;
    // Options
    bool _option_reuse_address;
    bool _option_reuse_port;
    bool _option_multicast;

    bool DisconnectInternal();
    bool DisconnectInternalAsync(bool dispatch);

    void TryReceive();

    void ClearBuffers();

    void SendError(std::error_code ec);
};

 
} // namespace Asio
} // namespace CppServer
 
#endif // CPPSERVER_ASIO_UDP_CLIENT_H