TaskContext Class Reference

#include <TaskScheduler.hpp>

Public Member Functions
	TaskContext ()
	TaskContext (TaskScheduler::TaskContainer &&task, std::weak_ptr< TaskScheduler > &&owner)
	TaskContext (TaskContext &&right)
TaskContext &	operator= (TaskContext &&right)
bool	IsExpired () const
	Returns true if the owner was deallocated and this context has expired. More...
bool	IsInGroup (TaskScheduler::group_t const group) const
	Returns true if the event is in the given group. More...
TaskContext &	SetGroup (TaskScheduler::group_t const group)
	Sets the event in the given group. More...
TaskContext &	ClearGroup ()
	Removes the group from the event. More...
TaskScheduler::repeated_t	GetRepeatCounter () const
	Returns the repeat counter which increases every time the task is repeated. More...
template<typename _Rep , typename _Period >
TaskContext &	Repeat (std::chrono::duration< _Rep, _Period > const &duration)
	Repeats the event and sets a new duration. std::chrono::seconds(5) for example. This will consume the task context, its not possible to repeat the task again from the same task context! More...
TaskContext &	Repeat ()
	Repeats the event with the same duration. This will consume the task context, its not possible to repeat the task again from the same task context! More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	Repeat (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
	Repeats the event and set a new duration that is randomized between min and max. std::chrono::seconds(5) for example. This will consume the task context, its not possible to repeat the task again from the same task context! More...
TaskContext &	Async (std::function< void()> const &callable)
	Schedule a callable function that is executed at the next update tick from within the context. Its safe to modify the TaskScheduler from within the callable. More...
template<typename _Rep , typename _Period >
TaskContext &	Schedule (std::chrono::duration< _Rep, _Period > const &time, TaskScheduler::task_handler_t const &task)
	Schedule an event with a fixed rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick. More...
template<typename _Rep , typename _Period >
TaskContext &	Schedule (std::chrono::duration< _Rep, _Period > const &time, TaskScheduler::group_t const group, TaskScheduler::task_handler_t const &task)
	Schedule an event with a fixed rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	Schedule (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max, TaskScheduler::task_handler_t const &task)
	Schedule an event with a randomized rate between min and max rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	Schedule (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max, TaskScheduler::group_t const group, TaskScheduler::task_handler_t const &task)
	Schedule an event with a randomized rate between min and max rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick. More...
TaskContext &	CancelAll ()
	Cancels all tasks from within the context. More...
TaskContext &	CancelGroup (TaskScheduler::group_t const group)
	Cancel all tasks of a single group from within the context. More...
TaskContext &	CancelGroupsOf (std::vector< TaskScheduler::group_t > const &groups)
	Cancels all groups in the given std::vector from within the context. Hint: Use std::initializer_list for this: "{1, 2, 3, 4}". More...
template<typename _Rep , typename _Period >
TaskContext &	DelayAll (std::chrono::duration< _Rep, _Period > const &duration)
	Delays all tasks with the given duration from within the context. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	DelayAll (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
	Delays all tasks with a random duration between min and max from within the context. More...
template<typename _Rep , typename _Period >
TaskContext &	DelayGroup (TaskScheduler::group_t const group, std::chrono::duration< _Rep, _Period > const &duration)
	Delays all tasks of a group with the given duration from within the context. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	DelayGroup (TaskScheduler::group_t const group, std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
	Delays all tasks of a group with a random duration between min and max from within the context. More...
template<typename _Rep , typename _Period >
TaskContext &	RescheduleAll (std::chrono::duration< _Rep, _Period > const &duration)
	Reschedule all tasks with the given duration. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	RescheduleAll (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
	Reschedule all tasks with a random duration between min and max. More...
template<typename _Rep , typename _Period >
TaskContext &	RescheduleGroup (TaskScheduler::group_t const group, std::chrono::duration< _Rep, _Period > const &duration)
	Reschedule all tasks of a group with the given duration. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskContext &	RescheduleGroup (TaskScheduler::group_t const group, std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
	Reschedule all tasks of a group with a random duration between min and max. More...

Private Member Functions
TaskContext &	Dispatch (std::function< TaskScheduler &(TaskScheduler &)> const &apply)
	Dispatches an action safe on the TaskScheduler. More...
TaskContext &	operator= (TaskContext const &right)
	TaskContext (TaskContext const &right)
void	ThrowOnConsumed () const
	Throws std::logic_error if the task was consumed already. More...
void	Invoke ()
	Invokes the associated hook of the task. More...

Private Attributes
TaskScheduler::TaskContainer	_task
	Associated task. More...
std::weak_ptr< TaskScheduler >	_owner
	Owner. More...
std::shared_ptr< bool >	_consumed
	Marks the task as consumed. More...

Friends
class	TaskScheduler

Constructor & Destructor Documentation

TaskContext() [1/4]

TaskContext::TaskContext ( TaskContext const &  right )

inlineprivate

    : _task(right._task), _owner(right._owner), _consumed(right._consumed) { }

TaskContext() [2/4]

TaskContext::TaskContext ( )

inline

    : _task(), _owner(), _consumed(std::make_shared<bool>(true)) { }

TaskContext() [3/4]

TaskContext::TaskContext ( TaskScheduler::TaskContainer &&  task, std::weak_ptr< TaskScheduler > &&  owner  )

inlineexplicit

    : _task(task), _owner(owner), _consumed(std::make_shared<bool>(false)) { }

TaskContext() [4/4]

TaskContext::TaskContext ( TaskContext &&  right )

inline

    : _task(std::move(right._task)), _owner(std::move(right._owner)),
    _consumed(std::move(right._consumed)) { }

Member Function Documentation

Async()

TaskContext & TaskContext::Async

(

std::function< void()> const &

callable

)

Schedule a callable function that is executed at the next update tick from within the context. Its safe to modify the TaskScheduler from within the callable.

{
    return Dispatch(std::bind(&TaskScheduler::Async, std::placeholders::_1, callable));
}

References TaskScheduler::Async(), and TaskScheduler::Dispatch().

Here is the call graph for this function:

CancelAll()

TaskContext & TaskContext::CancelAll

(

)

Cancels all tasks from within the context.

{
    return Dispatch(std::bind(&TaskScheduler::CancelAll, std::placeholders::_1));
}

References TaskScheduler::CancelAll(), and TaskScheduler::Dispatch().

Here is the call graph for this function:

CancelGroup()

TaskContext & TaskContext::CancelGroup

(

TaskScheduler::group_t const

group

)

Cancel all tasks of a single group from within the context.

{
    return Dispatch(std::bind(&TaskScheduler::CancelGroup, std::placeholders::_1, group));
}

References TaskScheduler::CancelGroup(), and TaskScheduler::Dispatch().

Here is the call graph for this function:

CancelGroupsOf()

TaskContext & TaskContext::CancelGroupsOf

(

std::vector< TaskScheduler::group_t > const &

groups

)

Cancels all groups in the given std::vector from within the context. Hint: Use std::initializer_list for this: "{1, 2, 3, 4}".

{
    return Dispatch(std::bind(&TaskScheduler::CancelGroupsOf, std::placeholders::_1, std::cref(groups)));
}

References TaskScheduler::CancelGroupsOf(), and TaskScheduler::Dispatch().

Here is the call graph for this function:

ClearGroup()

TaskContext & TaskContext::ClearGroup

(

)

Removes the group from the event.

{
    _task->_group = nullptr;
    return *this;
}

DelayAll() [1/2]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::DelayAll ( std::chrono::duration< _Rep, _Period > const &  duration )

inline

Delays all tasks with the given duration from within the context.

    {
        return Dispatch(std::bind(&TaskScheduler::DelayAll<_Rep, _Period>, std::placeholders::_1, duration));
    }

References Dispatch().

Referenced by DelayAll().

Here is the call graph for this function:

Here is the caller graph for this function:

DelayAll() [2/2]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::DelayAll ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inline

Delays all tasks with a random duration between min and max from within the context.

    {
        return DelayAll(TaskScheduler::RandomDurationBetween(min, max));
    }

References DelayAll(), and TaskScheduler::RandomDurationBetween().

Here is the call graph for this function:

DelayGroup() [1/2]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::DelayGroup ( TaskScheduler::group_t const  group, std::chrono::duration< _Rep, _Period > const &  duration  )

inline

Delays all tasks of a group with the given duration from within the context.

    {
        return Dispatch(std::bind(&TaskScheduler::DelayGroup<_Rep, _Period>, std::placeholders::_1, group, duration));
    }

References Dispatch().

Referenced by DelayGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

DelayGroup() [2/2]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::DelayGroup ( TaskScheduler::group_t const  group, std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inline

Delays all tasks of a group with a random duration between min and max from within the context.

    {
        return DelayGroup(group, TaskScheduler::RandomDurationBetween(min, max));
    }

References DelayGroup(), and TaskScheduler::RandomDurationBetween().

Here is the call graph for this function:

Dispatch()

TaskContext & TaskContext::Dispatch ( std::function< TaskScheduler &(TaskScheduler &)> const &  apply )

private

Dispatches an action safe on the TaskScheduler.

{
    if (auto const owner = _owner.lock())
        apply(*owner);
 
    return *this;
}

References ByteConverter::apply().

Referenced by DelayAll(), DelayGroup(), Repeat(), RescheduleAll(), RescheduleGroup(), and Schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

GetRepeatCounter()

TaskScheduler::repeated_t TaskContext::GetRepeatCounter

(

)

const

Returns the repeat counter which increases every time the task is repeated.

{
    return _task->_repeated;
}

Invoke()

void TaskContext::Invoke ( )

private

Invokes the associated hook of the task.

{
    _task->_task(*this);
}

Referenced by TaskScheduler::Dispatch().

Here is the caller graph for this function:

IsExpired()

bool TaskContext::IsExpired

(

)

const

Returns true if the owner was deallocated and this context has expired.

{
    return _owner.expired();
}

IsInGroup()

bool TaskContext::IsInGroup

(

TaskScheduler::group_t const

group

)

const

Returns true if the event is in the given group.

{
    return _task->IsInGroup(group);
}

operator=() [1/2]

TaskContext & TaskContext::operator= ( TaskContext &&  right )

inline

    {
        _task = std::move(right._task);
        _owner = std::move(right._owner);
        _consumed = std::move(right._consumed);
        return *this;
    }

References _consumed, _owner, and _task.

operator=() [2/2]

TaskContext & TaskContext::operator= ( TaskContext const &  right )

inlineprivate

    {
        _task = right._task;
        _owner = right._owner;
        _consumed = right._consumed;
        return *this;
    }

References _consumed, _owner, and _task.

Repeat() [1/3]

TaskContext & TaskContext::Repeat ( )

inline

Repeats the event with the same duration. This will consume the task context, its not possible to repeat the task again from the same task context!

    {
        ThrowOnConsumed();
 
        // Set new duration, in-context timing and increment repeat counter
        _task->_end += _task->_duration_calculator();
        _task->_repeated += 1;
        (*_consumed) = true;
        return Dispatch(std::bind(&TaskScheduler::InsertTask, std::placeholders::_1, std::cref(_task)));
    }

References _task, Dispatch(), TaskScheduler::InsertTask(), and ThrowOnConsumed().

Referenced by Repeat().

Here is the call graph for this function:

Here is the caller graph for this function:

Repeat() [2/3]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::Repeat ( std::chrono::duration< _Rep, _Period > const &  duration )

inline

Repeats the event and sets a new duration. std::chrono::seconds(5) for example. This will consume the task context, its not possible to repeat the task again from the same task context!

    {
        _task->_duration_calculator = TaskScheduler::MakeDurationCalculator(duration);
        return Repeat();
    }

References _task, TaskScheduler::MakeDurationCalculator(), and Repeat().

Referenced by Horizon::Zone::Unit::attack(), BOOST_AUTO_TEST_CASE(), Horizon::Zone::Units::Monster::initialize(), Horizon::Zone::ZoneKernel::initialize(), Horizon::Auth::AuthServer::initialize(), Horizon::Char::CharServer::initialize(), Horizon::Zone::Unit::status_effect_start(), and Horizon::Zone::Unit::walk().

Here is the call graph for this function:

Here is the caller graph for this function:

Repeat() [3/3]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::Repeat ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inline

Repeats the event and set a new duration that is randomized between min and max. std::chrono::seconds(5) for example. This will consume the task context, its not possible to repeat the task again from the same task context!

    {
        _task->_duration_calculator = TaskScheduler::MakeDurationCalculator(min, max);
        return Repeat();
    }

References _task, TaskScheduler::MakeDurationCalculator(), and Repeat().

Here is the call graph for this function:

RescheduleAll() [1/2]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::RescheduleAll ( std::chrono::duration< _Rep, _Period > const &  duration )

inline

Reschedule all tasks with the given duration.

    {
        return Dispatch(std::bind(&TaskScheduler::RescheduleAt, std::placeholders::_1, _task->_end + duration));
    }

References _task, Dispatch(), and TaskScheduler::RescheduleAt().

Referenced by RescheduleAll().

Here is the call graph for this function:

Here is the caller graph for this function:

RescheduleAll() [2/2]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::RescheduleAll ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inline

Reschedule all tasks with a random duration between min and max.

    {
        return RescheduleAll(TaskScheduler::RandomDurationBetween(min, max));
    }

References TaskScheduler::RandomDurationBetween(), and RescheduleAll().

Here is the call graph for this function:

RescheduleGroup() [1/2]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::RescheduleGroup ( TaskScheduler::group_t const  group, std::chrono::duration< _Rep, _Period > const &  duration  )

inline

Reschedule all tasks of a group with the given duration.

    {
        return Dispatch(std::bind(&TaskScheduler::RescheduleAtWithPredicate, std::placeholders::_1, _task->_end + duration,
                                  [&](TaskScheduler::TaskContainer const& task)
                                  {
                                      return task->IsInGroup(group);
                                  }));
    }

References _task, Dispatch(), and TaskScheduler::RescheduleAtWithPredicate().

Referenced by RescheduleGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

RescheduleGroup() [2/2]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::RescheduleGroup ( TaskScheduler::group_t const  group, std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inline

Reschedule all tasks of a group with a random duration between min and max.

    {
        return RescheduleGroup(group, TaskScheduler::RandomDurationBetween(min, max));
    }

References TaskScheduler::RandomDurationBetween(), and RescheduleGroup().

Here is the call graph for this function:

Schedule() [1/4]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::Schedule ( std::chrono::duration< _Rep, _Period > const &  time, TaskScheduler::group_t const  group, TaskScheduler::task_handler_t const &  task  )

inline

Schedule an event with a fixed rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick.

    {
        return Dispatch([&](TaskScheduler& scheduler) -> TaskScheduler&
                        {
                            return scheduler.ScheduleAt(_task->_end, TaskScheduler::MakeDurationCalculator(time), group, task);
                        });
    }

References _task, Dispatch(), TaskScheduler::MakeDurationCalculator(), and TaskScheduler::ScheduleAt().

Here is the call graph for this function:

Schedule() [2/4]

template<typename _Rep , typename _Period >

TaskContext & TaskContext::Schedule ( std::chrono::duration< _Rep, _Period > const &  time, TaskScheduler::task_handler_t const &  task  )

inline

Schedule an event with a fixed rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick.

    {
        return Dispatch([&](TaskScheduler& scheduler) -> TaskScheduler&
                        {
                            return scheduler.ScheduleAt(_task->_end, TaskScheduler::MakeDurationCalculator(time), task);
                        });
    }

References _task, Dispatch(), TaskScheduler::MakeDurationCalculator(), and TaskScheduler::ScheduleAt().

Here is the call graph for this function:

Schedule() [3/4]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::Schedule ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max, TaskScheduler::group_t const  group, TaskScheduler::task_handler_t const &  task  )

inline

Schedule an event with a randomized rate between min and max rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick.

    {
        return Dispatch([&](TaskScheduler& scheduler) -> TaskScheduler&
                        {
                            return scheduler.ScheduleAt(_task->_end, TaskScheduler::MakeDurationCalculator(min, max), group, task);
                        });
    }

References _task, Dispatch(), TaskScheduler::MakeDurationCalculator(), and TaskScheduler::ScheduleAt().

Here is the call graph for this function:

Schedule() [4/4]

template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >

TaskContext & TaskContext::Schedule ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max, TaskScheduler::task_handler_t const &  task  )

inline

Schedule an event with a randomized rate between min and max rate from within the context. Its possible that the new event is executed immediately! Use TaskScheduler::Async to create a task which will be called at the next update tick.

    {
        return Dispatch([&](TaskScheduler& scheduler) -> TaskScheduler&
                        {
                            return scheduler.ScheduleAt(_task->_end, TaskScheduler::MakeDurationCalculator(min, max), task);
                        });
    }

References _task, Dispatch(), TaskScheduler::MakeDurationCalculator(), and TaskScheduler::ScheduleAt().

Here is the call graph for this function:

SetGroup()

TaskContext & TaskContext::SetGroup

(

TaskScheduler::group_t const

group

)

Sets the event in the given group.

{
    _task->_group = TaskScheduler::MakeUnique<TaskScheduler::group_t>(group);
    return *this;
}

ThrowOnConsumed()

void TaskContext::ThrowOnConsumed ( ) const

private

Throws std::logic_error if the task was consumed already.

{
    // Catch multiple rescheduling caused through bad logic.
    if (*_consumed)
        throw std::logic_error("Bad task logic, task context was consumed already!");
}

Referenced by Repeat().

Here is the caller graph for this function:

Friends And Related Function Documentation

TaskScheduler

friend class TaskScheduler

friend

Member Data Documentation

_consumed

std::shared_ptr<bool> TaskContext::_consumed

private

Marks the task as consumed.

Referenced by operator=().

_owner

std::weak_ptr<TaskScheduler> TaskContext::_owner

private

Owner.

Referenced by operator=().

_task

TaskScheduler::TaskContainer TaskContext::_task

private

Associated task.

Referenced by operator=(), Repeat(), RescheduleAll(), RescheduleGroup(), and Schedule().

---

The documentation for this class was generated from the following files:

• src/Utility/TaskScheduler.hpp
• src/Utility/TaskScheduler.cpp