diff -r fd991a24c857 -r a7eeb8af6b34 src/work/alpar/list_graph.h
--- a/src/work/alpar/list_graph.h	Mon May 03 14:43:49 2004 +0000
+++ b/src/work/alpar/list_graph.h	Mon May 03 17:06:38 2004 +0000
@@ -63,8 +63,8 @@
     protected:
       const ListGraph* G; 
     public:
-      virtual void add(const Key k) = NULL;
-      virtual void erase(const Key k) = NULL;
+      virtual void add(const Key k) = 0;
+      virtual void erase(const Key k) = 0;
       DynMapBase(const ListGraph &_G) : G(&_G) {}
       virtual ~DynMapBase() {}
       friend class ListGraph;
@@ -763,8 +763,8 @@
     protected:
       const NodeSet* G; 
     public:
-      virtual void add(const Key k) = NULL;
-      virtual void erase(const Key k) = NULL;
+      virtual void add(const Key k) = 0;
+      virtual void erase(const Key k) = 0;
       DynMapBase(const NodeSet &_G) : G(&_G) {}
       virtual ~DynMapBase() {}
       friend class NodeSet;
@@ -1152,8 +1152,10 @@
 
     NodeGraphType &G;
 
+  public:
     class Node;
-    
+
+  private:
     //Edges are double linked.
     //The free edges are only single linked using the "next_in" field.
     struct NodeT 
@@ -1170,7 +1172,7 @@
     };
 
     
-    typename NodeGraphType::NodeMap<NodeT> nodes;
+    typename NodeGraphType::template NodeMap<NodeT> nodes;
     
     std::vector<EdgeT> edges;
     //The first free edge
@@ -1183,8 +1185,8 @@
     protected:
       const EdgeSet* G; 
     public:
-      virtual void add(const Key k) = NULL;
-      virtual void erase(const Key k) = NULL;
+      virtual void add(const Key k) = 0;
+      virtual void erase(const Key k) = 0;
       DynMapBase(const EdgeSet &_G) : G(&_G) {}
       virtual ~DynMapBase() {}
       friend class EdgeSet;
@@ -1449,13 +1451,14 @@
         NodeIt m;
 	for(G.first(m);
 	    G.valid(m) && G.nodes[m].first_in == -1;  G.next(m));
-	n = G.valid(m)?-1:G.nodes[m].first_in;
+	//AJJAJ! This is a non sense!!!!!!!
+	this->n = G.valid(m)?-1:G.nodes[m].first_in;
       }
       EdgeIt (Invalid i) : Edge(i) { }
       EdgeIt() : Edge() { }
       ///\bug This is a workaround until somebody tells me how to
       ///make class \c SymEdgeSet::SymEdgeMap friend of Edge
-      int &idref() {return n;}
+      int &idref() {return this->n;}
     };
     
     class OutEdgeIt : public Edge {
@@ -1475,22 +1478,23 @@
       InEdgeIt(const EdgeSet& G,Node v) :Edge(nodes[v].first_in) { }
     };
 
-    template <typename T> class NodeMap : public NodeGraphType::NodeMap<T>
+    template <typename T> class NodeMap : 
+      public NodeGraphType::template NodeMap<T>
     {
     public:
       NodeMap(const EdgeSet &_G) :
-	NodeGraphType::NodeMap<T>(_G.G) { }
+        NodeGraphType::NodeMap(_G.G) { } //AJAJJ <T> would be wrong!!!
       NodeMap(const EdgeSet &_G,const T &t) :
-	NodeGraphType::NodeMap<T>(_G.G,t) { }
+	NodeGraphType::NodeMap(_G.G,t) { }
       //It is unnecessary
-      NodeMap(const typename NodeGraphType::NodeMap<T> &m)
-	: NodeGraphType::NodeMap<T>(m) { }
+      NodeMap(const typename NodeGraphType::template NodeMap<T> &m) :
+	NodeGraphType::NodeMap(m) { }
 
       ///\todo It can copy between different types.
       ///
       template<typename TT>
-      NodeMap(const typename NodeGraphType::NodeMap<TT> &m)
-	: NodeGraphType::NodeMap<T>(m) { }
+      NodeMap(const typename NodeGraphType::template NodeMap<TT> &m)
+	: NodeGraphType::NodeMap(m) { }
     };
     
     template <typename T> class EdgeMap : public DynMapBase<Edge>