Topology.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__TOPOLOGY__HH
#define __DIADES__AUTOMATA__TOPOLOGY__HH
#include <fstream>
#include <set>
#include <unordered_set>
#include <diades/utils/Exceptions.hh>
#include <diades/utils/Identifier.hh>
#include <diades/graph/Graph.hh>
#include <diades/graph/NodeMap.hh>


using std::unordered_set;
using std::set;

namespace Diades
{
namespace Automata
{
  typedef Diades::Utils::Identifier Identifier;
 
  class Topology
  {
  public:
        typedef Diades::Graph::Node Connection;
        typedef Diades::Graph::Node Node;
        typedef unordered_set<Connection>::const_iterator ConnectionIterator;
        typedef unordered_set<Node>::const_iterator NodeIterator;
        
  private:      
        typedef Diades::Graph::Graph Graph;
        typedef Diades::Graph::Edge Edge;
        Graph _graph;
        unordered_set<Connection> _connections;
        unordered_set<Node> _nodes;
        Diades::Graph::NodeMap<Identifier> _labels;
        
  public:
        static string typeName() { return "AutModel::Topology"; }
        typedef Diades::Utils::Exception<Topology> Exception;

        Node getNodeOfName(const Identifier & name) const
        {
          try
                {
                  NodeIterator nodeIt = nodeBegin();
                  bool found = false;
                  while((!found) && (nodeIt!=nodeEnd()))
                        {
                          found = _labels[*nodeIt] == name;
                          if (!found)
                                {
                                  ++nodeIt;
                                }
                        }
                  if(found)
                        {
                          return *nodeIt;
                        }
                  return Node();
                }
          catch(exception & e)
                {
                  throw Exception("getNodeOfName(): the operation did not succeed", e);
                }
          return Node();
        }
        
        

        void setNodeName(Node node,const Identifier & name)
        {
          try
                {
                  require(Exception,node.valid(),"setNodeName(): the node is not valid");
                  require(Exception,&node.owner() == &graph(),"setNodeName(): the node does not belong to the topology");
                  _labels[node]=name;
                }
          catch(exception & e)
                {
                  throw Exception("setNodeName(): the operation did not succeed", e);
                }
        }

        const Identifier & getNodeName(Node node) const
        {
          try
                {
                  require(Exception,node.valid(),"getNodeName(): the node is not valid");
                  require(Exception,&node.owner() == &graph(),"getNodeName(): the node does not belong to the topology");
                  return _labels[node];
                }
          catch(exception & e)
                {
                  throw Exception("getNodeName(): the operation did not succeed", e);
                }
          return _labels[node];
        }

        
        const Identifier & getConnectionLabel(Connection connection) const
        {
          try
                {
                  require(Exception,connection.valid(),"getConnectionLabel(): the connection is not valid");
                  require(Exception,&connection.owner() == &graph(),"getConnectionLabel(): the connection does not belong to the topology");
                  return _labels[connection];
                }
          catch(exception & e)
                {
                  throw Exception("setConnectionEventLabel(): the operation did not succeed", e);
                }
          return _labels[connection];
        } 

        void setConnectionLabel(Connection connection,const Identifier & label)
        {
          try
                {
                  require(Exception,connection.valid(),"setConnectionEventLabel(): the connection is not valid");
                  require(Exception,&connection.owner() == &graph(),"setConnectionEventLabel(): the connection does not belong to the topology");
                  _labels[connection]=label;
                }
          catch(exception & e)
                {
                  throw Exception("setConnectionEventLabel(): the operation did not succeed", e);
                }
        }
        
        struct CliqueIterator
        {
          typedef CliqueIterator   self;
          typedef ptrdiff_t difference_type;
          typedef std::forward_iterator_tag iterator_category;
          typedef Diades::Graph::Node   value_type;
          typedef const Diades::Graph::Node*  pointer;
          typedef const Diades::Graph::Node&  reference;
          typedef Diades::Graph::OutEdgeIterator SupportIterator;
          SupportIterator _it;
          
          
          CliqueIterator():_it(){}
          explicit CliqueIterator(SupportIterator it):_it(it){}
          reference operator*() const { return _it->targetRef(); }
          pointer operator->() const  { return &(_it->targetRef()); }
          self & operator++() { ++_it;  return *this; }
          self operator++(int) { self tmp = *this;      ++_it; return tmp; }
          bool operator==(const self & it) const { return _it == it._it; }
          bool operator !=(const self & it) const {     return !(*this == it); }
          Edge getSupport() const {     return *_it; }
        };
        
        typedef CliqueIterator NodeConnectionIterator;
        
  public:


        unsigned numberOfNodes() const
        {
          return _nodes.size();
        }

        unsigned numberOfConnections() const
        {
          return _connections.size();
        }


        
        bool isSimple(const Connection & connection) const
        {
          require(Exception, connection.valid() && (&connection.owner() == &graph()), "isSimple(): the connection is invalid");
          try
                {
                  return connection.outDeg() == 2;
                }
          catch(exception & e)
                {
                  throw Exception("isSimple(): the operation did not succeed", e);
                }
          return false;
        }

        Connection addConnection(Node n1, Node n2);


        Connection addConnection(Node n1, Node n2,const Identifier & label);


        unsigned cliqueSize(Connection connection) const
        {
          return connection.outDeg();
        }


        
        CliqueIterator cliqueBegin(Connection connection) const
        {
          try
                {
                  require(Exception, connection.valid() && (&connection.owner() == &graph()), "cliqueBegin(): the connection is invalid");
                  return CliqueIterator(connection.outEdgeBegin());
                }
          catch(exception & e)
                {
                  throw Exception("cliqueBegin(): the operation did not succeed", e);
                }         
          return CliqueIterator(connection.outEdgeBegin());
        }
        CliqueIterator cliqueEnd(Connection connection) const
        {
          try
                {
                  require(Exception, connection.valid() && (&connection.owner() == &graph()), "cliqueEnd: the connection is invalid");
                  
                  return CliqueIterator(connection.outEdgeEnd());

                }
          catch(exception & e)
                {
                  throw Exception("cliqueEnd(): the operation did not succeed", e);
                }         

          return CliqueIterator(connection.outEdgeEnd());
        }


        
        ConnectionIterator connectionBegin() const
        {
          return _connections.begin();
        }
        ConnectionIterator connectionEnd() const
        {
          return _connections.end();
        }

        Topology():_graph(),_connections(),_nodes(),_labels()
        {
          _labels.init(_graph);
        }

        virtual ~Topology()
        {
        }
        

        unsigned nbConnections(const Node & n1, const Node & n2) const;


        unsigned connectivity(const Node & n) const;

        
        unsigned structuralConnectivity(const Node & n) const;



        bool isConnected(const Node & n1, const Node & n2) const;

        void getConnections(const Node & n1, const Node & n2, list<Connection> & connections) const;
        
        
        Connection addClique(const set<Node> & clique);

        Node addNode()
        {
          Node result;
          try
                {
                  result = _graph.newNode();
                  _nodes.insert(result);
                  stringstream stream;
                  stream << "n" << result.id();
                  _labels[result] = Identifier(stream.str());
                  ensure(Exception, result.valid() && (&result.owner() == &graph()), "addNode: the returned node is invalid");
                }
          catch(exception & e)
                {
                  throw Exception("addNode: cannot add a new node to the topology");
                }
          return result;
        }

        
        Node addNode(const Identifier & name)
        {
          Node result;
          try
                {
                  result = _graph.newNode();
                  _nodes.insert(result);
                  _labels[result] = name;
                  ensure(Exception, result.valid() && (&result.owner() == &graph()), "addNode: the returned node is invalid");
                }
          catch(exception & e)
                {
                  throw Exception("addNode: cannot add a new node to the topology");
                }
          return result;
        }

        NodeIterator nodeBegin() const
        {
          return _nodes.begin();
        }
        NodeIterator nodeEnd() const
        {
          return _nodes.end();
        }

        NodeConnectionIterator nodeConnectionBegin(Node n) const
        {
          try
                {
                  require(Exception, n.valid() && (&n.owner() == &graph()), "nodeConnectionBegin: the node is invalid");
                  return NodeConnectionIterator(n.outEdgeBegin());
                }
          catch(exception & e)
                {
                  throw Exception("nodeConnectionBegin(): cannot get an iterator about the connection of a node",e);
                }
          return NodeConnectionIterator(n.outEdgeBegin());
        }
        NodeConnectionIterator nodeConnectionEnd(Node n) const
        {
          try
                {
                  require(Exception, n.valid() && (&n.owner() == &graph()), "nodeConnectionEnd: the node is invalid");
                  return NodeConnectionIterator(n.outEdgeEnd());
                }
catch(exception & e)
                {
                  throw Exception("nodeConnectionEnd(): cannot get an iterator about the connection of a node",e);
                }
          return NodeConnectionIterator(n.outEdgeEnd());
        }
        void removeConnection(Connection connection)
        {
          require(Exception, connection.valid() && (&connection.owner() == &graph()), "removeConnection: the connection is invalid");
          _connections.erase(connection);
          _graph.deleteNode(connection);
        }

        void removeNode(Node n);

        void topology2dot(const string & fileName);

        void clear();
  
        void import(const string & fileName);

        
        void save(const string & fileName);

        bool valid() const
        {
          return numberOfNodes() > 0;
        }
        
        bool operator==(const Topology & topology) const
        {
          return this == &topology;
        }


        bool contains(Node node) const
        {
          require(Exception, node.valid(),"contains(): invalid node");
          try
                {
                  return &node.owner() == &graph();               
                }
          catch(exception & e)
                {
                  throw Exception("contains(): the operation did not succeed",e);
                }
          return false;
        }

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


  /************************ UTILS ***************************************/

  Topology::Connection getConnection(const Topology & topology, const  set<Topology::Node> & clique,
                                                                         const Identifier & connectionEventLabel);
  
};
};

#endif