1#ifndef ENTT_PROCESS_PROCESS_HPP
2#define ENTT_PROCESS_PROCESS_HPP
70template<
typename Derived,
typename Delta>
72 enum class state : std::uint8_t {
83 template<
typename Target = Derived>
84 auto next(std::integral_constant<state, state::uninitialized>)
85 ->
decltype(std::declval<Target>().init(), void()) {
86 static_cast<Target *
>(
this)->init();
89 template<
typename Target = Derived>
90 auto next(std::integral_constant<state, state::running>, Delta delta,
void *data)
91 ->
decltype(std::declval<Target>().update(delta, data), void()) {
92 static_cast<Target *
>(
this)->update(delta, data);
95 template<
typename Target = Derived>
96 auto next(std::integral_constant<state, state::succeeded>)
97 ->
decltype(std::declval<Target>().succeeded(), void()) {
98 static_cast<Target *
>(
this)->succeeded();
101 template<
typename Target = Derived>
102 auto next(std::integral_constant<state, state::failed>)
103 ->
decltype(std::declval<Target>().failed(), void()) {
104 static_cast<Target *
>(
this)->failed();
107 template<
typename Target = Derived>
108 auto next(std::integral_constant<state, state::aborted>)
109 ->
decltype(std::declval<Target>().aborted(), void()) {
110 static_cast<Target *
>(
this)->aborted();
113 void next(...)
const noexcept {}
124 current = state::succeeded;
136 current = state::failed;
147 if(current == state::running) {
148 current = state::paused;
159 if(current == state::paused) {
160 current = state::running;
170 static_assert(std::is_base_of_v<process, Derived>,
"Incorrect use of the class template");
181 void abort(
const bool immediate =
false) {
183 current = state::aborted;
195 [[nodiscard]]
bool alive() const noexcept {
196 return current == state::running || current == state::paused;
204 return current == state::finished;
211 [[nodiscard]]
bool paused() const noexcept {
212 return current == state::paused;
220 return current == state::rejected;
228 void tick(
const Delta delta,
void *data =
nullptr) {
230 case state::uninitialized:
231 next(std::integral_constant<state, state::uninitialized>{});
232 current = state::running;
235 next(std::integral_constant<state, state::running>{}, delta, data);
244 case state::succeeded:
245 next(std::integral_constant<state, state::succeeded>{});
246 current = state::finished;
249 next(std::integral_constant<state, state::failed>{});
250 current = state::rejected;
253 next(std::integral_constant<state, state::aborted>{});
254 current = state::rejected;
263 state current{state::uninitialized};
305template<
typename Func,
typename Delta>
312 template<
typename... Args>
314 : Func{std::forward<Args>(args)...} {}
321 void update(
const Delta delta,
void *data) {
326 [
this]() { this->
fail(); });
Base class for processes.
bool finished() const noexcept
Returns true if a process is already terminated.
void pause() noexcept
Stops a process if it's in a running state.
void succeed() noexcept
Terminates a process with success if it's still alive.
void unpause() noexcept
Restarts a process if it's paused.
Delta delta_type
Type used to provide elapsed time.
bool rejected() const noexcept
Returns true if a process terminated with errors.
virtual ~process() noexcept
Default destructor.
void fail() noexcept
Terminates a process with errors if it's still alive.
bool alive() const noexcept
Returns true if a process is either running or paused.
void tick(const Delta delta, void *data=nullptr)
Updates a process and its internal state if required.
void abort(const bool immediate=false)
Aborts a process if it's still alive.
bool paused() const noexcept
Returns true if a process is currently paused.
Adaptor for lambdas and functors to turn them into processes.
void update(const Delta delta, void *data)
Updates a process and its internal state if required.
process_adaptor(Args &&...args)
Constructs a process adaptor from a lambda or a functor.