AbstractEventSource.h

Go to the documentation of this file.

// Copyright CERN 2012 - Developed in collaboration with GSI
#ifndef ABSTRACT_EVENT_SOURCE_H_
#define ABSTRACT_EVENT_SOURCE_H_

#include <fesa-core/Diagnostic/DiagnosticUtils.h>
#include <fesa-core/Utilities/Thread.h>
#include <fesa-core/Exception/FesaException.h>
#include <fesa-core/Utilities/ConditionalVariable.h>
#include <fesa-core/Utilities/Mutex.h>
#include <boost/shared_ptr.hpp>

#include <map>
#include <vector>

namespace fesa
{

class EventElement;
class RTScheduler;
class FesaStream;
class RTEvent;

enum EventSourceType
{
        TimingSource, TimerSource, OnDemandSource, OnSubscriptionSource, CustomSource, TimingSimulationSource
};

class AbstractEventSource : protected Thread
{
        public:

                virtual void enable();

                virtual void disable();

                virtual void enableEvent(const std::string& logicalEventName);

                virtual void disableEvent(const std::string& logicalEventName);

                void printConfig(FesaStream* fesaStream) const;

                void printState(FesaStream* fesaStream, double elapsedTime);

                virtual ~AbstractEventSource();

                const std::string& getName() const;

                EventSourceType getType() const;

                uint32_t getEvtSrcPriority() const;

                uint32_t getEvtSrcID() const;

                bool isEventEnabled(const std::string& logicalEventName) const;

        protected:

                friend class RTEvent;
                friend class RTController;
                friend class AbstractEventSourceFactory;

                AbstractEventSource(const std::string eventSourceName,EventSourceType type_);

                void run();

                virtual void addRTScheduler(boost::shared_ptr<fesa::EventElement>& element, RTScheduler* scheduler);

                virtual RTEvent* wait() = 0;

                virtual void connect(boost::shared_ptr<fesa::EventElement>& eventElement) = 0;

        private:

                struct SubscribedScheduler
                {
                        RTScheduler* scheduler_;
                        std::string logicalEventName_;
                        bool isEnabled_;
                };
                typedef std::string ConcreteEventName;
                typedef std::map< ConcreteEventName, std::vector< SubscribedScheduler > > ConcreteEventMap;

                ConcreteEventMap eventMap_;

                bool sourceIsEnabled_;

                ConditionalVariable waitIfDisabled_;
                Mutex mutex_waitIfDisabled_;

                std::string eventSourceName_;

                EventSourceType type_;

                DiagnosticUtils::DiagStateCounter firedEventCount_;

                void postEventToSchedulers(boost::shared_ptr<RTEvent>& event);

                void waitTillSourceEnabled();

                void setLogicalEventEnableState(bool newState,const std::string& logicalEventName);

};

} // fesa

#endif // ABSTRACT_EVENT_SOURCE_H_