aio.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_AIO_HEADER
#define LIBFILEZILLA_AIO_HEADER

 
#include "../event.hpp"
#include "../event_handler.hpp"
#include "../mutex.hpp"
#include "../nonowning_buffer.hpp"
 
#include <tuple>
 
namespace fz {
 
class aio_buffer_pool;

class FZ_PUBLIC_SYMBOL buffer_lease final
{
public:
    constexpr buffer_lease() noexcept = default;
    ~buffer_lease() noexcept
    {
        release();
    }
 
    buffer_lease(buffer_lease && op) noexcept;
    buffer_lease& operator=(buffer_lease && op) noexcept;
 
    buffer_lease(buffer_lease const&) = delete;
    buffer_lease& operator=(buffer_lease const&) = delete;
 
    explicit operator bool() const { return pool_ != nullptr; }
 
    // operator. would be nice
    nonowning_buffer const* operator->() const { return &buffer_; }
    nonowning_buffer* operator->() { return &buffer_; }
    nonowning_buffer const& operator*() const { return buffer_; }
    nonowning_buffer & operator*() { return buffer_; }
 
    void release();
 
    nonowning_buffer buffer_;
private:
    friend class aio_buffer_pool;
    FZ_PRIVATE_SYMBOL buffer_lease(nonowning_buffer b, aio_buffer_pool* pool)
        : buffer_(b)
        , pool_(pool)
    {
    }
 
    aio_buffer_pool* pool_{};
};
 
class aio_waitable;
class event_handler;

class FZ_PUBLIC_SYMBOL aio_waitable
{
public:
    virtual ~aio_waitable() = default;

    void remove_waiter(event_handler & h);
 
protected:

    void remove_waiters();
 
    void add_waiter(event_handler & h);

    void signal_availibility();
 
private:
 
    mutex m_;
    std::vector<event_handler*> waiting_handlers_;
};

struct aio_buffer_event_type{};
 
typedef simple_event<aio_buffer_event_type, aio_waitable const*> aio_buffer_event;
 
class logger_interface;

class FZ_PUBLIC_SYMBOL aio_buffer_pool final : public aio_waitable
{
public:
    // If buffer_size is 0, it picks a suitable default
#if FZ_MAC
    // On macOS, if using sandboxing, you need to pass an application group identifier.
    aio_buffer_pool(thread_pool & tpool, logger_interface & logger, size_t buffer_count = 1, size_t buffer_size = 0, bool use_shm = false, std::string_view application_group_id = {});
#else
    aio_buffer_pool(thread_pool & tpool, logger_interface & logger, size_t buffer_count = 1, size_t buffer_size = 0, bool use_shm = false);
#endif
    ~aio_buffer_pool() noexcept;
 
    operator bool() const {
        return memory_ != nullptr;
    }

    buffer_lease get_buffer(event_handler & h);
 
    logger_interface & logger() const { return logger_; }
 
#if FZ_WINDOWS
    // A HANDLE
    typedef void* shm_handle;
    static shm_handle const shm_handle_default;
#else
    // A file descriptor
    typedef int shm_handle;
    static shm_handle constexpr shm_handle_default{-1};
#endif

    std::tuple<shm_handle, uint8_t const*, size_t> shared_memory_info() const;
 
    size_t buffer_count() const { return buffer_count_; }
 
    event_loop& loop() { return loop_; }
 
private:
    friend class buffer_lease;
    void FZ_PRIVATE_SYMBOL release(nonowning_buffer && b);
 
    event_loop loop_;
    logger_interface & logger_;
 
    mutable mutex mtx_;
 
    uint64_t memory_size_{};
    uint8_t* memory_{};
 
    std::vector<nonowning_buffer> buffers_;
 
    shm_handle shm_{shm_handle_default};
 
    size_t const buffer_count_{};
};

enum class aio_result
{
    ok,

    wait,

    error
};
 
class FZ_PUBLIC_SYMBOL aio_base
{
public:
    virtual ~aio_base() noexcept = default;
 
    using size_type = uint64_t;
    static constexpr auto nosize = static_cast<size_type>(-1);
};
 
}
 
#endif