SynchronisationRules.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__SYNCHRONISATION__RULES__HH
#define __DIADES__AUTOMATA__SYNCHRONISATION__RULES__HH

#include <numeric>
#include<diades/utils/Exceptions.hh>
#include<diades/utils/Functors.hh>
#include<diades/automata/Component.hh>
#include<diades/automata/Event.hh>


namespace Diades {
    namespace Automata {

        class _ComponentIterator {
        public:
            typedef vector<const Component *> ComponentVector;
            typedef vector<Event> EventVector;

        private:
            const ComponentVector * _pVect;
            const EventVector * _pEvent;
            ComponentVector::size_type _index;

        public:

            _ComponentIterator(const ComponentVector * pVect, const EventVector * pEvent,
                    ComponentVector::size_type index) : _pVect(pVect), _pEvent(pEvent), _index(index) {
            }

            _ComponentIterator(const _ComponentIterator & it) : _pVect(it._pVect), _pEvent(it._pEvent), _index(it._index) {
            }

            const Component & operator*() const {
                return *(_pVect->operator[](_index));
            }

            const Component * operator->() const {
                return (_pVect->operator[](_index));
            }

            _ComponentIterator & operator++() {
                ++_index;
                return (*this);
            }

            _ComponentIterator operator++(int) {
                _ComponentIterator res(_pVect, _pEvent, _index + 1);
                ++_index;
                return res;
            }

            bool operator==(const _ComponentIterator & compIt) const {
                return (_pVect == compIt._pVect) && (_pEvent == compIt._pEvent)
                        && (_index == compIt._index);
            }

            bool operator!=(const _ComponentIterator & compIt) const {
                return !(*this == compIt);
            }

            Event getAssociatedEvent() const {
                return (*_pEvent)[_index];
            }

            ComponentVector::size_type index() const {
                return _index;
            }
        };

        class SynchronisationEvent {
        public:

            static string typeName() {
                return "Automata::SynchronisationEvent";
            }
            typedef Diades::Utils::Exception<SynchronisationEvent> Exception;
            typedef vector<const Component *> ComponentVector;
            typedef vector<Event> EventVector;
            typedef ComponentVector::size_type size_type;
            typedef _ComponentIterator ComponentIterator;
            typedef _ComponentIterator SupportIterator;
            typedef const SynchronisationEvent * ConstPointer;

        private:
            ComponentVector _components;
            ComponentVector _support;
            EventVector _events;
            EventVector _supportEvents;
            Event _synchronised;

        public:

            SynchronisationEvent(const ComponentVector & components);


            SynchronisationEvent(const SynchronisationEvent & sync1, const SynchronisationEvent & sync2);



            SynchronisationEvent(const SynchronisationEvent & sync, const ComponentVector & components);

            SynchronisationEvent(const SynchronisationEvent & sync) :
            _components(sync._components), _support(),
            _events(sync._events),
            _synchronised(sync._synchronised) {
            }

            SynchronisationEvent & operator=(const SynchronisationEvent & sync) {
                if (&sync != this) {
                    _components = sync._components;
                    _support = sync._support;
                    _events = sync._events;
                    _supportEvents = sync._supportEvents;
                    _synchronised = sync._synchronised;
                }
                return *this;
            }

            ConstPointer getPointer() const {
                return this;
            }

            size_type size() const {
                return _components.size();
            }

            size_type supportSize() const {
                return _support.size();
            }

            bool isValid() const;

            ComponentIterator addEvent(const Component & component, Event e);

            const Event & synchronisedEvent() const {
                require(Exception, isValid(), "The synchronisation event is  invalid");
                ensure(Exception, _synchronised.isValid(), "The returned synchronised event is invalid");
                return _synchronised;
            }

            ComponentIterator beginOfComponents() const {
                return ComponentIterator(&_components, &_events, 0);
            }

            ComponentIterator endOfComponents() const {
                return ComponentIterator(&_components, &_events, _components.size());
            }

            ComponentIterator beginOfSupport() const {
                return ComponentIterator(&_support, &_supportEvents, 0);
            }

            ComponentIterator endOfSupport() const {
                return ComponentIterator(&_support, &_supportEvents, _support.size());
            }

            Event getAssociatedEvent(const ComponentIterator & it) const {
                return it.getAssociatedEvent();
            }

            Event getAssociatedEvent(const Component & comp) const {
                require(Exception, findComponent(comp) != endOfComponents(), "getAssociatedEvent: the component does not exist in the synchronisation event");
                ComponentIterator it = findComponent(comp);
                if (it == endOfComponents()) {
                    return Event();
                }
                return getAssociatedEvent(it);
            }


            ComponentIterator findComponent(const Component & component) const;
            ComponentIterator findSupportComponent(const Component & component) const;

            bool operator==(const SynchronisationEvent & sync) const;
        private:
            void updateSynchroniseEvent();
        };

        class SynchronisationRules {
        public:

            static string typeName() {
                return "Automata::SynchronisationRules";
            }
            typedef Diades::Utils::Exception<SynchronisationRules> Exception;
            typedef vector<const Component *> ComponentVector;
            

        protected:
            ComponentVector _components;
            list<SynchronisationEvent> _synchros;
        public:
            typedef ComponentVector::size_type size_type;
            typedef list<SynchronisationEvent>::const_iterator SynchronisationIterator;
            typedef _ComponentIterator ComponentIterator;


            SynchronisationRules(const ComponentVector & components);

            SynchronisationRules() : _components(), _synchros() {
            }

            void setComponentVector(const ComponentVector & components);

            SynchronisationIterator beginOfSynchronisedEvents() const {
                return _synchros.begin();
            }

            SynchronisationIterator endOfSynchronisedEvents() const {
                return _synchros.end();
            }

            size_type numberOfComponents() const {
                return _components.size();
            }

            size_type size() const {
                return _synchros.size();
            }

            ComponentIterator beginOfComponents() const {
                return ComponentIterator(&_components, 0, 0);
            }

            ComponentIterator endOfComponents() const {
                return ComponentIterator(&_components, 0, _components.size());
            }

            const Component & getComponent(size_type index) const {
                require(Exception, index < numberOfComponents(),
                        Diades::Utils::Msg("getComponent: out-of-range index '%1% > %2%'")
                        % index % numberOfComponents());
                return *_components[index];
            }


            ComponentIterator findComponent(const string & name) const;


            ComponentIterator findComponent(const Component & component) const;

            bool operator==(const SynchronisationRules & rules) const {
                return (_components == rules._components) && (_synchros == rules._synchros);
            }

            void getSynchronisationEvents(const Component & component, Event event,
                    list< SynchronisationEvent::ConstPointer > & events) const;

            bool valid() const {
               using AccValidity = Diades::Utils::AccumulateValidity<SynchronisationEvent>;
                return !_components.empty() && accumulate(_synchros.begin(), _synchros.end(), true, AccValidity());
            }

            friend ostream & operator<<(ostream & os, const SynchronisationRules & rules);


        };

        class TwinPlantSynchronisation : public SynchronisationRules {
        public:
            TwinPlantSynchronisation(const ComponentVector & components, const set<Event> & synchronisedEvents);
        };

        class FreeProduct : public SynchronisationRules {
        public:
            FreeProduct(const ComponentVector & components);
        };

        class ParametrizedSynchronisation : public SynchronisationRules {
        private:
            bool _locked;
            set< set<Event> > _isSynchronized;
        public:
            ParametrizedSynchronisation(const ComponentVector & components);

            ParametrizedSynchronisation() : SynchronisationRules(), _locked(false), _isSynchronized() {
            }


            void init(const ComponentVector & components);


            void synchronise(Event e);

            void synchronise(const vector<Event> & e);
            void synchronise(const vector<Event> & e, bool relaxation);

            void close();
            void open();

            bool isLocked() const {
                return _locked;
            }


            void clear();




        };


    };

};

#endif