Events.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_PPI_Events_
#define HH_SENF_PPI_Events_ 1

// Custom includes
#include <vector>
#include <senf/Scheduler/ClockService.hh>
#include "predecl.hh"

//#include "Events.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace ppi {

    namespace detail { class EventBindingBase; }

    // Implementation: The concrete EventDescriptor implementation will need to set things up so
    // some callback (within the EventDescriptor implementation) will be called when the event
    // happens. This setup happens in 'v_enable()'. This internal handler sets up an EventType
    // instance if needed and calls 'callback()'.
    //
    // 'callback()' will access the EventBinding wrapper to find the user-callback to signal. It
    // will do any needed internal processing, call that user callback and clean up afterwards.

    class EventDescriptor
    {
    public:
        virtual ~EventDescriptor();

        bool enabled() const; 
        void enabled(bool v); 

    protected:
        EventDescriptor();

    private:
        virtual void v_enable() = 0;    
        virtual void v_disable() = 0;   

        virtual bool v_isRegistered() = 0;

        void notifyThrottle();
        void notifyUnthrottle();

        void registerRoute(ForwardingRoute & route);
        void unregisterRoute(ForwardingRoute & route);

        bool enabled_;
        bool throttled_;

        typedef std::vector<ForwardingRoute*> Routes;
        Routes routes_;

        detail::EventBindingBase * binding_;

        friend class ForwardingRoute;
        friend class detail::EventBindingBase;
    };

    template <class EventType, class Self>
    class EventImplementationHelper
    {
    protected:
        typedef typename detail::EventArgType<EventType>::type EventArg;

        void callback(EventArg event, ClockService::clock_type time);

        void callback(EventArg event);  

    private:
        detail::EventBinding<EventType> & binding();
    };

#ifndef DOXYGEN

    template <class Self>
    class EventImplementationHelper<void,Self>
    {
    protected:
        void callback(ClockService::clock_type time);
        void callback();

    private:
        detail::EventBinding<void> & binding();
    };

#endif

    template <class EventType>
    class EventImplementation
        : public EventDescriptor,
          public EventImplementationHelper< EventType, EventImplementation<EventType> >
    {
    public:
        typedef EventType Event;
        typedef typename detail::EventArgType<EventType>::type EventArg;

        module::Module & module() const; 
        EventManager & manager() const; 

    protected:
        EventImplementation();

    private:
        virtual bool v_isRegistered();
        void setBinding(detail::EventBinding<Event> & binding);

        detail::EventBinding<Event> * binding_;

        friend class EventManager;
        friend class EventImplementationHelper< EventType, EventImplementation<EventType> >;
    };

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Events.cci"
//#include "Events.ct"
#include "Events.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End: