TaskScheduler Class Reference

The TaskScheduler class provides the ability to schedule std::function's in the near future. Use TaskScheduler::Update to update the scheduler. Popular methods are: More...

#include <TaskScheduler.hpp>

Collaboration diagram for TaskScheduler:

Classes
struct	Compare
	Container which provides Task order, insert and reschedule operations. More...
class	Task
class	TaskQueue

Public Member Functions
	TaskScheduler ()
template<typename P >
	TaskScheduler (P &&predicate)
	TaskScheduler (TaskScheduler const &)=delete
	TaskScheduler (TaskScheduler &&)=delete
TaskScheduler &	operator= (TaskScheduler const &)=delete
TaskScheduler &	operator= (TaskScheduler &&)=delete
template<typename P >
TaskScheduler &	SetValidator (P &&predicate)
	Sets a Validator which is asked if tasks are allowed to be executed. More...
TaskScheduler &	ClearValidator ()
	Clears the Validator which is asked if tasks are allowed to be executed. More...
TaskScheduler &	Update (success_t const &callback=EmptyCallback)
	Update the scheduler to the current time. Calls the optional callback on successfully finish. More...
TaskScheduler &	Update (size_t const microseconds, success_t const &callback=EmptyCallback)
	Update the scheduler with a difftime in ms. Calls the optional callback on successfully finish. More...
template<typename _Rep , typename _Period >
TaskScheduler &	Update (std::chrono::duration< _Rep, _Period > const &difftime, success_t const &callback=EmptyCallback)
	Update the scheduler with a difftime. Calls the optional callback on successfully finish. More...
TaskScheduler &	Async (std::function< void()> const &callable)
	Schedule an callable function that is executed at the next update tick. Its safe to modify the TaskScheduler from within the callable. More...
template<typename _Rep , typename _Period >
TaskScheduler &	Schedule (std::chrono::duration< _Rep, _Period > const &time, task_handler_t const &task)
	Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::Schedule instead! More...
std::size_t	Count (group_t const &group)
template<typename _Rep , typename _Period >
TaskScheduler &	Schedule (std::chrono::duration< _Rep, _Period > const &time, group_t const group, task_handler_t const &task)
	Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::Schedule instead! More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskScheduler &	Schedule (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max, task_handler_t const &task)
	Schedule an event with a randomized rate between min and max rate. Never call this from within a task context! Use TaskContext::Schedule instead! More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskScheduler &	Schedule (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max, group_t const group, task_handler_t const &task)
	Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::Schedule instead! More...
TaskScheduler &	CancelAll ()
	Cancels all tasks. Never call this from within a task context! Use TaskContext::CancelAll instead! More...
TaskScheduler &	CancelGroup (group_t const group)
	Cancel all tasks of a single group. Never call this from within a task context! Use TaskContext::CancelGroup instead! More...
TaskScheduler &	CancelGroupsOf (std::vector< group_t > const &groups)
	Cancels all groups in the given std::vector. Hint: Use std::initializer_list for this: "{1, 2, 3, 4}". More...
template<typename _Rep , typename _Period >
TaskScheduler &	DelayAll (std::chrono::duration< _Rep, _Period > const &duration)
	Delays all tasks with the given duration. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskScheduler &	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. More...
template<typename _Rep , typename _Period >
TaskScheduler &	DelayGroup (group_t const group, std::chrono::duration< _Rep, _Period > const &duration)
	Delays all tasks of a group with the given duration. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskScheduler &	DelayGroup (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. More...
template<typename _Rep , typename _Period >
TaskScheduler &	RescheduleAll (std::chrono::duration< _Rep, _Period > const &duration)
	Reschedule all tasks with a given duration. More...
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
TaskScheduler &	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 >
TaskScheduler &	RescheduleGroup (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 >
TaskScheduler &	RescheduleGroup (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 Types
typedef std::chrono::system_clock	clock_t
typedef clock_t::time_point	timepoint_t
typedef std::function< clock_t::duration()>	duration_calculator_t
typedef uint64_t	group_t
typedef unsigned int	repeated_t
typedef std::function< void(TaskContext)>	task_handler_t
typedef std::function< bool()>	predicate_t
typedef std::function< void()>	success_t
typedef std::shared_ptr< Task >	TaskContainer
typedef std::queue< std::function< void()> >	AsyncHolder

Private Member Functions
TaskScheduler &	InsertTask (TaskContainer task)
	Insert a new task to the enqueued tasks. More...
TaskScheduler &	ScheduleAt (timepoint_t const &end, duration_calculator_t &&duration_calculator, task_handler_t const &task)
TaskScheduler &	ScheduleAt (timepoint_t const &end, duration_calculator_t &&duration_calculator, group_t const group, task_handler_t const &task)
	Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::schedule instead! More...
TaskScheduler &	RescheduleAt (timepoint_t const &end)
TaskScheduler &	RescheduleAtWithPredicate (timepoint_t const &end, std::function< bool(TaskContainer const &)> const &predicate)
	Reschedule all tasks with a given duration relative to the given time. More...
void	Dispatch (success_t const &callback)
	Dispatch remaining tasks when the given condition fits. More...

Static Private Member Functions
template<typename _Rep , typename _Period >
static duration_calculator_t	MakeDurationCalculator (std::chrono::duration< _Rep, _Period > const &duration)
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
static duration_calculator_t	MakeDurationCalculator (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)
template<typename T , typename... Args>
static std::unique_ptr< T >	MakeUnique (Args &&... args)
static bool	EmptyValidator ()
static void	EmptyCallback ()
static bool	AlwaysTruePredicate (TaskContainer const &)
template<typename _RepLeft , typename _PeriodLeft , typename _RepRight , typename _PeriodRight >
static std::chrono::duration< _RepLeft, _PeriodLeft >	RandomDurationBetween (std::chrono::duration< _RepLeft, _PeriodLeft > const &min, std::chrono::duration< _RepRight, _PeriodRight > const &max)

Private Attributes
std::shared_ptr< TaskScheduler >	self_reference
	Contains a self reference to track if this object was deleted or not. More...
timepoint_t	_now
	The current time point (now) More...
TaskQueue	_task_holder
	The Task Queue which contains all task objects. More...
AsyncHolder	_asyncHolder
	Contains all asynchronous tasks which will be invoked at the next update tick. More...
predicate_t	_predicate

Friends
class	TaskContext

Detailed Description

The TaskScheduler class provides the ability to schedule std::function's in the near future. Use TaskScheduler::Update to update the scheduler. Popular methods are:

• Schedule (Schedules a std::function which will be executed in the near future).
• Schedules an asynchronous function which will be executed at the next update tick.
• Cancel, Delay & Reschedule (Methods to manipulate already scheduled tasks). Tasks are organized in groups (uint), multiple tasks can have the same group id, you can provide a group or not, but keep in mind that you can only manipulate specific tasks through its group id! Tasks callbacks use the function signature void(TaskContext) where TaskContext provides access to the function schedule plan which makes it possible to repeat the task with the same duration or a new one. It also provides access to the repeat counter which is useful for task that repeat itself often but behave different every time (spoken event HLogs for example).

Member Typedef Documentation

AsyncHolder

typedef std::queue<std::function<void()> > TaskScheduler::AsyncHolder

private

clock_t

typedef std::chrono::system_clock TaskScheduler::clock_t

private

duration_calculator_t

typedef std::function<clock_t::duration()> TaskScheduler::duration_calculator_t

private

group_t

typedef uint64_t TaskScheduler::group_t

private

predicate_t

typedef std::function<bool()> TaskScheduler::predicate_t

private

repeated_t

typedef unsigned int TaskScheduler::repeated_t

private

success_t

typedef std::function<void()> TaskScheduler::success_t

private

task_handler_t

typedef std::function<void(TaskContext)> TaskScheduler::task_handler_t

private

TaskContainer

typedef std::shared_ptr<Task> TaskScheduler::TaskContainer

private

timepoint_t

typedef clock_t::time_point TaskScheduler::timepoint_t

private

Constructor & Destructor Documentation

TaskScheduler() [1/4]

TaskScheduler::TaskScheduler ( )

inline

    : self_reference(this, [](TaskScheduler const*) { }),
    _now(clock_t::now()), _predicate(EmptyValidator) { }

TaskScheduler() [2/4]

template<typename P >

TaskScheduler::TaskScheduler ( P &&  predicate )

inline

    : self_reference(this, [](TaskScheduler const*) { }),
    _now(clock_t::now()), _predicate(std::forward<P>(predicate)) { }

TaskScheduler() [3/4]

TaskScheduler::TaskScheduler ( TaskScheduler const &  )

delete

TaskScheduler() [4/4]

TaskScheduler::TaskScheduler ( TaskScheduler &&  )

delete

Member Function Documentation

AlwaysTruePredicate()

static bool TaskScheduler::AlwaysTruePredicate ( TaskContainer const &  )

inlinestaticprivate

    {
        return true;
    }

Referenced by RescheduleAt().

Here is the caller graph for this function:

Async()

TaskScheduler & TaskScheduler::Async

(

std::function< void()> const &

callable

)

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

{
    _asyncHolder.push(callable);
    return *this;
}

References _asyncHolder.

Referenced by TaskContext::Async().

Here is the caller graph for this function:

CancelAll()

TaskScheduler & TaskScheduler::CancelAll

(

)

Cancels all tasks. Never call this from within a task context! Use TaskContext::CancelAll instead!

Clear the task holder

{
    _task_holder.Clear();
    _asyncHolder = AsyncHolder();
    return *this;
}

References _asyncHolder, _task_holder, and TaskScheduler::TaskQueue::Clear().

Referenced by TaskContext::CancelAll(), Horizon::Zone::ZoneKernel::finalize(), Horizon::Auth::AuthServer::update(), and Horizon::Char::CharServer::update().

Here is the call graph for this function:

Here is the caller graph for this function:

CancelGroup()

TaskScheduler & TaskScheduler::CancelGroup

(

group_t const

group

)

Cancel all tasks of a single group. Never call this from within a task context! Use TaskContext::CancelGroup instead!

{
    _task_holder.RemoveIf(
        [group] (TaskContainer const &task) -> bool
        { return task->IsInGroup(group); });
    return *this;
}

References _task_holder, and TaskScheduler::TaskQueue::RemoveIf().

Referenced by TaskContext::CancelGroup(), and CancelGroupsOf().

Here is the call graph for this function:

Here is the caller graph for this function:

CancelGroupsOf()

TaskScheduler & TaskScheduler::CancelGroupsOf

(

std::vector< group_t > const &

groups

)

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

{
    std::for_each(groups.begin(), groups.end(),
                  std::bind(&TaskScheduler::CancelGroup, this, std::placeholders::_1));
 
    return *this;
}

References CancelGroup().

Referenced by TaskContext::CancelGroupsOf().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearValidator()

TaskScheduler & TaskScheduler::ClearValidator

(

)

Clears the Validator which is asked if tasks are allowed to be executed.

Copyright 2014-2015 Denis Blank denis.nosp@m..bla.nosp@m.nk@ou.nosp@m.tloo.nosp@m.k.com

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

{
    _predicate = EmptyValidator;
    return *this;
}

References _predicate, and EmptyValidator().

Here is the call graph for this function:

Count()

std::size_t TaskScheduler::Count

(

group_t const &

group

)

{
    return _task_holder.Count(group);
}

References _task_holder, and TaskScheduler::TaskQueue::Count().

Here is the call graph for this function:

DelayAll() [1/2]

template<typename _Rep , typename _Period >

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

inline

Delays all tasks with the given duration.

    {
        _task_holder.ModifyIf([&duration](TaskContainer const& task) -> bool
                              {
                                  task->_end += duration;
                                  return true;
                              });
        return *this;
    }

References _task_holder, and TaskScheduler::TaskQueue::ModifyIf().

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 >

TaskScheduler & TaskScheduler::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.

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

References DelayAll(), and RandomDurationBetween().

Here is the call graph for this function:

DelayGroup() [1/2]

template<typename _Rep , typename _Period >

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

inline

Delays all tasks of a group with the given duration.

    {
        _task_holder.ModifyIf([&duration, group](TaskContainer const& task) -> bool
                              {
                                  if (task->IsInGroup(group))
                                  {
                                      task->_end += duration;
                                      return true;
                                  }
                                  else
                                      return false;
                              });
        return *this;
    }

References _task_holder, and TaskScheduler::TaskQueue::ModifyIf().

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 >

TaskScheduler & TaskScheduler::DelayGroup ( 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.

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

References DelayGroup(), and RandomDurationBetween().

Here is the call graph for this function:

Dispatch()

void TaskScheduler::Dispatch ( success_t const &  callback )

private

Dispatch remaining tasks when the given condition fits.

{
    // If the validation failed abort the dispatching here.
    if (!_predicate())
        return;
 
    // Process all asyncs
    while (!_asyncHolder.empty())
    {
        _asyncHolder.front()();
        _asyncHolder.pop();
 
        // If the validation failed abort the dispatching here.
        if (!_predicate())
            return;
    }
 
    while (!_task_holder.IsEmpty())
    {
        if (_task_holder.First()->_end > _now)
            break;
 
        // Perfect forward the context to the handler
        // Use weak references to catch destruction before callbacks.
        TaskContext context(_task_holder.Pop(), std::weak_ptr<TaskScheduler>(self_reference));
 
        // Invoke the context
        context.Invoke();
 
        // If the validation failed abort the dispatching here.
        if (!_predicate())
            return;
    }
 
    // On finish call the final callback
    callback();
}

References _asyncHolder, _now, _predicate, _task_holder, TaskScheduler::TaskQueue::First(), TaskContext::Invoke(), TaskScheduler::TaskQueue::IsEmpty(), TaskScheduler::TaskQueue::Pop(), and self_reference.

Referenced by TaskContext::Async(), TaskContext::CancelAll(), TaskContext::CancelGroup(), TaskContext::CancelGroupsOf(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

EmptyCallback()

static void TaskScheduler::EmptyCallback ( )

inlinestaticprivate

    {
    }

EmptyValidator()

static bool TaskScheduler::EmptyValidator ( )

inlinestaticprivate

    {
        return true;
    }

Referenced by ClearValidator().

Here is the caller graph for this function:

InsertTask()

TaskScheduler & TaskScheduler::InsertTask ( TaskContainer  task )

private

Insert a new task to the enqueued tasks.

{
    _task_holder.Push(std::move(task));
    return *this;
}

References _task_holder, and TaskScheduler::TaskQueue::Push().

Referenced by TaskContext::Repeat(), and ScheduleAt().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeDurationCalculator() [1/2]

template<typename _Rep , typename _Period >

static duration_calculator_t TaskScheduler::MakeDurationCalculator ( std::chrono::duration< _Rep, _Period > const &  duration )

inlinestaticprivate

    {
        return [duration]
        {
            return duration;
        };
    }

Referenced by TaskContext::Repeat(), Schedule(), and TaskContext::Schedule().

Here is the caller graph for this function:

MakeDurationCalculator() [2/2]

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

static duration_calculator_t TaskScheduler::MakeDurationCalculator ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inlinestaticprivate

    {
        return std::bind(RandomDurationBetween<_RepLeft, _PeriodLeft, _RepRight, _PeriodRight>, min, max);
    }

MakeUnique()

template<typename T , typename... Args>

static std::unique_ptr< T > TaskScheduler::MakeUnique ( Args &&...  args )

inlinestaticprivate

    {
        return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
    }

operator=() [1/2]

TaskScheduler & TaskScheduler::operator= ( TaskScheduler &&  )

delete

operator=() [2/2]

TaskScheduler & TaskScheduler::operator= ( TaskScheduler const &  )

delete

RandomDurationBetween()

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

static std::chrono::duration< _RepLeft, _PeriodLeft > TaskScheduler::RandomDurationBetween ( std::chrono::duration< _RepLeft, _PeriodLeft > const &  min, std::chrono::duration< _RepRight, _PeriodRight > const &  max  )

inlinestaticprivate

    {
        if (!min.count() && !max.count())
            return std::chrono::duration<_RepLeft, _PeriodLeft>(0);
 
        using normalized_t = std::chrono::duration<_RepLeft, _PeriodLeft>;
        auto normalized = std::chrono::duration_cast<normalized_t>(max);
 
        if (min.count() > normalized.count())
            throw std::logic_error("min > max");
 
        static std::mutex _lock;
        std::lock_guard<std::mutex> guard(_lock);
 
        // Random engine
        static std::random_device rd;
        static std::mt19937 rng(rd());
 
        std::uniform_int_distribution<typename std::chrono::duration<_RepLeft, _PeriodLeft>::rep>
        _distribution(min.count(), normalized.count());
 
        // Distribute
        return std::chrono::duration<_RepLeft, _PeriodLeft>(_distribution(rng));
    }

Referenced by DelayAll(), TaskContext::DelayAll(), DelayGroup(), TaskContext::DelayGroup(), RescheduleAll(), TaskContext::RescheduleAll(), RescheduleGroup(), and TaskContext::RescheduleGroup().

Here is the caller graph for this function:

RescheduleAll() [1/2]

template<typename _Rep , typename _Period >

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

inline

Reschedule all tasks with a given duration.

    {
        return RescheduleAt(_now + duration);
    }

References _now, and 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 >

TaskScheduler & TaskScheduler::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(RandomDurationBetween(min, max));
    }

References RandomDurationBetween(), and RescheduleAll().

Here is the call graph for this function:

RescheduleAt()

TaskScheduler & TaskScheduler::RescheduleAt ( timepoint_t const &  end )

inlineprivate

    {
        return RescheduleAtWithPredicate(end, AlwaysTruePredicate);
    }

References AlwaysTruePredicate(), and RescheduleAtWithPredicate().

Referenced by RescheduleAll(), and TaskContext::RescheduleAll().

Here is the call graph for this function:

Here is the caller graph for this function:

RescheduleAtWithPredicate()

TaskScheduler & TaskScheduler::RescheduleAtWithPredicate ( timepoint_t const &  end, std::function< bool(TaskContainer const &)> const &  predicate  )

inlineprivate

Reschedule all tasks with a given duration relative to the given time.

    {
        _task_holder.ModifyIf([&](TaskContainer const& task) -> bool
                              {
                                  if (predicate(task))
                                  {
                                      task->_end = end;
                                      return true;
                                  }
                                  else
                                      return false;
                              });
        return *this;
    }

References _task_holder, and TaskScheduler::TaskQueue::ModifyIf().

Referenced by RescheduleAt(), RescheduleGroup(), and TaskContext::RescheduleGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

RescheduleGroup() [1/2]

template<typename _Rep , typename _Period >

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

inline

Reschedule all tasks of a group with the given duration.

    {
        return RescheduleAtWithPredicate(_now + duration, [&](TaskContainer const& task)
                                         {
                                             return task->IsInGroup(group);
                                         });
    }

References _now, and 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 >

TaskScheduler & TaskScheduler::RescheduleGroup ( 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, RandomDurationBetween(min, max));
    }

References RandomDurationBetween(), and RescheduleGroup().

Here is the call graph for this function:

Schedule() [1/4]

template<typename _Rep , typename _Period >

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

inline

Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::Schedule instead!

    {
        return ScheduleAt(_now, MakeDurationCalculator(time), group, task);
    }

References _now, MakeDurationCalculator(), and ScheduleAt().

Here is the call graph for this function:

Schedule() [2/4]

template<typename _Rep , typename _Period >

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

inline

Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::Schedule instead!

    {
        return ScheduleAt(_now, MakeDurationCalculator(time), task);
    }

References _now, MakeDurationCalculator(), and ScheduleAt().

Referenced by BOOST_AUTO_TEST_CASE(), Horizon::Zone::ZoneKernel::initialize(), Horizon::Auth::AuthServer::initialize(), Horizon::Char::CharServer::initialize(), and Horizon::Zone::ScriptManager::initialize_basic_state().

Here is the call graph for this function:

Here is the caller graph for this function:

Schedule() [3/4]

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

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

inline

Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::Schedule instead!

    {
        return ScheduleAt(_now, MakeDurationCalculator(min, max), group, task);
    }

References _now, MakeDurationCalculator(), and ScheduleAt().

Here is the call graph for this function:

Schedule() [4/4]

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

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

inline

Schedule an event with a randomized rate between min and max rate. Never call this from within a task context! Use TaskContext::Schedule instead!

    {
        return ScheduleAt(_now, MakeDurationCalculator(min, max), task);
    }

References _now, MakeDurationCalculator(), and ScheduleAt().

Here is the call graph for this function:

ScheduleAt() [1/2]

TaskScheduler & TaskScheduler::ScheduleAt ( timepoint_t const &  end, duration_calculator_t &&  duration_calculator, group_t const  group, task_handler_t const &  task  )

inlineprivate

Schedule an event with a fixed rate. Never call this from within a task context! Use TaskContext::schedule instead!

    {
        // FIXME Reuse std::unique_ptr
        static repeated_t const DEFAULT_REPEATED = 0;
        return InsertTask(TaskContainer(new Task(end + duration_calculator(), std::move(duration_calculator), group, DEFAULT_REPEATED, task)));
    }

References InsertTask().

Here is the call graph for this function:

ScheduleAt() [2/2]

TaskScheduler & TaskScheduler::ScheduleAt ( timepoint_t const &  end, duration_calculator_t &&  duration_calculator, task_handler_t const &  task  )

inlineprivate

    {
        return InsertTask(TaskContainer(new Task(end + duration_calculator(), std::move(duration_calculator), task)));
    }

References InsertTask().

Referenced by Schedule(), and TaskContext::Schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

SetValidator()

template<typename P >

TaskScheduler & TaskScheduler::SetValidator ( P &&  predicate )

inline

Sets a Validator which is asked if tasks are allowed to be executed.

    {
        _predicate = std::forward<P>(predicate);
        return *this;
    }

References _predicate.

Update() [1/3]

TaskScheduler & TaskScheduler::Update	(	size_t const	microseconds,
		success_t const &	callback = EmptyCallback
	)

Update the scheduler with a difftime in ms. Calls the optional callback on successfully finish.

{
    return Update(std::chrono::microseconds(microseconds), callback);
}

References Update().

Here is the call graph for this function:

Update() [2/3]

template<typename _Rep , typename _Period >

TaskScheduler & TaskScheduler::Update ( std::chrono::duration< _Rep, _Period > const &  difftime, success_t const &  callback = EmptyCallback  )

inline

Update the scheduler with a difftime. Calls the optional callback on successfully finish.

    {
        _now += difftime;
        Dispatch(callback);
        return *this;
    }

References _now, and Dispatch().

Here is the call graph for this function:

Update() [3/3]

TaskScheduler & TaskScheduler::Update

(

success_t const &

callback = EmptyCallback

)

Update the scheduler to the current time. Calls the optional callback on successfully finish.

{
    _now = clock_t::now();
    Dispatch(callback);
    return *this;
}

References _now, and Dispatch().

Referenced by BOOST_AUTO_TEST_CASE(), Horizon::Zone::ZoneServer::update(), Update(), Horizon::Zone::GameLogicProcess::update(), Horizon::Zone::ScriptManager::update(), Horizon::Auth::AuthServer::update(), and Horizon::Char::CharServer::update().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

TaskContext

friend class TaskContext

friend

Member Data Documentation

_asyncHolder

AsyncHolder TaskScheduler::_asyncHolder

private

Contains all asynchronous tasks which will be invoked at the next update tick.

Referenced by Async(), CancelAll(), and Dispatch().

_now

timepoint_t TaskScheduler::_now

private

The current time point (now)

Referenced by Dispatch(), RescheduleAll(), RescheduleGroup(), Schedule(), and Update().

_predicate

predicate_t TaskScheduler::_predicate

private

Referenced by ClearValidator(), Dispatch(), and SetValidator().

_task_holder

TaskQueue TaskScheduler::_task_holder

private

The Task Queue which contains all task objects.

Referenced by CancelAll(), CancelGroup(), Count(), DelayAll(), DelayGroup(), Dispatch(), InsertTask(), and RescheduleAtWithPredicate().

self_reference

std::shared_ptr<TaskScheduler> TaskScheduler::self_reference

private

Contains a self reference to track if this object was deleted or not.

Referenced by Dispatch().

---

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

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