Candidate.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__CANDIDATE__HH__
#define __DIADES__AUTOMATA__CANDIDATE__HH__

#include <set>
#include <vector>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/set.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <diades/utils/Verbose.hh>
#include <diades/graph/Graph.hh>
#include <diades/automata/Event.hh>


using std::set;


namespace Diades
{
  namespace Automata
  {

        class Candidate
        {
        public:
          typedef Diades::Graph::Node::NodeId StateId;
          
          typedef set<Event>::const_iterator FaultIterator;

          typedef set<Event>::size_type FaultSize;


        private:
          vector< StateId > _stateId;
          vector< set<Event> > _faults;
        public:
          Candidate():_stateId(),_faults(){}
            
          Candidate(StateId stateId, const set<Event>  & faults):
                    _stateId(1),_faults(1)
          {
              _stateId[0] = stateId;
              _faults[0] = faults;
          }

          Candidate(const vector<StateId> & stateId, 
                    const vector< set<Event> > & faults):
                    _stateId(stateId),_faults(faults){}

          Candidate(const Candidate & candidate):_stateId(candidate._stateId),
                                                 _faults(candidate._faults){}


          Candidate & operator=(const Candidate & candidate)
          {
                if(this != &candidate)
                  {
                        _stateId = candidate._stateId;
                        _faults = candidate._faults;
                  }
                return *this;
          }

          
          const vector<StateId> &  stateId() const { return _stateId; }

          const vector< set<Event> > & faults() const { return _faults; }

          FaultIterator begin(unsigned i) const { return _faults[i].begin(); }

          FaultIterator end(unsigned i) const { return _faults[i].end(); }

          FaultSize numberOfFaults() const {
                unsigned number = 0;
                for(const set<Event> & fset : faults())
                  {
                        number+= fset.size();
                  }
                return number;
          }

          bool isNormal() const { return numberOfFaults() == 0; }


          bool isAbnormal() const { return !isNormal(); }


          bool operator==(const Candidate & candidate) const
          {
                return (_stateId == candidate.stateId())
                  && (_faults == candidate._faults);
          }


          bool operator!= (const Candidate & candidate) const
          {
                return !(*this == candidate);
          }


          bool operator<(const Candidate & candidate) const;

          
          string toString() const
          {
              stringstream stream;
              stream << *this;
              return stream.str();
          }
          
          friend ostream & operator<<(ostream & os, const Candidate & candidate)
          {
                os << "[ ";
                for(unsigned i = 0; i < candidate.stateId().size(); ++i)
                  {
                        os << "(" << candidate.stateId().operator[](i) 
                           << "," 
                           << toStream(candidate.begin(i),
                                       candidate.end(i)) << ") ";
                  }
                os << "]";
                return os;
          }

        private:
          friend class boost::serialization::access;

          template<class Archive>
          void serialize(Archive & ar, const unsigned int version)
          {
                ar & _stateId;
                ar & _faults;
          }       
        };


        
  };
};
  
namespace std
{
  template<> struct hash<Diades::Automata::Candidate>
  {
        size_t operator()(const Diades::Automata::Candidate & candidate) const
        {
          return std::hash<std::string>()(candidate.toString());
        }
  };
};




#endif