Index: src/include/skeletons/graph.h
===================================================================
--- src/include/skeletons/graph.h	(revision 503)
+++ src/include/skeletons/graph.h	(revision 515)
@@ -88,5 +88,5 @@
       NodeIt(Invalid) {}
       /// Sets the iterator to the first node of \c G.
-      NodeIt(const GraphSkeleton &G) {}
+      NodeIt(const GraphSkeleton &) {}
       /// @warning The default constructor sets the iterator
       /// to an undefined value.
@@ -135,5 +135,5 @@
       ///@param n the node
       ///@param G the graph
-      OutEdgeIt(const GraphSkeleton & G, Node n) {}
+      OutEdgeIt(const GraphSkeleton &, Node) {}
     };
 
@@ -286,8 +286,8 @@
       typedef Node KeyType;
 
-      NodeMap(const GraphSkeleton &G) {}
-      NodeMap(const GraphSkeleton &G, T t) {}
-
-      template<typename TT> NodeMap(const NodeMap<TT> &m) {}
+      NodeMap(const GraphSkeleton &) {}
+      NodeMap(const GraphSkeleton &, T) {}
+
+      template<typename TT> NodeMap(const NodeMap<TT> &) {}
 
       /// Sets the value of a node.
@@ -324,10 +324,10 @@
       typedef Edge KeyType;
 
-      EdgeMap(const GraphSkeleton &G) {}
-      EdgeMap(const GraphSkeleton &G, T t) {}
+      EdgeMap(const GraphSkeleton &) {}
+      EdgeMap(const GraphSkeleton &, T ) {}
     
       ///\todo It can copy between different types.
       ///
-      template<typename TT> EdgeMap(const EdgeMap<TT> &m) {}
+      template<typename TT> EdgeMap(const EdgeMap<TT> &) {}
 
       void set(Edge, T) {}
Index: src/test/graph_test.cc
===================================================================
--- src/test/graph_test.cc	(revision 504)
+++ src/test/graph_test.cc	(revision 515)
@@ -109,9 +109,10 @@
   {
     Node k;
-    typename Graph::NodeMap<int> m(G);
-    typename Graph::NodeMap<int> const &cm = m;  //Const map
-    typename Graph::NodeMap<int> mdef(G,12); //Inicialize with default value
-    typename Graph::NodeMap<int> mm(cm);   //Copy
-    typename Graph::NodeMap<double> dm(cm); //Copy from another type
+    typename Graph::template NodeMap<int> m(G);
+    typename Graph::template NodeMap<int> const &cm = m;  //Const map
+    //Inicialize with default value
+    typename Graph::template NodeMap<int> mdef(G,12);
+    typename Graph::template NodeMap<int> mm(cm);   //Copy
+    typename Graph::template NodeMap<double> dm(cm); //Copy from another type
     int v;
     v=m[k]; m[k]=v; m.set(k,v);
@@ -123,9 +124,10 @@
   { //bool NodeMap
     Node k;
-    typename Graph::NodeMap<bool> m(G);
-    typename Graph::NodeMap<bool> const &cm = m;  //Const map
-    typename Graph::NodeMap<bool> mdef(G,12); //Inicialize with default value
-    typename Graph::NodeMap<bool> mm(cm);   //Copy
-    typename Graph::NodeMap<int> dm(cm); //Copy from another type
+    typename Graph::template NodeMap<bool> m(G);
+    typename Graph::template NodeMap<bool> const &cm = m;  //Const map
+    //Inicialize with default value
+    typename Graph::template NodeMap<bool> mdef(G,12);
+    typename Graph::template NodeMap<bool> mm(cm);   //Copy
+    typename Graph::template NodeMap<int> dm(cm); //Copy from another type
     bool v;
     v=m[k]; m[k]=v; m.set(k,v);
@@ -139,9 +141,10 @@
   {
     Edge k;
-    typename Graph::EdgeMap<int> m(G);
-    typename Graph::EdgeMap<int> const &cm = m;  //Const map
-    typename Graph::EdgeMap<int> mdef(G,12); //Inicialize with default value
-    typename Graph::EdgeMap<int> mm(cm);   //Copy
-    typename Graph::EdgeMap<double> dm(cm); //Copy from another type
+    typename Graph::template EdgeMap<int> m(G);
+    typename Graph::template EdgeMap<int> const &cm = m;  //Const map
+    //Inicialize with default value
+    typename Graph::template EdgeMap<int> mdef(G,12);
+    typename Graph::template EdgeMap<int> mm(cm);   //Copy
+    typename Graph::template EdgeMap<double> dm(cm); //Copy from another type
     int v;
     v=m[k]; m[k]=v; m.set(k,v);
@@ -153,9 +156,10 @@
   { //bool EdgeMap
     Edge k;
-    typename Graph::EdgeMap<bool> m(G);
-    typename Graph::EdgeMap<bool> const &cm = m;  //Const map
-    typename Graph::EdgeMap<bool> mdef(G,12); //Inicialize with default value
-    typename Graph::EdgeMap<bool> mm(cm);   //Copy
-    typename Graph::EdgeMap<int> dm(cm); //Copy from another type
+    typename Graph::template EdgeMap<bool> m(G);
+    typename Graph::template EdgeMap<bool> const &cm = m;  //Const map
+    //Inicialize with default value
+    typename Graph::template EdgeMap<bool> mdef(G,12);
+    typename Graph::template EdgeMap<bool> mm(cm);   //Copy
+    typename Graph::template EdgeMap<int> dm(cm); //Copy from another type
     bool v;
     v=m[k]; m[k]=v; m.set(k,v);
Index: src/work/alpar/list_graph.h
===================================================================
--- src/work/alpar/list_graph.h	(revision 508)
+++ src/work/alpar/list_graph.h	(revision 515)
@@ -64,6 +64,6 @@
       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() {}
@@ -764,6 +764,6 @@
       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() {}
@@ -1153,6 +1153,8 @@
     NodeGraphType &G;
 
+  public:
     class Node;
-    
+
+  private:
     //Edges are double linked.
     //The free edges are only single linked using the "next_in" field.
@@ -1171,5 +1173,5 @@
 
     
-    typename NodeGraphType::NodeMap<NodeT> nodes;
+    typename NodeGraphType::template NodeMap<NodeT> nodes;
     
     std::vector<EdgeT> edges;
@@ -1184,6 +1186,6 @@
       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() {}
@@ -1450,5 +1452,6 @@
 	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) { }
@@ -1456,5 +1459,5 @@
       ///\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;}
     };
     
@@ -1476,20 +1479,21 @@
     };
 
-    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) { }
     };
     
