1 #ifndef ENTT_PROCESS_SCHEDULER_HPP
2 #define ENTT_PROCESS_SCHEDULER_HPP
10 #include "../config/config.h"
11 #include "process.hpp"
41 template<
typename Delta>
43 struct process_handler {
44 using instance_type = std::unique_ptr<void, void (*)(
void *)>;
45 using update_fn_type = bool(
scheduler &, std::size_t, Delta,
void *);
46 using abort_fn_type = void(
scheduler &, std::size_t,
bool);
47 using next_type = std::unique_ptr<process_handler>;
49 instance_type instance;
50 update_fn_type *update;
56 continuation(process_handler *ref) ENTT_NOEXCEPT
59 template<
typename Proc,
typename... Args>
60 continuation then(Args &&...args) {
62 auto proc =
typename process_handler::instance_type{
new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
63 handler->next.reset(
new process_handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>,
nullptr});
64 handler = handler->next.get();
68 template<
typename Func>
69 continuation then(Func &&func) {
70 return then<process_adaptor<std::decay_t<Func>, Delta>>(std::forward<Func>(func));
74 process_handler *handler;
77 template<
typename Proc>
78 [[nodiscard]]
static bool update(
scheduler &owner, std::size_t pos,
const Delta delta,
void *data) {
79 auto *
process =
static_cast<Proc *
>(owner.handlers[pos].instance.get());
85 if(
auto &&handler = owner.handlers[pos]; handler.next) {
86 handler = std::move(*handler.next);
88 return handler.update(owner, pos, {},
nullptr);
97 template<
typename Proc>
98 static void abort(
scheduler &owner, std::size_t pos,
const bool immediately) {
99 static_cast<Proc *
>(owner.handlers[pos].instance.get())->abort(immediately);
102 template<
typename Proc>
103 static void deleter(
void *proc) {
104 delete static_cast<Proc *
>(proc);
125 return handlers.size();
132 [[nodiscard]]
bool empty() const ENTT_NOEXCEPT {
133 return handlers.empty();
171 template<
typename Proc,
typename... Args>
174 auto proc =
typename process_handler::instance_type{
new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
175 auto &&ref = handlers.emplace_back(process_handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>,
nullptr});
177 ref.update(*
this, handlers.size() - 1u, {},
nullptr);
178 return continuation{&handlers.back()};
232 template<
typename Func>
235 return attach<Proc>(std::forward<Func>(func));
249 void update(
const Delta delta,
void *data =
nullptr) {
250 for(
auto pos = handlers.size(); pos; --pos) {
251 const auto curr = pos - 1u;
253 if(
const auto dead = handlers[curr].update(*
this, curr, delta, data); dead) {
254 std::swap(handlers[curr], handlers.back());
270 void abort(
const bool immediately =
false) {
271 for(
auto pos = handlers.size(); pos; --pos) {
272 const auto curr = pos - 1u;
273 handlers[curr].abort(*
this, curr, immediately);
278 std::vector<process_handler> handlers{};
Base class for processes.
bool finished() const
Returns true if a process is already terminated.
bool rejected() const
Returns true if a process terminated with errors.
void tick(const Delta delta, void *data=nullptr)
Updates a process and its internal state if required.
Cooperative scheduler for processes.
size_type size() const
Number of processes currently scheduled.
scheduler()=default
Default constructor.
void clear()
Discards all scheduled processes.
void update(const Delta delta, void *data=nullptr)
Updates all scheduled processes.
auto attach(Func &&func)
Schedules a process for the next tick.
void abort(const bool immediately=false)
Aborts all scheduled processes.
auto attach(Args &&...args)
Schedules a process for the next tick.
scheduler & operator=(scheduler &&)=default
Default move assignment operator.
bool empty() const
Returns true if at least a process is currently scheduled.
scheduler(scheduler &&)=default
Default move constructor.
std::size_t size_type
Unsigned integer type.
Adaptor for lambdas and functors to turn them into processes.