scheduler.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   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.
 
 
#ifndef SCHEDULER_HH
#define SCHEDULER_HH
 
#include "events.h"
#include "linked_list.h"
 
namespace events
{
    class Job;
 
    template<typename CLOCK_, typename EVENT_>
    class Scheduler : public EventHandler<EVENT_>, public containers::LinkedList<Job>
    {
    public:
        Scheduler(const Scheduler&) = delete;
        Scheduler& operator=(const Scheduler&) = delete;
 
        using CLOCK = CLOCK_;
        using EVENT = EVENT_;
 
        Scheduler(const CLOCK& clock, uint8_t type) INLINE : EventHandler<EVENT>{type}, clock_{clock} {}
 
        void on_event(UNUSED const EVENT& event) final INLINE
        {
            traverse(JobCaller{clock_});
        }
 
        void schedule(Job& job) INLINE
        {
            insert(job);
        }
 
        void unschedule(Job& job) INLINE
        {
            remove(job);
        }
 
    private:
        class JobCaller
        {
        public:
            explicit JobCaller(const CLOCK& clock) : clock_{clock} {}
            bool operator()(Job& job);
 
        private:
            const CLOCK& clock_;
        };
 
        const CLOCK& clock_;
    };
 
    class Job : public containers::Link<Job>
    {
    public:
        bool is_periodic() const INLINE
        {
            return period_ != 0;
        }
 
        uint32_t next_time() const INLINE
        {
            return next_time_;
        }
 
        uint32_t period() const INLINE
        {
            return period_;
        }
 
        void reschedule(uint32_t when) INLINE
        {
            next_time_ = when;
        }
 
    protected:
        Job(const Job&) =  default;
        Job& operator=(const Job&) = default;
        
        virtual void on_schedule(uint32_t millis) = 0;
 
        Job(uint32_t next = 0, uint32_t period = 0) INLINE : next_time_{next}, period_{period} {}
 
    private:
        uint32_t next_time_;
        uint32_t period_;
 
        template<typename CLOCK, typename T> friend class Scheduler;
    };
 
    template<typename CLOCK, typename T> bool Scheduler<CLOCK, T>::JobCaller::operator()(Job& job)
    {
        uint32_t now = clock_.millis();
        if (job.next_time() <= now)
        {
            job.on_schedule(now);
            if (!job.is_periodic()) return true;
            job.reschedule(now + job.period());
        }
        return false;
    }
}
 
#endif /* SCHEDULER_HH */