# HG changeset patch
# User hegyi
# Date 1089045858 0
# Node ID 014c2e4eb07b895f6cdef6c48e277312d5ca0ac4
# Parent  a0f95e1b17fc970c11a48b31c38fd74342431d93
t/bin/bash: line 1: q: command not found
-j-This line, and those below, will be ignored--

M    peter/hierarchygraph.h

diff -r a0f95e1b17fc -r 014c2e4eb07b src/work/peter/hierarchygraph.h
--- a/src/work/peter/hierarchygraph.h	Mon Jul 05 15:52:35 2004 +0000
+++ b/src/work/peter/hierarchygraph.h	Mon Jul 05 16:44:18 2004 +0000
@@ -9,7 +9,8 @@
 #include <hugo/maps.h>
 
 /// The namespace of HugoLib
-namespace hugo {
+namespace hugo
+{
 
   // @defgroup empty_graph The HierarchyGraph class
   // @{
@@ -21,8 +22,7 @@
   /// means that a node in one layer can be a complete network in a nother
   /// layer.
 
-  template <class Gact, class Gsub>
-  class HierarchyGraph
+  template < class Gact, class Gsub > class HierarchyGraph
   {
 
   public:
@@ -39,138 +39,159 @@
 
       struct actedgesubnodestruct
       {
-        typename Gact::Edge actedge;
-        typename Gsub::Node subnode;
+	typename Gact::Edge actedge;
+	typename Gsub::Node subnode;
       };
 
       int edgenumber;
       bool connectable;
-      Gact * actuallayer;
+      Gact *actuallayer;
       typename Gact::Node * actuallayernode;
-      Gsub * subnetwork;
-      actedgesubnodestruct * assignments;
+      Gsub *subnetwork;
+      actedgesubnodestruct *assignments;
 
     public:
 
-      int addAssignment(typename Gact::Edge actedge, typename Gsub::Node subnode)
+      int addAssignment (typename Gact::Edge actedge,
+			 typename Gsub::Node subnode)
       {
-	if(!(actuallayer->valid(actedge)))
-	{
-	  cerr << "The given edge is not in the given network!" << endl;
-	  return -1;
-	}
-	else if(
-	   (actuallayer->id(actuallayer->tail(actedge))!=actuallayer->id(*actuallayernode))
-	   &&
-	   (actuallayer->id(actuallayer->head(actedge))!=actuallayer->id(*actuallayernode))
-	  )
-	{
-	  cerr << "The given edge does not connect to the given node!" << endl;
-	  return -1;
-	}
+	if (!(actuallayer->valid (actedge)))
+	  {
+	    cerr << "The given edge is not in the given network!" << endl;
+	    return -1;
+	  }
+	else if ((actuallayer->id (actuallayer->tail (actedge)) !=
+		  actuallayer->id (*actuallayernode))
+		 && (actuallayer->id (actuallayer->head (actedge)) !=
+		     actuallayer->id (*actuallayernode)))
+	  {
+	    cerr << "The given edge does not connect to the given node!" <<
+	      endl;
+	    return -1;
+	  }
 
-	if(!(subnetwork->valid(subnode)))
-	{
-	  cerr << "The given node is not in the given network!" << endl;
-	  return -1;
-	}
+	if (!(subnetwork->valid (subnode)))
+	  {
+	    cerr << "The given node is not in the given network!" << endl;
+	    return -1;
+	  }
 
-	int i=0;
+	int i = 0;
 	//while in the array there is valid note that is not equvivalent with the one that would be noted increase i
-	while( (i<edgenumber) && (actuallayer->valid(assignments[i].actedge) ) && (assignments[i].actedge!=actedge) ) i++;
-	if(assignments[i].actedge==actedge)
-	{
-	  cout << "Warning: Redefinement of assigment!!!" << endl;
-	}
-	if(i==edgenumber)
-	{
-	  cout << "This case can't be!!! (because there should be the guven edge in the array already and the cycle had to stop)" << endl;
-	}
+	while ((i < edgenumber)
+	       && (actuallayer->valid (assignments[i].actedge))
+	       && (assignments[i].actedge != actedge))
+	  i++;
+	if (assignments[i].actedge == actedge)
+	  {
+	    cout << "Warning: Redefinement of assigment!!!" << endl;
+	  }
+	if (i == edgenumber)
+	  {
+	    cout <<
+	      "This case can't be!!! (because there should be the guven edge in the array already and the cycle had to stop)"
+	      << endl;
+	  }
 	//if(!(actuallayer->valid(assignments[i].actedge)))   //this condition is necessary if we do not obey redefinition
 	{
-	  assignments[i].actedge=actedge;
-	  assignments[i].subnode=subnode;
+	  assignments[i].actedge = actedge;
+	  assignments[i].subnode = subnode;
 	}
 
 	/// If to all of the edges a subnode is assigned then the subnetwork is connectable (attachable?)
 	/// We do not need to check for further attributes, because to notice an assignment we need
 	/// all of them to be correctly initialised before.
-	if(i==edgenumber-1)connectable=1;
+	if (i == edgenumber - 1)
+	  connectable = 1;
 
 	return 0;
       }
 
-      int setSubNetwork(Gsub * sn)
+      int setSubNetwork (Gsub * sn)
       {
-	subnetwork=sn;
+	subnetwork = sn;
 	return 0;
       }
 
-      int setActualLayer(Gact * al)
+      int setActualLayer (Gact * al)
       {
-	actuallayer=al;
+	actuallayer = al;
 	return 0;
       }
 
-      int setActualLayerNode(typename Gact::Node * aln)
+      int setActualLayerNode (typename Gact::Node * aln)
       {
 	typename Gact::InEdgeIt iei;
 	typename Gact::OutEdgeIt oei;
 
-	actuallayernode=aln;
+	actuallayernode = aln;
 
-	edgenumber=0;
+	edgenumber = 0;
 
-	if(actuallayer)
-	{
-	  for(iei=actuallayer->first(iei,(*actuallayernode));((actuallayer->valid(iei))&&(actuallayer->head(iei)==(*actuallayernode)));actuallayer->next(iei))
+	if (actuallayer)
 	  {
-	    cout << actuallayer->id(actuallayer->tail(iei)) << " " << actuallayer->id(actuallayer->head(iei)) << endl;
-	    edgenumber++;
+	    for (iei = actuallayer->first (iei, (*actuallayernode));
+		 ((actuallayer->valid (iei))
+		  && (actuallayer->head (iei) == (*actuallayernode)));
+		 actuallayer->next (iei))
+	      {
+		cout << actuallayer->id (actuallayer->
+					 tail (iei)) << " " << actuallayer->
+		  id (actuallayer->head (iei)) << endl;
+		edgenumber++;
+	      }
+	    //cout << "Number of in-edges: " << edgenumber << endl;
+	    for (oei = actuallayer->first (oei, (*actuallayernode));
+		 ((actuallayer->valid (oei))
+		  && (actuallayer->tail (oei) == (*actuallayernode)));
+		 actuallayer->next (oei))
+	      {
+		cout << actuallayer->id (actuallayer->
+					 tail (oei)) << " " << actuallayer->
+		  id (actuallayer->head (oei)) << endl;
+		edgenumber++;
+	      }
+	    //cout << "Number of in+out-edges: " << edgenumber << endl;
+	    assignments = new actedgesubnodestruct[edgenumber];
+	    for (int i = 0; i < edgenumber; i++)
+	      {
+		assignments[i].actedge = INVALID;
+		assignments[i].subnode = INVALID;
+	      }
 	  }
-	  //cout << "Number of in-edges: " << edgenumber << endl;
-	  for(oei=actuallayer->first(oei,(*actuallayernode));((actuallayer->valid(oei))&&(actuallayer->tail(oei)==(*actuallayernode)));actuallayer->next(oei))
+	else
 	  {
-	    cout << actuallayer->id(actuallayer->tail(oei)) << " " << actuallayer->id(actuallayer->head(oei)) << endl;
-	    edgenumber++;
+	    cerr << "There is no actual layer defined yet!" << endl;
+	    return -1;
 	  }
-	  //cout << "Number of in+out-edges: " << edgenumber << endl;
-	  assignments=new actedgesubnodestruct[edgenumber];
-	  for(int i=0;i<edgenumber;i++)
-	  {
-	    assignments[i].actedge=INVALID;
-	    assignments[i].subnode=INVALID;
-	  }
-	}
-	else
-	{
-	  cerr << "There is no actual layer defined yet!" << endl;
-	  return -1;
-	}
 
 	return 0;
       }
 
-      SubNetwork(): edgenumber(0), connectable(false), actuallayer(NULL), actuallayernode(NULL), subnetwork(NULL), assignments(NULL)
+    SubNetwork ():edgenumber (0), connectable (false), actuallayer (NULL),
+	actuallayernode (NULL), subnetwork (NULL),
+	assignments (NULL)
       {
       }
 
     };
 
-    typename Gact::template NodeMap< SubNetwork > subnetworks;
+    typename Gact::template NodeMap < SubNetwork > subnetworks;
 
 
     /// Defalult constructor.
     /// We don't need any extra lines, because the actuallayer
     /// variable has run its constructor, when we have created this class
     /// So only the two maps has to be initialised here.
-    HierarchyGraph() : subnetworks(actuallayer)
+  HierarchyGraph ():subnetworks (actuallayer)
     {
     }
 
 
     ///Copy consructor.
-    HierarchyGraph(const HierarchyGraph<Gact, Gsub> & HG ) : actuallayer(HG.actuallayer), subnetworks(actuallayer)
+  HierarchyGraph (const HierarchyGraph < Gact, Gsub > &HG):actuallayer (HG.actuallayer),
+      subnetworks
+      (actuallayer)
     {
     }
 
@@ -197,7 +218,7 @@
 
     /// The base type of the edge iterators.
     /// The Edge type of the HierarchyGraph is the Edge type of the actual layer.
-    typedef typename  Gact::Edge Edge;
+    typedef typename Gact::Edge Edge;
 
 
     /// This iterator goes trough the outgoing edges of a node.
@@ -247,20 +268,34 @@
 
     /// \retval i the first node.
     /// \return the first node.
-    typename Gact::NodeIt &first(typename Gact::NodeIt &i) const { return actuallayer.first(i);}
+    typename Gact::NodeIt & first (typename Gact::NodeIt & i) const
+    {
+      return actuallayer.first (i);
+    }
 
 
     /// The first incoming edge.
-    typename Gact::InEdgeIt &first(typename Gact::InEdgeIt &i, typename Gact::Node) const { return actuallayer.first(i);}
+    typename Gact::InEdgeIt & first (typename Gact::InEdgeIt & i,
+				     typename Gact::Node) const
+    {
+      return actuallayer.first (i);
+    }
 
 
     /// The first outgoing edge.
-    typename Gact::OutEdgeIt &first(typename Gact::OutEdgeIt &i, typename Gact::Node) const { return actuallayer.first(i);}
+    typename Gact::OutEdgeIt & first (typename Gact::OutEdgeIt & i,
+				      typename Gact::Node) const
+    {
+      return actuallayer.first (i);
+    }
 
 
     //  SymEdgeIt &first(SymEdgeIt &, Node) const { return i;}
     /// The first edge of the Graph.
-    typename Gact::EdgeIt &first(typename Gact::EdgeIt &i) const { return actuallayer.first(i);}
+    typename Gact::EdgeIt & first (typename Gact::EdgeIt & i) const
+    {
+      return actuallayer.first (i);
+    }
 
 
 //     Node getNext(Node) const {}
@@ -271,19 +306,37 @@
 
 
     /// Go to the next node.
-    typename Gact::NodeIt &next(typename Gact::NodeIt &i) const { return actuallayer.next(i);}
+    typename Gact::NodeIt & next (typename Gact::NodeIt & i) const
+    {
+      return actuallayer.next (i);
+    }
     /// Go to the next incoming edge.
-    typename Gact::InEdgeIt &next(typename Gact::InEdgeIt &i) const { return actuallayer.next(i);}
+    typename Gact::InEdgeIt & next (typename Gact::InEdgeIt & i) const
+    {
+      return actuallayer.next (i);
+    }
     /// Go to the next outgoing edge.
-    typename Gact::OutEdgeIt &next(typename Gact::OutEdgeIt &i) const { return actuallayer.next(i);}
+    typename Gact::OutEdgeIt & next (typename Gact::OutEdgeIt & i) const
+    {
+      return actuallayer.next (i);
+    }
     //SymEdgeIt &next(SymEdgeIt &) const {}
     /// Go to the next edge.
-    typename Gact::EdgeIt &next(typename Gact::EdgeIt &i) const { return actuallayer.next(i);}
+    typename Gact::EdgeIt & next (typename Gact::EdgeIt & i) const
+    {
+      return actuallayer.next (i);
+    }
 
     ///Gives back the head node of an edge.
-    typename Gact::Node head(typename Gact::Edge edge) const { return actuallayer.head(edge); }
+    typename Gact::Node head (typename Gact::Edge edge) const
+    {
+      return actuallayer.head (edge);
+    }
     ///Gives back the tail node of an edge.
-    typename Gact::Node tail(typename Gact::Edge edge) const { return actuallayer.tail(edge); }
+    typename Gact::Node tail (typename Gact::Edge edge) const
+    {
+      return actuallayer.tail (edge);
+    }
 
     //   Node aNode(InEdgeIt) const {}
     //   Node aNode(OutEdgeIt) const {}
@@ -297,23 +350,35 @@
 
     ///\todo Maybe, it would be better if iterator converted to
     ///bool directly, as Jacint prefers.
-    bool valid(const typename Gact::Node& node) const { return actuallayer.valid(node);}
+    bool valid (const typename Gact::Node & node) const
+    {
+      return actuallayer.valid (node);
+    }
     /// Checks if an edge iterator is valid
 
     ///\todo Maybe, it would be better if iterator converted to
     ///bool directly, as Jacint prefers.
-    bool valid(const typename Gact::Edge& edge) const { return actuallayer.valid(edge);}
+    bool valid (const typename Gact::Edge & edge) const
+    {
+      return actuallayer.valid (edge);
+    }
 
     ///Gives back the \e id of a node.
 
     ///\warning Not all graph structures provide this feature.
     ///
-    int id(const typename Gact::Node & node) const { return actuallayer.id(node);}
+    int id (const typename Gact::Node & node) const
+    {
+      return actuallayer.id (node);
+    }
     ///Gives back the \e id of an edge.
 
     ///\warning Not all graph structures provide this feature.
     ///
-    int id(const typename Gact::Edge & edge) const { return actuallayer.id(edge);}
+    int id (const typename Gact::Edge & edge) const
+    {
+      return actuallayer.id (edge);
+    }
 
     //void setInvalid(Node &) const {};
     //void setInvalid(Edge &) const {};
@@ -322,22 +387,38 @@
 
     /// \return the new node.
     ///
-    typename Gact::Node addNode() { return actuallayer.addNode();}
+    typename Gact::Node addNode ()
+    {
+      return actuallayer.addNode ();
+    }
     ///Add a new edge to the graph.
 
     ///Add a new edge to the graph with tail node \c tail
     ///and head node \c head.
     ///\return the new edge.
-    typename Gact::Edge addEdge(typename Gact::Node node1, typename Gact::Node node2) { return actuallayer.addEdge(node1, node2);}
+    typename Gact::Edge addEdge (typename Gact::Node node1,
+				 typename Gact::Node node2)
+    {
+      return actuallayer.addEdge (node1, node2);
+    }
 
     /// Resets the graph.
 
     /// This function deletes all edges and nodes of the graph.
     /// It also frees the memory allocated to store them.
-    void clear() {actuallayer.clear();}
+    void clear ()
+    {
+      actuallayer.clear ();
+    }
 
-    int nodeNum() const { return actuallayer.nodeNum();}
-    int edgeNum() const { return actuallayer.edgeNum();}
+    int nodeNum () const
+    {
+      return actuallayer.nodeNum ();
+    }
+    int edgeNum () const
+    {
+      return actuallayer.edgeNum ();
+    }
 
     ///Read/write/reference map of the nodes to type \c T.
 
@@ -349,33 +430,51 @@
     /// \warning Making maps that can handle bool type (NodeMap<bool>)
     /// needs extra attention!
 
-    template<class T> class NodeMap
+    template < class T > class NodeMap
     {
     public:
       typedef T ValueType;
       typedef Node KeyType;
 
-      NodeMap(const HierarchyGraph &) {}
-      NodeMap(const HierarchyGraph &, T) {}
+      NodeMap (const HierarchyGraph &)
+      {
+      }
+      NodeMap (const HierarchyGraph &, T)
+      {
+      }
 
-      template<typename TT> NodeMap(const NodeMap<TT> &) {}
+      template < typename TT > NodeMap (const NodeMap < TT > &)
+      {
+      }
 
       /// Sets the value of a node.
 
       /// Sets the value associated with node \c i to the value \c t.
       ///
-      void set(Node, T) {}
+      void set (Node, T)
+      {
+      }
       // Gets the value of a node.
       //T get(Node i) const {return *(T*)0;}  //FIXME: Is it necessary?
-      T &operator[](Node) {return *(T*)0;}
-      const T &operator[](Node) const {return *(T*)0;}
+      T & operator[](Node)
+      {
+	return *(T *) 0;
+      }
+      const T & operator[] (Node) const
+      {
+	return *(T *) 0;
+      }
 
       /// Updates the map if the graph has been changed
 
       /// \todo Do we need this?
       ///
-      void update() {}
-      void update(T a) {}   //FIXME: Is it necessary
+      void update ()
+      {
+      }
+      void update (T a)
+      {
+      }				//FIXME: Is it necessary
     };
 
     ///Read/write/reference map of the edges to type \c T.
@@ -387,26 +486,44 @@
     /// \todo We may need copy constructor
     /// \todo We may need conversion from other edgetype
     /// \todo We may need operator=
-    template<class T> class EdgeMap
+    template < class T > class EdgeMap
     {
     public:
       typedef T ValueType;
       typedef Edge KeyType;
 
-      EdgeMap(const HierarchyGraph &) {}
-      EdgeMap(const HierarchyGraph &, T ) {}
+      EdgeMap (const HierarchyGraph &)
+      {
+      }
+      EdgeMap (const HierarchyGraph &, T)
+      {
+      }
 
       ///\todo It can copy between different types.
       ///
-      template<typename TT> EdgeMap(const EdgeMap<TT> &) {}
+      template < typename TT > EdgeMap (const EdgeMap < TT > &)
+      {
+      }
 
-      void set(Edge, T) {}
+      void set (Edge, T)
+      {
+      }
       //T get(Edge) const {return *(T*)0;}
-      T &operator[](Edge) {return *(T*)0;}
-      const T &operator[](Edge) const {return *(T*)0;}
+      T & operator[](Edge)
+      {
+	return *(T *) 0;
+      }
+      const T & operator[] (Edge) const
+      {
+	return *(T *) 0;
+      }
 
-      void update() {}
-      void update(T a) {}   //FIXME: Is it necessary
+      void update ()
+      {
+      }
+      void update (T a)
+      {
+      }				//FIXME: Is it necessary
     };
   };
 
@@ -429,25 +546,36 @@
   /// feature, the documentation of a real graph imlementation
   /// like @ref ListGraph or
   /// @ref SmartGraph will just refer to this structure.
-  template <typename Gact, typename Gsub>
-  class EraseableHierarchyGraph : public HierarchyGraph<Gact, Gsub>
+template < typename Gact, typename Gsub > class EraseableHierarchyGraph:public HierarchyGraph < Gact,
+    Gsub
+    >
   {
   public:
     /// Deletes a node.
-    void erase(typename Gact::Node n) {actuallayer.erase(n);}
+    void erase (typename Gact::Node n)
+    {
+      actuallayer.erase (n);
+    }
     /// Deletes an edge.
-    void erase(typename Gact::Edge e) {actuallayer.erase(e);}
+    void erase (typename Gact::Edge e)
+    {
+      actuallayer.erase (e);
+    }
 
     /// Defalult constructor.
-    EraseableHierarchyGraph() {}
+    EraseableHierarchyGraph ()
+    {
+    }
     ///Copy consructor.
-    EraseableHierarchyGraph(const HierarchyGraph<Gact, Gsub> &EPG) {}
+    EraseableHierarchyGraph (const HierarchyGraph < Gact, Gsub > &EPG)
+    {
+    }
   };
 
 
   // @}
 
-} //namespace hugo
+}				//namespace hugo
 
 
 #endif // HUGO_SKELETON_GRAPH_H