EnTT  3.10.0
scheduler.hpp
1 #ifndef ENTT_PROCESS_SCHEDULER_HPP
2 #define ENTT_PROCESS_SCHEDULER_HPP
3 
4 #include <algorithm>
5 #include <iterator>
6 #include <memory>
7 #include <type_traits>
8 #include <utility>
9 #include <vector>
10 #include "../config/config.h"
11 #include "process.hpp"
12 
13 namespace entt {
14 
41 template<typename Delta>
42 class scheduler {
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>;
48 
49  instance_type instance;
50  update_fn_type *update;
51  abort_fn_type *abort;
52  next_type next;
53  };
54 
55  struct continuation {
56  continuation(process_handler *ref) ENTT_NOEXCEPT
57  : handler{ref} {}
58 
59  template<typename Proc, typename... Args>
60  continuation then(Args &&...args) {
61  static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>, "Invalid process type");
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();
65  return *this;
66  }
67 
68  template<typename Func>
69  continuation then(Func &&func) {
70  return then<process_adaptor<std::decay_t<Func>, Delta>>(std::forward<Func>(func));
71  }
72 
73  private:
74  process_handler *handler;
75  };
76 
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());
80  process->tick(delta, data);
81 
82  if(process->rejected()) {
83  return true;
84  } else if(process->finished()) {
85  if(auto &&handler = owner.handlers[pos]; handler.next) {
86  handler = std::move(*handler.next);
87  // forces the process to exit the uninitialized state
88  return handler.update(owner, pos, {}, nullptr);
89  }
90 
91  return true;
92  }
93 
94  return false;
95  }
96 
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);
100  }
101 
102  template<typename Proc>
103  static void deleter(void *proc) {
104  delete static_cast<Proc *>(proc);
105  }
106 
107 public:
109  using size_type = std::size_t;
110 
112  scheduler() = default;
113 
115  scheduler(scheduler &&) = default;
116 
118  scheduler &operator=(scheduler &&) = default;
119 
124  [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
125  return handlers.size();
126  }
127 
132  [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
133  return handlers.empty();
134  }
135 
142  void clear() {
143  handlers.clear();
144  }
145 
171  template<typename Proc, typename... Args>
172  auto attach(Args &&...args) {
173  static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>, "Invalid process type");
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});
176  // forces the process to exit the uninitialized state
177  ref.update(*this, handlers.size() - 1u, {}, nullptr);
178  return continuation{&handlers.back()};
179  }
180 
232  template<typename Func>
233  auto attach(Func &&func) {
234  using Proc = process_adaptor<std::decay_t<Func>, Delta>;
235  return attach<Proc>(std::forward<Func>(func));
236  }
237 
249  void update(const Delta delta, void *data = nullptr) {
250  for(auto pos = handlers.size(); pos; --pos) {
251  const auto curr = pos - 1u;
252 
253  if(const auto dead = handlers[curr].update(*this, curr, delta, data); dead) {
254  std::swap(handlers[curr], handlers.back());
255  handlers.pop_back();
256  }
257  }
258  }
259 
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);
274  }
275  }
276 
277 private:
278  std::vector<process_handler> handlers{};
279 };
280 
281 } // namespace entt
282 
283 #endif
Base class for processes.
Definition: process.hpp:71
bool finished() const
Returns true if a process is already terminated.
Definition: process.hpp:203
bool rejected() const
Returns true if a process terminated with errors.
Definition: process.hpp:219
void tick(const Delta delta, void *data=nullptr)
Updates a process and its internal state if required.
Definition: process.hpp:228
Cooperative scheduler for processes.
Definition: scheduler.hpp:42
size_type size() const
Number of processes currently scheduled.
Definition: scheduler.hpp:124
scheduler()=default
Default constructor.
void clear()
Discards all scheduled processes.
Definition: scheduler.hpp:142
void update(const Delta delta, void *data=nullptr)
Updates all scheduled processes.
Definition: scheduler.hpp:249
auto attach(Func &&func)
Schedules a process for the next tick.
Definition: scheduler.hpp:233
void abort(const bool immediately=false)
Aborts all scheduled processes.
Definition: scheduler.hpp:270
auto attach(Args &&...args)
Schedules a process for the next tick.
Definition: scheduler.hpp:172
scheduler & operator=(scheduler &&)=default
Default move assignment operator.
bool empty() const
Returns true if at least a process is currently scheduled.
Definition: scheduler.hpp:132
scheduler(scheduler &&)=default
Default move constructor.
std::size_t size_type
Unsigned integer type.
Definition: scheduler.hpp:109
EnTT default namespace.
Definition: dense_map.hpp:22
Adaptor for lambdas and functors to turn them into processes.
Definition: process.hpp:306