TopologyMap.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__TOPOLOGYMAP_HH
#define __DIADES__AUTOMATA__TOPOLOGYMAP_HH

#include<unordered_map>
#include<set>
#include<algorithm>
#include<diades/utils/Exceptions.hh>
#include<diades/graph/ConstNodeMap.hh>
#include<diades/automata/ObservableComponent.hh>
#include<diades/automata/Topology.hh>
#include<diades/automata/SynchronisationRules.hh>
#include<diades/automata/ConnectionMap.hh>



namespace Diades
{
  namespace Automata
  {
 
        class TopologyMap
        {

        private:
          typedef const ObservableComponent * ComponentPointer;
          typedef ConstNodeMap< ConnectionMap >  _ConnMap;
          typedef ConstNodeMap< ComponentPointer >  _CompMap;

          const Topology * _topology;
          _ConnMap _connMap;
          _CompMap _compMap;
          unordered_map<ComponentPointer,Node> _nodeMap;
          unordered_map<Event,Node> _eventMap;

        public:
          static string typeName() { return "AutModel::TopologyMap"; }
          typedef Diades::Utils::Exception<Topology> Exception;



        
        public:
          TopologyMap(const Topology & topology):_topology(&topology),_connMap(topology.graph()),_compMap(topology.graph()),_nodeMap(){  }
          bool valid() const { return _topology!=0 && topology().valid(); }
          const Topology & topology() const { return *_topology; }
          void mapComponentToNode(const ObservableComponent & component, Topology::Node itsNode);
        

          Node getNodeSourceOf(Event event) const
          {
                unordered_map<Event,Node>::const_iterator it = _eventMap.find(event);
                if(it == _eventMap.end())
                  {
                        return Node();
                  }
                return it->second;
          }

        
          const ObservableComponent & getComponent(Topology::Node node) const
          {
                require(Exception,node.valid(),"getComponent(): invalid node");
                require(Exception,&node.owner() == &topology().graph(),
                                "getComponent(): this node does not belong to the Topology");
                return  *_compMap[node];
          }
        
          Topology::Node getNode(const ObservableComponent &  component) const
          {
                unordered_map<ComponentPointer,Node>::const_iterator it = _nodeMap.find(&component);
                return it->second;
          }
        
          void addConnection(Topology::Connection connection, Topology::Node node, Event event)
          {
                if(find(topology().cliqueBegin(connection),topology().cliqueEnd(connection),node)
                   != topology().cliqueEnd(connection))
                  {
                        _connMap[connection].mapEventToNode(event,node);
                  }
          }

          void importMap(const string & fileName);
          void exportMap(const string & fileName);
          
          const ConnectionMap & getConnectionMap(Topology::Connection connection) const
          {
                return _connMap[connection];
          }

        
        };
  };
};


#endif