TaskContext Class Reference

#include <TaskScheduler.h>

Public Member Functions
	TaskContext ()
	TaskContext (TaskScheduler::TaskContainer &&task, std::weak_ptr< TaskScheduler > &&owner)
	TaskContext (TaskContext const &right)
	TaskContext (TaskContext &&right)
TaskContext &	operator= (TaskContext const &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<class _Rep , class _Period >
TaskContext &	Repeat (std::chrono::duration< _Rep, _Period > const &duration)
TaskContext &	Repeat ()
template<class _RepLeft , class _PeriodLeft , class _RepRight , class _PeriodRight >
TaskContext &	Repeat (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
TaskContext &	Async (std::function< void()> const &callable)
template<class _Rep , class _Period >
TaskContext &	Schedule (std::chrono::duration< _Rep, _Period > const &time, TaskScheduler::task_handler_t const &task)
template<class _Rep , class _Period >
TaskContext &	Schedule (std::chrono::duration< _Rep, _Period > const &time, TaskScheduler::group_t const group, TaskScheduler::task_handler_t const &task)
template<class _RepLeft , class _PeriodLeft , class _RepRight , class _PeriodRight >
TaskContext &	Schedule (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max, TaskScheduler::task_handler_t const &task)
template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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)
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)
template<class _Rep , class _Period >
TaskContext &	DelayAll (std::chrono::duration< _Rep, _Period > const &duration)
	Delays all tasks with the given duration from within the context. More...
template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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<class _Rep , class _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<class _RepLeft , class _PeriodLeft , class _RepRight , class _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<class _Rep , class _Period >
TaskContext &	RescheduleAll (std::chrono::duration< _Rep, _Period > const &duration)
	Reschedule all tasks with the given duration. More...
template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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<class _Rep , class _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<class _RepLeft , class _PeriodLeft , class _RepRight , class _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...
void	AssertOnConsumed () const
	Asserts 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::TaskContext ( )

inline

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

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

inlineexplicit

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

TaskContext::TaskContext ( TaskContext const &  right )

inline

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

TaskContext::TaskContext ( TaskContext &&  right )

inline

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

Member Function Documentation

void TaskContext::AssertOnConsumed ( ) const

private

Asserts if the task was consumed already.

{
 // This was adapted to TC to prevent static analysis tools from complaining.
 // If you encounter this assertion check if you repeat a TaskContext more then 1 time!
 ASSERT(!(*_consumed) && "Bad task logic, task context was consumed already!");
}

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));
}

Here is the call graph for this function:

TaskContext & TaskContext::CancelAll

(

)

Cancels all tasks from within the context.

{
 return Dispatch(std::mem_fn(&TaskScheduler::CancelAll));
}

Here is the call graph for this function:

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));
}

Here is the call graph for this function:

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)));
}

Here is the call graph for this function:

TaskContext & TaskContext::ClearGroup

(

)

Removes the group from the event.

{
 _task->_group = boost::none;
 return *this;
}

template<class _Rep , class _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));
 }

Here is the call graph for this function:

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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));
 }

Here is the call graph for this function:

template<class _Rep , class _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));
 }

Here is the call graph for this function:

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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));
 }

Here is the call graph for this function:

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;
}

Here is the call graph for this function:

TaskScheduler::repeated_t TaskContext::GetRepeatCounter

(

)

const

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

{
 return _task->_repeated;
}

Here is the caller graph for this function:

void TaskContext::Invoke ( )

private

Invokes the associated hook of the task.

{
 _task->_task(*this);
}

Here is the caller graph for this function:

bool TaskContext::IsExpired

(

)

const

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

{
 return _owner.expired();
}

bool TaskContext::IsInGroup

(

TaskScheduler::group_t const

group

)

const

Returns true if the event is in the given group.

{
 return _task->IsInGroup(group);
}

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

inline

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

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

inline

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

template<class _Rep , class _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!

 {
 AssertOnConsumed();

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

Here is the call graph for this function:

Here is the caller graph for this function:

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!

 {
 return Repeat(_task->_duration);
 }

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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!

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

Here is the call graph for this function:

template<class _Rep , class _Period >

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

inline

Reschedule all tasks with the given duration.

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

Here is the call graph for this function:

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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));
 }

Here is the call graph for this function:

template<class _Rep , class _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::RescheduleGroup<_Rep, _Period>, std::placeholders::_1, group, duration));
 }

Here is the call graph for this function:

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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));
 }

Here is the call graph for this function:

template<class _Rep , class _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.

 {
 auto const end = _task->_end;
 return Dispatch([end, time, task](TaskScheduler& scheduler) -> TaskScheduler&
 {
 return scheduler.ScheduleAt<_Rep, _Period>(end, time, task);
 });
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class _Rep , class _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.

 {
 auto const end = _task->_end;
 return Dispatch([end, time, group, task](TaskScheduler& scheduler) -> TaskScheduler&
 {
 return scheduler.ScheduleAt<_Rep, _Period>(end, time, group, task);
 });
 }

Here is the call graph for this function:

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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 Schedule(TaskScheduler::RandomDurationBetween(min, max), task);
 }

Here is the call graph for this function:

template<class _RepLeft , class _PeriodLeft , class _RepRight , class _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 Schedule(TaskScheduler::RandomDurationBetween(min, max), group, task);
 }

Here is the call graph for this function:

TaskContext & TaskContext::SetGroup

(

TaskScheduler::group_t const

group

)

Sets the event in the given group.

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

Friends And Related Function Documentation

friend class TaskScheduler

friend

Member Data Documentation

std::shared_ptr<bool> TaskContext::_consumed

private

Marks the task as consumed.

std::weak_ptr<TaskScheduler> TaskContext::_owner

private

Owner.

TaskScheduler::TaskContainer TaskContext::_task

private

Associated task.

---

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

• src/common/Utilities/TaskScheduler.h
• src/common/Utilities/TaskScheduler.cpp