ObservableMask.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__OBSERVABLEMASK__HH
#define __DIADES__AUTOMATA__OBSERVABLEMASK__HH

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/set.hpp>
#include <boost/serialization/map.hpp>
#include <unordered_map>
#include <set>
#include <diades/automata/Event.hh>
#include <diades/automata/SynchronisationRules.hh>

using std::set;

namespace Diades
{

  namespace Automata
  {
      class ObservableComponent;
    using Diades::Utils::Msg;
        class ObservableMask {


        public:
          static string typeName() { return "Automata::ObservableMask"; }
          typedef Diades::Utils::Exception<ObservableMask> Exception;

          
        public:
          typedef set<Event>::const_iterator ObservableEventIterator;
          typedef set<Event>::const_iterator EventIterator;
        
        private:
          unordered_map<Event,set<Event> > _eventOfObservable; // store for each observable event, the set of events that may produce them 
          unordered_map<Event,set<Event> > _observableOfEvent; // store for each event, the set of observable events, including noEvent()
          Event _noEvent; // the unobservable event (epsilon)
          set<Event> _observableEvents;
          unsigned _nbIdentifiable;
          set<Event> _events;
          vector<bool> _detectable;
          vector<bool> _identifiable;

        public:
          template<class Archive>
          void serialize(Archive & ar, const unsigned int version)
          {
                ar & _eventOfObservable;
                ar &_observableOfEvent;
                ar & _noEvent;
                ar & _observableEvents;
                ar & _nbIdentifiable;
                ar & _events;
                ar & _detectable;
                ar & _identifiable;
          }


          
        public:
        
          ObservableMask();
        

        
          ObservableMask(const ObservableMask & mask);


          ObservableMask(const SynchronisationRules & rules, 
                         const vector<const ObservableComponent *> & components);

          ObservableMask & operator= (const ObservableMask & mask);
        
          void clear();



          void project(const ObservableMask & mask, const set<Event> & events);


          unsigned numberOfObservableEvents() const
          {
                return _observableEvents.size();
          }
          unsigned numberOfIdentifiableEvents() const
          {
                return _nbIdentifiable;
          }
        
          EventIterator eventBegin() const{
                return _events.begin();
          }


          EventIterator eventEnd() const {
                return _events.end();
          }     

        
          ObservableEventIterator observableBegin() const{
                return _observableEvents.begin();
          }


          ObservableEventIterator observableEnd() const {
                return _observableEvents.end();
          }     

          bool containsEvent(const Event & e) const
          {
                return _observableOfEvent.find(e) != _observableOfEvent.end();
          }


          bool containsObservableEvent(const Event & obs) const
          {
                return _eventOfObservable.find(obs) != _eventOfObservable.end();
          }


          bool sometimesObservable(const Event & e) const;
        
        
          bool matches(const Event & e,const Event & obs) const;
        

          bool isUnobservable(const Event & e) const;

        
          bool isObservable(const Event & e) const;
        
          bool isIdentifiable(const Event & e) const
          {
            require(Exception,containsEvent(e),
                    Msg("isIdentifiable: event %1% must be in the mask") % e);
            return (_identifiable.size() > e.id()) && (_identifiable[e.id()]);
          }
        


          bool isDetectable(const Event & e) const
          {
            require(Exception,containsEvent(e),
                    Msg("isDetectable: event %1% must be in the mask") % e);
                return (_detectable.size() > e.id()) && (_detectable[e.id()]);
          }


        
          ObservableEventIterator  observableBegin(const Event & e) const;


          ObservableEventIterator  observableEnd(const Event & e) const;





          EventIterator  beginOfSourceEvent(const Event & obs) const;


        




          EventIterator  endOfSourceEvent(const Event & obs) const;

        
          const Event & noEvent() const { return _noEvent; }


          void addMask(const Event & e, const Event & obs);
        

          void removeMask(const Event & e, const Event & obs);


          unsigned numberOfAssociatedEvents(const Event  & e) const;
        
        
          void makeUnobservable(const Event & e);
        
        
        };






        struct IsObservable:  public std::unary_function<Event,bool>
        {
          const ObservableMask & _mask;
          IsObservable(const ObservableMask & mask):_mask(mask){}
          bool operator()(const Event & event) const
          {
                return _mask.isObservable(event);
          }
        };



        

        struct IsUnobservable:  public std::unary_function<Event,bool>
        {
          const ObservableMask & _mask;
          IsUnobservable(const ObservableMask & mask):_mask(mask){}
          bool operator()(const Event & event) const 
          {
                return _mask.isUnobservable(event);
          }
        };

        

        struct IsIdentifiable:  public std::unary_function<Event,bool>
        {
          const ObservableMask & _mask;
          IsIdentifiable(const ObservableMask & mask):_mask(mask){}
          bool operator()(const Event & event) const 
          {
                return _mask.isIdentifiable(event);
          }
        };
        
        struct IsNonIdentifiable:  public std::unary_function<Event,bool>
        {
          const ObservableMask & _mask;
          IsNonIdentifiable(const ObservableMask & mask):_mask(mask){}
          bool operator()(const Event & event) const 
          {
                return !_mask.isIdentifiable(event);
          }
        };

  };

};

#endif