TaskScheduler.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * 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 TRINITYCORE_TASK_SCHEDULER_H
#define TRINITYCORE_TASK_SCHEDULER_H
 
#include "Duration.h"
#include "Optional.h"
#include "Random.h"
#include "Types.h"
#include <algorithm>
#include <functional>
#include <memory>
#include <set>
#include <span>
#include <utility>
#include <variant>
 
class TaskContext;
 
class TC_COMMON_API TaskScheduler
{
    friend class TaskContext;
 
    class TaskHandler;
 
    // 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 handler type
    typedef TaskHandler task_handler_t;
    // Predicate type
    typedef std::function<bool()> predicate_t;
    // Success handle type
    typedef std::function<void()> success_t;
 
    // Task handler function wrapper designed to support both TaskContext& and TaskContext arguments
    class TaskHandler
    {
    public:
        template <typename InnerHandler> requires (!std::same_as<InnerHandler, TaskHandler>)
        TaskHandler(InnerHandler&& handler) : _handler(TaskHandler::Wrap(std::forward<InnerHandler>(handler))) { }
 
        void operator()(TaskContext& context) const { _handler(context); }
 
    private:
        template <typename InnerHandler>
        static decltype(auto) Wrap(InnerHandler&& handler)
        {
            if constexpr (std::invocable<InnerHandler, TaskContext&>)
            {
                return std::forward<InnerHandler>(handler);
            }
            else if constexpr (std::invocable<InnerHandler, TaskContext&&>)
            {
                // support legacy signature
                return [inner = std::forward<InnerHandler>(handler)](TaskContext& context)
                {
                    inner(static_cast<TaskContext&&>(context));
                };
            }
            else
            {
                static_assert(Trinity::dependant_false_v<InnerHandler>, "Unsupported task argument type, must be TaskContext& or TaskContext const&");
            }
        }
 
        std::function<void(TaskContext&)> _handler;
    };
 
    class Task
    {
        friend class TaskContext;
        friend class TaskScheduler;
 
        timepoint_t _end;
        duration_t _duration;
        Optional<group_t> _group;
        repeated_t _repeated;
        task_handler_t _task;
 
    public:
        // All Argument construct
        Task(timepoint_t end, duration_t duration, Optional<group_t> group,
            repeated_t const repeated, task_handler_t task)
                : _end(end), _duration(duration), _group(group), _repeated(repeated), _task(std::move(task)) { }
 
        // Minimal Argument construct
        Task(timepoint_t end, duration_t duration, task_handler_t task)
            : _end(end), _duration(duration), _group(std::nullopt), _repeated(0), _task(std::move(task)) { }
 
        // Copy construct
        Task(Task const&) = delete;
        // Move construct
        Task(Task&&) = delete;
        // Copy Assign
        Task& operator= (Task const&) = delete;
        // Move Assign
        Task& operator= (Task&& right) = delete;
 
        ~Task() = default;
 
        // Order tasks by its end
        std::weak_ordering operator<=> (Task const& other) const
        {
            return std::compare_weak_order_fallback(_end, other._end);
        }
 
        // Compare tasks with its end
        bool operator== (Task const& other) const
        {
            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) const
        {
            return (*left.get()) < (*right.get());
        }
    };
 
    class TC_COMMON_API TaskQueue
    {
    public:
        typedef std::multiset<TaskContainer, Compare> Container;
 
    private:
        Container container;
 
    public:
        // Pushes the task in the container
        void Push(TaskContainer&& task);
 
        // Pushes the task in the container
        void Push(Container::node_type&& node);
 
        Container::node_type 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;
 
    predicate_t _predicate;
 
    static bool EmptyValidator()
    {
        return true;
    }
 
public:
    TaskScheduler();
 
    template<typename P>
    explicit 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;
 
    ~TaskScheduler();
 
    template<typename P>
    TaskScheduler& SetValidator(P&& predicate)
    {
        _predicate = std::forward<P>(predicate);
        return *this;
    }
 
    TaskScheduler& ClearValidator();
 
    static success_t const EmptySuccessCallback;
 
    TaskScheduler& Update();
 
    TaskScheduler& Update(success_t callback);
 
    TaskScheduler& Update(size_t milliseconds);
 
    TaskScheduler& Update(size_t milliseconds, success_t callback);
 
    TaskScheduler& Update(duration_t difftime);
 
    TaskScheduler& Update(duration_t difftime, success_t callback);
 
    TaskScheduler& Async(std::function<void()> callable);
 
    TaskScheduler& Schedule(duration_t time,
        task_handler_t task)
    {
        return this->ScheduleAt(_now, time, std::move(task));
    }
 
    TaskScheduler& Schedule(duration_t time,
        group_t group, task_handler_t task)
    {
        return this->ScheduleAt(_now, time, group, std::move(task));
    }
 
    TaskScheduler& Schedule(std::chrono::milliseconds min,
        std::chrono::milliseconds max, task_handler_t task)
    {
        return this->Schedule(::randtime(min, max), std::move(task));
    }
 
    TaskScheduler& Schedule(std::chrono::milliseconds min,
        std::chrono::milliseconds max, group_t group,
        task_handler_t task)
    {
        return this->Schedule(::randtime(min, max), group, std::move(task));
    }
 
    TaskScheduler& CancelAll();
 
    TaskScheduler& CancelGroup(group_t group);
 
    TaskScheduler& CancelGroupsOf(std::span<group_t> groups);
 
    TaskScheduler& DelayAll(duration_t duration);
 
    TaskScheduler& DelayAll(std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->DelayAll(::randtime(min, max));
    }
 
    TaskScheduler& DelayGroup(group_t group, duration_t duration);
 
    TaskScheduler& DelayGroup(group_t group,
        std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->DelayGroup(group, ::randtime(min, max));
    }
 
    TaskScheduler& RescheduleAll(duration_t duration);
 
    TaskScheduler& RescheduleAll(std::chrono::milliseconds min, std::chrono::milliseconds max)
    {
        return this->RescheduleAll(::randtime(min, max));
    }
 
    TaskScheduler& RescheduleGroup(group_t group, duration_t duration);
 
    TaskScheduler& RescheduleGroup(group_t group,
        std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->RescheduleGroup(group, ::randtime(min, max));
    }
 
private:
    TaskScheduler& InsertTask(TaskContainer&& task);
 
    TaskScheduler& InsertTask(TaskQueue::Container::node_type&& node);
 
    TaskScheduler& ScheduleAt(timepoint_t end,
        duration_t time, task_handler_t task);
 
    TaskScheduler& ScheduleAt(timepoint_t end,
        duration_t time,
        group_t group, task_handler_t task);
 
    void Dispatch(success_t const& callback);
};
 
class TC_COMMON_API TaskContext
{
    friend class TaskScheduler;
 
    std::variant<TaskScheduler::TaskQueue::Container::node_type /*not consumed*/,
        TaskScheduler::TaskContainer /*consumed*/> _task;
 
    std::weak_ptr<TaskScheduler> _owner;
 
public:
    // Empty constructor
    TaskContext() noexcept
        : _task(), _owner() { }
 
    // Construct from task and owner
    explicit TaskContext(TaskScheduler::TaskQueue::Container::node_type&& task, std::weak_ptr<TaskScheduler>&& owner) noexcept;
 
    // Copy construct
    TaskContext(TaskContext const& right) = delete;
 
    // Move construct
    TaskContext(TaskContext&& right) noexcept;
 
    // Copy assign
    TaskContext& operator=(TaskContext const& right) = delete;
 
    // Move assign
    TaskContext& operator=(TaskContext&& right) noexcept;
 
    ~TaskContext();
 
    bool IsExpired() const;
 
    bool IsInGroup(TaskScheduler::group_t group) const;
 
    TaskContext& SetGroup(TaskScheduler::group_t group);
 
    TaskContext& ClearGroup();
 
    TaskScheduler::repeated_t GetRepeatCounter() const;
 
    TaskContext& Repeat(TaskScheduler::duration_t duration);
 
    TaskContext& Repeat();
 
    TaskContext& Repeat(std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->Repeat(::randtime(min, max));
    }
 
    TaskContext& Async(std::function<void()> callable);
 
    TaskContext& Schedule(TaskScheduler::duration_t time,
        TaskScheduler::task_handler_t task);
 
    TaskContext& Schedule(TaskScheduler::duration_t time,
        TaskScheduler::group_t group, TaskScheduler::task_handler_t task);
 
    TaskContext& Schedule(std::chrono::milliseconds min,
        std::chrono::milliseconds max, TaskScheduler::task_handler_t task)
    {
        return this->Schedule(::randtime(min, max), std::move(task));
    }
 
    TaskContext& Schedule(std::chrono::milliseconds min,
        std::chrono::milliseconds max, TaskScheduler::group_t group,
        TaskScheduler::task_handler_t task)
    {
        return this->Schedule(::randtime(min, max), group, std::move(task));
    }
 
    TaskContext& CancelAll();
 
    TaskContext& CancelGroup(TaskScheduler::group_t group);
 
    TaskContext& CancelGroupsOf(std::span<TaskScheduler::group_t> groups);
 
    TaskContext& DelayAll(TaskScheduler::duration_t duration);
 
    TaskContext& DelayAll(std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->DelayAll(::randtime(min, max));
    }
 
    TaskContext& DelayGroup(TaskScheduler::group_t group, TaskScheduler::duration_t duration);
 
    TaskContext& DelayGroup(TaskScheduler::group_t group,
        std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->DelayGroup(group, ::randtime(min, max));
    }
 
    TaskContext& RescheduleAll(TaskScheduler::duration_t duration);
 
    TaskContext& RescheduleAll(std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->RescheduleAll(::randtime(min, max));
    }
 
    TaskContext& RescheduleGroup(TaskScheduler::group_t group, TaskScheduler::duration_t duration);
 
    TaskContext& RescheduleGroup(TaskScheduler::group_t group,
        std::chrono::milliseconds min,
        std::chrono::milliseconds max)
    {
        return this->RescheduleGroup(group, ::randtime(min, max));
    }
 
private:
    void Invoke();
 
    TaskScheduler::TaskContainer& GetTaskContainer() noexcept;
 
    TaskScheduler::Task* GetTask() const noexcept;
};
 
#endif