TaskScheduler.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _TASK_SCHEDULER_H_
#define _TASK_SCHEDULER_H_

#include <algorithm>
#include <chrono>
#include <vector>
#include <queue>
#include <memory>
#include <utility>
#include <set>

#include <boost/optional.hpp>

#include "Util.h"
#include "Duration.h"

class TaskContext;

class TC_COMMON_API TaskScheduler
{
 friend class TaskContext;

 // Time definitions (use steady clock)
 typedef std::chrono::steady_clock clock_t;
 typedef clock_t::time_point timepoint_t;
 typedef clock_t::duration duration_t;

 // Task group type
 typedef uint32 group_t;
 // Task repeated type
 typedef uint32 repeated_t;
 // Task handle type
 typedef std::function<void(TaskContext)> task_handler_t;
 // Predicate type
 typedef std::function<bool()> predicate_t;
 // Success handle type
 typedef std::function<void()> success_t;

 class Task
 {
 friend class TaskContext;
 friend class TaskScheduler;

 timepoint_t _end;
 duration_t _duration;
 boost::optional<group_t> _group;
 repeated_t _repeated;
 task_handler_t _task;

 public:
 // All Argument construct
 Task(timepoint_t const& end, duration_t const& duration, boost::optional<group_t> const& group,
 repeated_t const repeated, task_handler_t const& task)
 : _end(end), _duration(duration), _group(group), _repeated(repeated), _task(task) { }

 // Minimal Argument construct
 Task(timepoint_t const& end, duration_t const& duration, task_handler_t const& task)
 : _end(end), _duration(duration), _group(boost::none), _repeated(0), _task(task) { }

 // Copy construct
 Task(Task const&) = delete;
 // Move construct
 Task(Task&&) = delete;
 // Copy Assign
 Task& operator= (Task const&) = default;
 // Move Assign
 Task& operator= (Task&& right) = delete;

 // Order tasks by its end
 inline bool operator< (Task const& other) const
 {
 return _end < other._end;
 }

 inline bool operator> (Task const& other) const
 {
 return _end > other._end;
 }

 // Compare tasks with its end
 inline bool operator== (Task const& other)
 {
 return _end == other._end;
 }

 // Returns true if the task is in the given group
 inline bool IsInGroup(group_t const group) const
 {
 return _group == group;
 }
 };

 typedef std::shared_ptr<Task> TaskContainer;

 struct Compare
 {
 bool operator() (TaskContainer const& left, TaskContainer const& right)
 {
 return (*left.get()) < (*right.get());
 };
 };

 class TC_COMMON_API TaskQueue
 {
 std::multiset<TaskContainer, Compare> container;

 public:
 // Pushes the task in the container
 void Push(TaskContainer&& task);

 TaskContainer Pop();

 TaskContainer const& First() const;

 void Clear();

 void RemoveIf(std::function<bool(TaskContainer const&)> const& filter);

 void ModifyIf(std::function<bool(TaskContainer const&)> const& filter);

 bool IsEmpty() const;
 };

 std::shared_ptr<TaskScheduler> self_reference;

 timepoint_t _now;

 TaskQueue _task_holder;

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

 AsyncHolder _asyncHolder;

 predicate_t _predicate;

 static bool EmptyValidator()
 {
 return true;
 }

 static void EmptyCallback()
 {
 }

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

 template<typename P>
 TaskScheduler(P&& predicate)
 : self_reference(this, [](TaskScheduler const*) { }), _now(clock_t::now()), _predicate(std::forward<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)
 {
 _predicate = std::forward<P>(predicate);
 return *this;
 }

 TaskScheduler& ClearValidator();

 TaskScheduler& Update(success_t const& callback = EmptyCallback);

 TaskScheduler& Update(size_t const milliseconds, success_t const& callback = EmptyCallback);

 template<class _Rep, class _Period>
 TaskScheduler& Update(std::chrono::duration<_Rep, _Period> const& difftime,
 success_t const& callback = EmptyCallback)
 {
 _now += difftime;
 Dispatch(callback);
 return *this;
 }

 TaskScheduler& Async(std::function<void()> const& callable);

 template<class _Rep, class _Period>
 TaskScheduler& Schedule(std::chrono::duration<_Rep, _Period> const& time,
 task_handler_t const& task)
 {
 return ScheduleAt(_now, time, task);
 }

 template<class _Rep, class _Period>
 TaskScheduler& Schedule(std::chrono::duration<_Rep, _Period> const& time,
 group_t const group, task_handler_t const& task)
 {
 return ScheduleAt(_now, time, group, task);
 }

 template<class _RepLeft, class _PeriodLeft, class _RepRight, class _PeriodRight>
 TaskScheduler& Schedule(std::chrono::duration<_RepLeft, _PeriodLeft> const& min,
 std::chrono::duration<_RepRight, _PeriodRight> const& max, task_handler_t const& task)
 {
 return Schedule(RandomDurationBetween(min, max), task);
 }

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

 TaskScheduler& CancelAll();

 TaskScheduler& CancelGroup(group_t const group);

 TaskScheduler& CancelGroupsOf(std::vector<group_t> const& groups);

 template<class _Rep, class _Period>
 TaskScheduler& DelayAll(std::chrono::duration<_Rep, _Period> const& duration)
 {
 _task_holder.ModifyIf([&duration](TaskContainer const& task) -> bool
 {
 task->_end += duration;
 return true;
 });
 return *this;
 }

 template<class _RepLeft, class _PeriodLeft, class _RepRight, class _PeriodRight>
 TaskScheduler& DelayAll(std::chrono::duration<_RepLeft, _PeriodLeft> const& min,
 std::chrono::duration<_RepRight, _PeriodRight> const& max)
 {
 return DelayAll(RandomDurationBetween(min, max));
 }

 template<class _Rep, class _Period>
 TaskScheduler& DelayGroup(group_t const group, std::chrono::duration<_Rep, _Period> const& duration)
 {
 _task_holder.ModifyIf([&duration, group](TaskContainer const& task) -> bool
 {
 if (task->IsInGroup(group))
 {
 task->_end += duration;
 return true;
 }
 else
 return false;
 });
 return *this;
 }

 template<class _RepLeft, class _PeriodLeft, class _RepRight, class _PeriodRight>
 TaskScheduler& DelayGroup(group_t const group,
 std::chrono::duration<_RepLeft, _PeriodLeft> const& min,
 std::chrono::duration<_RepRight, _PeriodRight> const& max)
 {
 return DelayGroup(group, RandomDurationBetween(min, max));
 }

 template<class _Rep, class _Period>
 TaskScheduler& RescheduleAll(std::chrono::duration<_Rep, _Period> const& duration)
 {
 auto const end = _now + duration;
 _task_holder.ModifyIf([end](TaskContainer const& task) -> bool
 {
 task->_end = end;
 return true;
 });
 return *this;
 }

 template<class _RepLeft, class _PeriodLeft, class _RepRight, class _PeriodRight>
 TaskScheduler& RescheduleAll(std::chrono::duration<_RepLeft, _PeriodLeft> const& min,
 std::chrono::duration<_RepRight, _PeriodRight> const& max)
 {
 return RescheduleAll(RandomDurationBetween(min, max));
 }

 template<class _Rep, class _Period>
 TaskScheduler& RescheduleGroup(group_t const group, std::chrono::duration<_Rep, _Period> const& duration)
 {
 auto const end = _now + duration;
 _task_holder.ModifyIf([end, group](TaskContainer const& task) -> bool
 {
 if (task->IsInGroup(group))
 {
 task->_end = end;
 return true;
 }
 else
 return false;
 });
 return *this;
 }

 template<class _RepLeft, class _PeriodLeft, class _RepRight, class _PeriodRight>
 TaskScheduler& RescheduleGroup(group_t const group,
 std::chrono::duration<_RepLeft, _PeriodLeft> const& min,
 std::chrono::duration<_RepRight, _PeriodRight> const& max)
 {
 return RescheduleGroup(group, RandomDurationBetween(min, max));
 }

private:
 TaskScheduler& InsertTask(TaskContainer task);

 template<class _Rep, class _Period>
 TaskScheduler& ScheduleAt(timepoint_t const& end,
 std::chrono::duration<_Rep, _Period> const& time, task_handler_t const& task)
 {
 return InsertTask(TaskContainer(new Task(end + time, time, task)));
 }

 template<class _Rep, class _Period>
 TaskScheduler& ScheduleAt(timepoint_t const& end,
 std::chrono::duration<_Rep, _Period> const& time,
 group_t const group, task_handler_t const& task)
 {
 static repeated_t const DEFAULT_REPEATED = 0;
 return InsertTask(TaskContainer(new Task(end + time, time, group, DEFAULT_REPEATED, task)));
 }

 // Returns a random duration between min and max
 template<class _RepLeft, class _PeriodLeft, class _RepRight, class _PeriodRight>
 static std::chrono::milliseconds
 RandomDurationBetween(std::chrono::duration<_RepLeft, _PeriodLeft> const& min,
 std::chrono::duration<_RepRight, _PeriodRight> const& max)
 {
 auto const milli_min = std::chrono::duration_cast<std::chrono::milliseconds>(min);
 auto const milli_max = std::chrono::duration_cast<std::chrono::milliseconds>(max);

 // TC specific: use SFMT URandom
 return std::chrono::milliseconds(urand(uint32(milli_min.count()), uint32(milli_max.count())));
 }

 void Dispatch(success_t const& callback);
};

class TC_COMMON_API TaskContext
{
 friend class TaskScheduler;

 TaskScheduler::TaskContainer _task;

 std::weak_ptr<TaskScheduler> _owner;

 std::shared_ptr<bool> _consumed;

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

public:
 // Empty constructor
 TaskContext()
 : _task(), _owner(), _consumed(std::make_shared<bool>(true)) { }

 // Construct from task and owner
 explicit TaskContext(TaskScheduler::TaskContainer&& task, std::weak_ptr<TaskScheduler>&& owner)
 : _task(task), _owner(owner), _consumed(std::make_shared<bool>(false)) { }

 // Copy construct
 TaskContext(TaskContext const& right)
 : _task(right._task), _owner(right._owner), _consumed(right._consumed) { }

 // Move construct
 TaskContext(TaskContext&& right)
 : _task(std::move(right._task)), _owner(std::move(right._owner)), _consumed(std::move(right._consumed)) { }

 // Copy assign
 TaskContext& operator= (TaskContext const& right)
 {
 _task = right._task;
 _owner = right._owner;
 _consumed = right._consumed;
 return *this;
 }

 // Move assign
 TaskContext& operator= (TaskContext&& right)
 {
 _task = std::move(right._task);
 _owner = std::move(right._owner);
 _consumed = std::move(right._consumed);
 return *this;
 }

 bool IsExpired() const;

 bool IsInGroup(TaskScheduler::group_t const group) const;

 TaskContext& SetGroup(TaskScheduler::group_t const group);

 TaskContext& ClearGroup();

 TaskScheduler::repeated_t GetRepeatCounter() const;

 template<class _Rep, class _Period>
 TaskContext& Repeat(std::chrono::duration<_Rep, _Period> const& duration)
 {
 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));
 }

 TaskContext& Repeat()
 {
 return Repeat(_task->_duration);
 }

 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)
 {
 return Repeat(TaskScheduler::RandomDurationBetween(min, 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)
 {
 auto const end = _task->_end;
 return Dispatch([end, time, task](TaskScheduler& scheduler) -> TaskScheduler&
 {
 return scheduler.ScheduleAt<_Rep, _Period>(end, time, 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)
 {
 auto const end = _task->_end;
 return Dispatch([end, time, group, task](TaskScheduler& scheduler) -> TaskScheduler&
 {
 return scheduler.ScheduleAt<_Rep, _Period>(end, time, group, 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)
 {
 return Schedule(TaskScheduler::RandomDurationBetween(min, max), 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)
 {
 return Schedule(TaskScheduler::RandomDurationBetween(min, max), group, task);
 }

 TaskContext& CancelAll();

 TaskContext& CancelGroup(TaskScheduler::group_t const group);

 TaskContext& CancelGroupsOf(std::vector<TaskScheduler::group_t> const& groups);

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

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

 template<class _Rep, class _Period>
 TaskContext& DelayGroup(TaskScheduler::group_t const group, std::chrono::duration<_Rep, _Period> const& duration)
 {
 return Dispatch(std::bind(&TaskScheduler::DelayGroup<_Rep, _Period>, std::placeholders::_1, group, duration));
 }

 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)
 {
 return DelayGroup(group, TaskScheduler::RandomDurationBetween(min, max));
 }

 template<class _Rep, class _Period>
 TaskContext& RescheduleAll(std::chrono::duration<_Rep, _Period> const& duration)
 {
 return Dispatch(std::bind(&TaskScheduler::RescheduleAll, std::placeholders::_1, duration));
 }

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

 template<class _Rep, class _Period>
 TaskContext& RescheduleGroup(TaskScheduler::group_t const group, std::chrono::duration<_Rep, _Period> const& duration)
 {
 return Dispatch(std::bind(&TaskScheduler::RescheduleGroup<_Rep, _Period>, std::placeholders::_1, group, duration));
 }

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

private:
 void AssertOnConsumed() const;

 void Invoke();
};

#endif