async_operation.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_ASYNC_OPERATION_HPP
#define JOIN_CORE_ASYNC_OPERATION_HPP
 
// libjoin.
#include <join/io_operation.hpp>
#include <join/function.hpp>
#include <join/protocol.hpp>
 
// C++.
#include <system_error>
#include <algorithm>
 
// C.
#include <sys/socket.h>
#include <cstddef>
 
namespace join
{
    template <class Protocol, class ProactorType>
    struct BasicAsyncWait
    {
        using Wait = Function<void (const std::error_code&, bool), 16>;
 
        IoOperation op = {};
 
        Wait waitHandler;
    };
 
    template <class Protocol, class ProactorType>
    struct BasicAsyncAccept
    {
        using Endpoint = typename Protocol::Endpoint;
        using Socket = typename Protocol::Socket;
 
        using Accept = Function<void (Socket&&, const std::error_code&, bool), 16>;
 
        IoOperation op = {};
 
        Accept acceptHandler;
 
        Endpoint remote;
 
        socklen_t remoteLen = sizeof (struct sockaddr_storage);
    };
 
    template <class Protocol, class ProactorType>
    struct BasicAsyncRead
    {
        using Endpoint = typename Protocol::Endpoint;
 
        using Read = Function<void (const std::error_code&, const char*, size_t, bool), 16>;
 
        using ReadFrom =
            Function<void (const std::error_code&, const char*, size_t, const Endpoint&, const char*, size_t, bool),
                     16>;
 
        IoOperation op = {};
 
        Read readHandler;
 
        ReadFrom readFromHandler;
 
        msghdr msg = {};
 
        iovec iov = {};
    };
 
    template <class Protocol, class ProactorType>
    struct BasicAsyncWrite
    {
        using Connect = Function<void (const std::error_code&), 16>;
 
        using Write = Function<void (const std::error_code&, size_t), 16>;
 
        IoOperation op = {};
 
        Connect connectHandler;
 
        Write writeHandler;
 
        msghdr msg = {};
 
        iovec iov = {};
    };
 
    template <class... Ops>
    struct BasicAsyncOpTraits
    {
        static_assert (sizeof...(Ops) > 0, "traits must describe at least one operation");
 
        static constexpr size_t maxSize = std::max ({sizeof (Ops)...});
    };
 
    template <class Protocol, class ProactorType>
    using AsyncOp = BasicAsyncOpTraits<BasicAsyncWait<Protocol, ProactorType>, BasicAsyncRead<Protocol, ProactorType>,
                                       BasicAsyncWrite<Protocol, ProactorType>>;
}
 
#endif