FaultPattern.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__FAULTMODEL__HH
#define __DIADES__AUTOMATA__FAULTMODEL__HH
#include<fstream>
#include<set>
#include<list>
#include<unordered_set>
#include<diades/graph/Graph.hh>
#include<diades/graph/NodeMap.hh>
#include<diades/graph/EdgeMap.hh>
#include<diades/automata/Event.hh>


using std::unordered_set;
using std::set;
using namespace Diades::Graph;

namespace Diades
{
  namespace Automata
  {
  
        class FaultPattern
        {
        public:
          class EventOccurrence
          {
          private:
                Event _event; 
                int   _id;    
                
          public:
                EventOccurrence(Event event, int identifier): _event(event),_id(identifier){}
          
                EventOccurrence():_event(),_id(){}
                
                EventOccurrence(const EventOccurrence & occurrence):_event(occurrence.event()),_id(occurrence.identifier()){}
                
                EventOccurrence & operator=(const EventOccurrence & occurrence){
                  if(this != &occurrence)
                        {
                          _event = occurrence.event();
                          _id = occurrence.identifier();
                        }
                  return *this;
                }

                
                
                Event event() const { return _event;}

                int identifier() const { return _id; }

                bool operator==(const EventOccurrence & occurrence)
                {
                  return (event() == occurrence.event()) && (identifier() == occurrence.identifier()); 
                }

                friend ostream & operator<<(ostream & os, const EventOccurrence & occurrence)
                {
                  return os << occurrence.event() << "#" << occurrence.identifier();
                }

                
                
          };
        protected:
          Graph::Graph _graph; 
          EdgeMap<EventOccurrence> _edgeMap; 
          Node _initialNode; 
          NodeMap<int> _finalNodes;   
          unordered_set<Event> _events; 
        public:
          FaultPattern();

          virtual ~FaultPattern() {}
          
          virtual void pattern2Dot(const string & filename);
        

          virtual const Graph::Graph & graph() const { return _graph; }

        
          virtual bool isFinal(Node s) const { return (s.valid() && (&s.owner() == &_graph) && (_finalNodes[s]==1)); }
        
        
          bool containsEvent(Event event) const { return _events.find(event) != _events.end(); }
        
          virtual Node initial() const { return _initialNode; }

          virtual const EventOccurrence & eventOccurrenceOf(Edge edge) const { return _edgeMap[edge]; }
        
        };
  

        class SingleFaultEventPattern: public FaultPattern
        {
        public:
          SingleFaultEventPattern(Event fault);
        };



        class MultipleFaultEventPattern: public FaultPattern
        {
        public:
          MultipleFaultEventPattern(const set<Event> & events);
        };



        class MultipleFaultEventOccurrencePattern: public FaultPattern
        {
        public:
          MultipleFaultEventOccurrencePattern(const list<Event> & events);
        };

  
        class DisjunctiveFaultPattern: public FaultPattern
        {
        public:
          DisjunctiveFaultPattern(const list<FaultPattern *> & patterns);
        };
        
  
        
  };
};

#endif