async_pipe.hpp

#ifndef LIBFILEZILLA_GLUE_ASYNC_PIPE_HEADER
#define LIBFILEZILLA_GLUE_ASYNC_PIPE_HEADER
 
#include "../libfilezilla.hpp"
 
#ifdef FZ_WINDOWS
 
#include "../buffer.hpp"
#include "../event.hpp"
#include "../fsresult.hpp"
#include "../thread_pool.hpp"
 
#include "windows.hpp"
 
#include <optional>
 
namespace fz {
 
class event_handler;
 

enum class pipe_event_flag
{
    read = 0x1,

    write = 0x2,
};

struct pipe_event_type;
 
class async_pipe;

typedef simple_event<pipe_event_type, async_pipe*, pipe_event_flag> pipe_event;
 
 
class FZ_PUBLIC_SYMBOL async_pipe final
{
public:
    // Connect a named pipe to a pipe server
    async_pipe(thread_pool & pool, event_handler& h);
    async_pipe(thread_pool & pool, event_handler& h, HANDLE read_pipe, HANDLE write_pipe);
    async_pipe(thread_pool & pool, event_handler& h, std::wstring_view name);
    ~async_pipe();
 
    async_pipe(async_pipe const&) = delete;
    async_pipe& operator=(async_pipe const&) = delete;
 
    bool connect_named_pipe(std::wstring_view name);
 
    bool valid() const;
 
    void reset();

    rwresult read(void* buffer, size_t len);

    rwresult write(void const* buffer, size_t len);
 
    inline rwresult write(std::string_view const& s) {
        return write(s.data(), s.size());
    }
 
private:
    bool init();
    void thread_entry();
    thread_pool & pool_;
    event_handler & handler_;
 
    mutex mutex_{false};
    async_task task_;
    buffer read_buffer_;
    buffer write_buffer_;
    HANDLE sync_{INVALID_HANDLE_VALUE};
    OVERLAPPED ol_read_{};
    OVERLAPPED ol_write_{};
    rwresult write_error_{0};
    std::optional<rwresult> terminal_read_result_;
    bool waiting_read_{true};
    bool waiting_write_{};
    bool quit_{};
 
    HANDLE read_{INVALID_HANDLE_VALUE};
    HANDLE write_{INVALID_HANDLE_VALUE};
};
 
}
 
#else
#error This file is for Windows only
#endif
 
#endif