libfilezilla
Loading...
Searching...
No Matches
aio.hpp
Go to the documentation of this file.
1#ifndef LIBFILEZILLA_AIO_HEADER
2#define LIBFILEZILLA_AIO_HEADER
3
7
8#include "../event.hpp"
10#include "../mutex.hpp"
12
13#include <tuple>
14
15namespace fz {
16
17class aio_buffer_pool;
18
25class FZ_PUBLIC_SYMBOL buffer_lease final
26{
27public:
28 constexpr buffer_lease() noexcept = default;
29 ~buffer_lease() noexcept
30 {
31 release();
32 }
33
34 buffer_lease(buffer_lease && op) noexcept;
35 buffer_lease& operator=(buffer_lease && op) noexcept;
36
37 buffer_lease(buffer_lease const&) = delete;
38 buffer_lease& operator=(buffer_lease const&) = delete;
39
40 explicit operator bool() const { return pool_ != nullptr; }
41
42 // operator. would be nice
43 nonowning_buffer const* operator->() const { return &buffer_; }
44 nonowning_buffer* operator->() { return &buffer_; }
45 nonowning_buffer const& operator*() const { return buffer_; }
46 nonowning_buffer & operator*() { return buffer_; }
47
48 void release();
49
50 nonowning_buffer buffer_;
51private:
52 friend class aio_buffer_pool;
53 FZ_PRIVATE_SYMBOL buffer_lease(nonowning_buffer b, aio_buffer_pool* pool)
54 : buffer_(b)
55 , pool_(pool)
56 {
57 }
58
59 aio_buffer_pool* pool_{};
60};
61
62class aio_waitable;
63class event_handler;
64
68class FZ_PUBLIC_SYMBOL aio_waitable
69{
70public:
71 virtual ~aio_waitable() = default;
72
77
78protected:
79
82
83 void add_waiter(event_handler & h);
84
86 void signal_availibility();
87
88private:
89
90 mutex m_;
91 std::vector<event_handler*> waiting_handlers_;
92};
93
95struct aio_buffer_event_type{};
96
97typedef simple_event<aio_buffer_event_type, aio_waitable const*> aio_buffer_event;
98
99class logger_interface;
100
106class FZ_PUBLIC_SYMBOL aio_buffer_pool final : public aio_waitable
107{
108public:
109 // If buffer_size is 0, it picks a suitable default
110#if FZ_MAC
111 // On macOS, if using sandboxing, you need to pass an application group identifier.
112 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 = {});
113#else
114 aio_buffer_pool(thread_pool & tpool, logger_interface & logger, size_t buffer_count = 1, size_t buffer_size = 0, bool use_shm = false);
115#endif
116 ~aio_buffer_pool() noexcept;
117
118 operator bool() const {
119 return memory_ != nullptr;
120 }
121
130 buffer_lease get_buffer(event_handler & h);
131
132 logger_interface & logger() const { return logger_; }
133
134#if FZ_WINDOWS
135 // A HANDLE
136 typedef void* shm_handle;
137 static shm_handle const shm_handle_default;
138#else
139 // A file descriptor
140 typedef int shm_handle;
141 static shm_handle constexpr shm_handle_default{-1};
142#endif
143
163 std::tuple<shm_handle, uint8_t const*, size_t> shared_memory_info() const;
164
165 size_t buffer_count() const { return buffer_count_; }
166
167 event_loop& loop() { return loop_; }
168
169private:
170 friend class buffer_lease;
171 void FZ_PRIVATE_SYMBOL release(nonowning_buffer && b);
172
173 event_loop loop_;
174 logger_interface & logger_;
175
176 mutable mutex mtx_;
177
178 uint64_t memory_size_{};
179 uint8_t* memory_{};
180
181 std::vector<nonowning_buffer> buffers_;
182
183 shm_handle shm_{shm_handle_default};
184
185 size_t const buffer_count_{};
186};
187
189enum class aio_result
190{
193
197
200};
201
202class FZ_PUBLIC_SYMBOL aio_base
203{
204public:
205 virtual ~aio_base() noexcept = default;
206
207 using size_type = uint64_t;
208 static constexpr auto nosize = static_cast<size_type>(-1);
209};
210
211}
212
213#endif
Definition aio.hpp:203
A buffer pool for use with async readers/writers.
Definition aio.hpp:107
std::tuple< shm_handle, uint8_t const *, size_t > shared_memory_info() const
buffer_lease get_buffer(event_handler &h)
Returns either a buffer lease, or records the passed waiter/handler as waiting.
Definition aio.hpp:69
void remove_waiter(event_handler &h)
void remove_waiters()
Call in destructor of most-derived class.
Simple handler for asynchronous event processing.
Definition event_handler.hpp:55
A threaded event loop that supports sending events and timers.
Definition event_loop.hpp:34
Abstract interface for logging strings.
Definition logger.hpp:51
Lean replacement for std::(recursive_)mutex.
Definition mutex.hpp:57
Similar to fz::buffer, but does not own memory.
Definition nonowning_buffer.hpp:25
A dumb thread-pool for asynchronous tasks.
Definition thread_pool.hpp:64
Declares event_base and simple_event<>
Declares the event_handler class.
Thread synchronization primitives: mutex, scoped_lock and condition.
The namespace used by libfilezilla.
Definition apply.hpp:17
aio_result
Result of aio operations.
Definition aio.hpp:190
@ ok
Success, proceed.
Definition aio.hpp:192
@ wait
Definition aio.hpp:196
@ error
Operationf failed.
Definition aio.hpp:199
Declares fz::nonowning_buffer.