events.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 EVENTS_HH
#define EVENTS_HH
 
#include <stddef.h>
#include "queue.h"
#include "linked_list.h"
 
namespace events
{
    namespace Type
    {
        const uint8_t NO_EVENT = 0;
 
        const uint8_t WDT_TIMER = 1;
 
        const uint8_t RTT_TIMER = 2;
 
        const uint8_t USER_EVENT = 128;
    };
 
    template<typename T> class Event
    {
    public:
        Event(const Event&) = default;
        Event& operator=(const Event&) = default;
 
        using TYPE = T;
 
        explicit Event(uint8_t type = Type::NO_EVENT, T value = T{}) INLINE : type_{type}, value_{value} {}
 
        uint8_t type() const INLINE
        {
            return type_;
        }
 
        T value() const INLINE
        {
            return value_;
        }
 
    private:
        uint8_t type_;
        T value_;
    };
 
    template<> class Event<void>
    {
    public:
        Event(const Event&) = default;
        Event& operator=(const Event&) = default;
 
        using TYPE = void;
 
        explicit Event(uint8_t type = Type::NO_EVENT) INLINE : type_{type} {}
        uint8_t type() const INLINE
        {
            return type_;
        }
 
    private:
        uint8_t type_;
    };
 
    template<typename T> struct Event_trait
    {
        static constexpr const bool IS_EVENT = false;
    };
    // Note: the following line compiled with GCC 7.4 but does not with 9.2 and 10.2
    // template<> template<typename T> struct Event_trait<Event<T>>
    // Replaced with this line to make GCC 9.2 happy
    template<typename T> struct Event_trait<Event<T>>
    {
        static constexpr const bool IS_EVENT = true;
    };
 
    template<typename EVENT> class EventHandler;
 
    template<typename EVENT> class Dispatcher : public containers::LinkedList<EventHandler<EVENT>>
    {
        static_assert(Event_trait<EVENT>::IS_EVENT, "EVENT type must be an events::Event<T>");
 
    public:
        Dispatcher() = default;
        Dispatcher(const Dispatcher&) = delete;
        Dispatcher& operator=(const Dispatcher&) = delete;
 
        void dispatch(const EVENT& event)
        {
            this->traverse(HandlerCaller(event));
        }
 
    private:
        class HandlerCaller
        {
        public:
            explicit HandlerCaller(const EVENT& event) INLINE : event_{event} {}
            bool operator()(EventHandler<EVENT>& handler) INLINE
            {
                if (handler.type() == event_.type()) handler.on_event(event_);
                return false;
            }
 
        private:
            const EVENT event_;
        };
    };
 
    template<typename EVENT> class EventHandler : public containers::Link<EventHandler<EVENT>>
    {
        static_assert(Event_trait<EVENT>::IS_EVENT, "EVENT type must be an events::Event<T>");
 
    public:
        uint8_t type() const INLINE
        {
            return type_;
        }
 
    protected:
        EventHandler(const EventHandler&) = default;
        EventHandler& operator=(const EventHandler&) = default;
        
        virtual void on_event(const EVENT& event) = 0;
 
        explicit EventHandler(uint8_t type = Type::NO_EVENT) INLINE : type_{type} {}
 
    private:
        uint8_t type_;
        friend class Dispatcher<EVENT>;
    };
};
#endif /* EVENTS_HH */