Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 2384)
+++ lemon/graph_adaptor.h	(revision 2386)
@@ -94,7 +94,7 @@
 
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& source, const Node& target, 
+    Edge findEdge(const Node& u, const Node& v, 
 		  const Edge& prev = INVALID) {
-      return graph->findEdge(source, target, prev);
+      return graph->findEdge(u, v, prev);
     }
   
@@ -103,6 +103,6 @@
     }
 
-    Edge addEdge(const Node& source, const Node& target) const { 
-      return Edge(graph->addEdge(source, target)); 
+    Edge addEdge(const Node& u, const Node& v) const { 
+      return Edge(graph->addEdge(u, v)); 
     }
 
@@ -115,10 +115,10 @@
     int id(const Edge& e) const { return graph->id(e); }
 
-    Node fromNodeId(int id) const {
-      return graph->fromNodeId(id);
-    }
-
-    Edge fromEdgeId(int id) const {
-      return graph->fromEdgeId(id);
+    Node fromNodeId(int ix) const {
+      return graph->fromNodeId(ix);
+    }
+
+    Edge fromEdgeId(int ix) const {
+      return graph->fromEdgeId(ix);
     }
 
@@ -244,7 +244,7 @@
 
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-    Edge findEdge(const Node& source, const Node& target, 
+    Edge findEdge(const Node& u, const Node& v, 
 		  const Edge& prev = INVALID) {
-      return Parent::findEdge(target, source, prev);
+      return Parent::findEdge(v, u, prev);
     }
 
@@ -461,8 +461,8 @@
                              template NodeMap<_Value> > Parent;
     
-      NodeMap(const Graph& graph) 
-	: Parent(graph) {}
-      NodeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      NodeMap(const Graph& g) 
+	: Parent(g) {}
+      NodeMap(const Graph& g, const _Value& v) 
+	: Parent(g, v) {}
     
       NodeMap& operator=(const NodeMap& cmap) {
@@ -487,8 +487,8 @@
                              template EdgeMap<_Value> > Parent;
     
-      EdgeMap(const Graph& graph) 
-	: Parent(graph) {}
-      EdgeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      EdgeMap(const Graph& g) 
+	: Parent(g) {}
+      EdgeMap(const Graph& g, const _Value& v) 
+	: Parent(g, v) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -634,8 +634,8 @@
                              template NodeMap<_Value> > Parent;
     
-      NodeMap(const Graph& graph) 
-	: Parent(graph) {}
-      NodeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      NodeMap(const Graph& g) 
+	: Parent(g) {}
+      NodeMap(const Graph& g, const _Value& v) 
+	: Parent(g, v) {}
     
       NodeMap& operator=(const NodeMap& cmap) {
@@ -660,8 +660,8 @@
                              template EdgeMap<_Value> > Parent;
     
-      EdgeMap(const Graph& graph) 
-	: Parent(graph) {}
-      EdgeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      EdgeMap(const Graph& g) 
+	: Parent(g) {}
+      EdgeMap(const Graph& g, const _Value& v) 
+	: Parent(g, v) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -1106,8 +1106,8 @@
       typedef SubMapExtender<Adaptor, EdgeMapBase<_Value> > Parent;
     
-      EdgeMap(const Graph& graph) 
-	: Parent(graph) {}
-      EdgeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      EdgeMap(const Graph& g) 
+	: Parent(g) {}
+      EdgeMap(const Graph& g, const _Value& v) 
+	: Parent(g, v) {}
     
       EdgeMap& operator=(const EdgeMap& cmap) {
@@ -1181,7 +1181,7 @@
       : Parent(), edge_notifier(*this), edge_notifier_proxy(*this) {}
 
-    void setGraph(_Graph& graph) {
-      Parent::setGraph(graph);
-      edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
+    void setGraph(_Graph& g) {
+      Parent::setGraph(g);
+      edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
     }
 
@@ -1221,6 +1221,6 @@
       }
 
-      void setNotifier(typename Graph::EdgeNotifier& notifier) {
-        Parent::attach(notifier);
+      void setNotifier(typename Graph::EdgeNotifier& nf) {
+        Parent::attach(nf);
       }
 
@@ -1236,5 +1236,5 @@
       virtual void add(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) { 
+        for (int i = 0; i < int(ge.size()); ++i) { 
           edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
           edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
@@ -1250,5 +1250,5 @@
       virtual void erase(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) { 
+        for (int i = 0; i < int(ge.size()); ++i) { 
           edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
           edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
@@ -1822,94 +1822,94 @@
     };
 
-    void first(Node& node) const {
-      Parent::first(node);
-      node.in_node = true;
-    }
-
-    void next(Node& node) const {
-      if (node.in_node) {
-	node.in_node = false;
+    void first(Node& n) const {
+      Parent::first(n);
+      n.in_node = true;
+    }
+
+    void next(Node& n) const {
+      if (n.in_node) {
+	n.in_node = false;
       } else {
-	node.in_node = true;
-	Parent::next(node);
-      }
-    }
-
-    void first(Edge& edge) const {
-      edge.item.setSecond();
-      Parent::first(edge.item.second());
-      if (edge.item.second() == INVALID) {
-        edge.item.setFirst();
-	Parent::first(edge.item.first());
-      }
-    }
-
-    void next(Edge& edge) const {
-      if (edge.item.secondState()) {
-	Parent::next(edge.item.second());
-        if (edge.item.second() == INVALID) {
-          edge.item.setFirst();
-          Parent::first(edge.item.first());
+	n.in_node = true;
+	Parent::next(n);
+      }
+    }
+
+    void first(Edge& e) const {
+      e.item.setSecond();
+      Parent::first(e.item.second());
+      if (e.item.second() == INVALID) {
+        e.item.setFirst();
+	Parent::first(e.item.first());
+      }
+    }
+
+    void next(Edge& e) const {
+      if (e.item.secondState()) {
+	Parent::next(e.item.second());
+        if (e.item.second() == INVALID) {
+          e.item.setFirst();
+          Parent::first(e.item.first());
         }
       } else {
-	Parent::next(edge.item.first());
+	Parent::next(e.item.first());
       }      
     }
 
-    void firstOut(Edge& edge, const Node& node) const {
-      if (node.in_node) {
-        edge.item.setSecond(node);
+    void firstOut(Edge& e, const Node& n) const {
+      if (n.in_node) {
+        e.item.setSecond(n);
       } else {
-        edge.item.setFirst();
-	Parent::firstOut(edge.item.first(), node);
-      }
-    }
-
-    void nextOut(Edge& edge) const {
-      if (!edge.item.firstState()) {
-	edge.item.setFirst(INVALID);
+        e.item.setFirst();
+	Parent::firstOut(e.item.first(), n);
+      }
+    }
+
+    void nextOut(Edge& e) const {
+      if (!e.item.firstState()) {
+	e.item.setFirst(INVALID);
       } else {
-	Parent::nextOut(edge.item.first());
+	Parent::nextOut(e.item.first());
       }      
     }
 
-    void firstIn(Edge& edge, const Node& node) const {
-      if (!node.in_node) {
-        edge.item.setSecond(node);        
+    void firstIn(Edge& e, const Node& n) const {
+      if (!n.in_node) {
+        e.item.setSecond(n);        
       } else {
-        edge.item.setFirst();
-	Parent::firstIn(edge.item.first(), node);
-      }
-    }
-
-    void nextIn(Edge& edge) const {
-      if (!edge.item.firstState()) {
-	edge.item.setFirst(INVALID);
+        e.item.setFirst();
+	Parent::firstIn(e.item.first(), n);
+      }
+    }
+
+    void nextIn(Edge& e) const {
+      if (!e.item.firstState()) {
+	e.item.setFirst(INVALID);
       } else {
-	Parent::nextIn(edge.item.first());
-      }
-    }
-
-    Node source(const Edge& edge) const {
-      if (edge.item.firstState()) {
-	return Node(Parent::source(edge.item.first()), false);
+	Parent::nextIn(e.item.first());
+      }
+    }
+
+    Node source(const Edge& e) const {
+      if (e.item.firstState()) {
+	return Node(Parent::source(e.item.first()), false);
       } else {
-	return Node(edge.item.second(), true);
-      }
-    }
-
-    Node target(const Edge& edge) const {
-      if (edge.item.firstState()) {
-	return Node(Parent::target(edge.item.first()), true);
+	return Node(e.item.second(), true);
+      }
+    }
+
+    Node target(const Edge& e) const {
+      if (e.item.firstState()) {
+	return Node(Parent::target(e.item.first()), true);
       } else {
-	return Node(edge.item.second(), false);
-      }
-    }
-
-    int id(const Node& node) const {
-      return (Parent::id(node) << 1) | (node.in_node ? 0 : 1);
-    }
-    Node nodeFromId(int id) const {
-      return Node(Parent::nodeFromId(id >> 1), (id & 1) == 0);
+	return Node(e.item.second(), false);
+      }
+    }
+
+    int id(const Node& n) const {
+      return (Parent::id(n) << 1) | (n.in_node ? 0 : 1);
+    }
+    Node nodeFromId(int ix) const {
+      return Node(Parent::nodeFromId(ix >> 1), (ix & 1) == 0);
     }
     int maxNodeId() const {
@@ -1917,16 +1917,16 @@
     }
 
-    int id(const Edge& edge) const {
-      if (edge.item.firstState()) {
-        return Parent::id(edge.item.first()) << 1;
+    int id(const Edge& e) const {
+      if (e.item.firstState()) {
+        return Parent::id(e.item.first()) << 1;
       } else {
-        return (Parent::id(edge.item.second()) << 1) | 1;
-      }
-    }
-    Edge edgeFromId(int id) const {
-      if ((id & 1) == 0) {
-        return Edge(Parent::edgeFromId(id >> 1));
+        return (Parent::id(e.item.second()) << 1) | 1;
+      }
+    }
+    Edge edgeFromId(int ix) const {
+      if ((ix & 1) == 0) {
+        return Edge(Parent::edgeFromId(ix >> 1));
       } else {
-        return Edge(Parent::nodeFromId(id >> 1));
+        return Edge(Parent::nodeFromId(ix >> 1));
       }
     }
@@ -1939,6 +1939,6 @@
     ///
     /// Returns true when the node is in-node.
-    static bool inNode(const Node& node) {
-      return node.in_node;
+    static bool inNode(const Node& n) {
+      return n.in_node;
     }
 
@@ -1946,6 +1946,6 @@
     ///
     /// Returns true when the node is out-node.
-    static bool outNode(const Node& node) {
-      return !node.in_node;
+    static bool outNode(const Node& n) {
+      return !n.in_node;
     }
 
@@ -1953,6 +1953,6 @@
     ///
     /// Returns true when the edge is edge in the original graph.
-    static bool origEdge(const Edge& edge) {
-      return edge.item.firstState();
+    static bool origEdge(const Edge& e) {
+      return e.item.firstState();
     }
 
@@ -1960,6 +1960,6 @@
     ///
     /// Returns true when the edge binds an in-node and an out-node.
-    static bool bindEdge(const Edge& edge) {
-      return edge.item.secondState();
+    static bool bindEdge(const Edge& e) {
+      return e.item.secondState();
     }
 
@@ -1967,6 +1967,6 @@
     ///
     /// Gives back the in-node created from the \c node.
-    static Node inNode(const GraphNode& node) {
-      return Node(node, true);
+    static Node inNode(const GraphNode& n) {
+      return Node(n, true);
     }
 
@@ -1974,6 +1974,6 @@
     ///
     /// Gives back the out-node created from the \c node.
-    static Node outNode(const GraphNode& node) {
-      return Node(node, false);
+    static Node outNode(const GraphNode& n) {
+      return Node(n, false);
     }
 
@@ -1981,6 +1981,6 @@
     /// 
     /// Gives back the edge binds the two part of the node.
-    static Edge edge(const GraphNode& node) {
-      return Edge(node);
+    static Edge edge(const GraphNode& n) {
+      return Edge(n);
     }
 
@@ -1988,6 +1988,6 @@
     /// 
     /// Gives back the edge of the original edge.
-    static Edge edge(const GraphEdge& edge) {
-      return Edge(edge);
+    static Edge edge(const GraphEdge& e) {
+      return Edge(e);
     }
 
@@ -2006,15 +2006,16 @@
     typedef True FindEdgeTag;
 
-    Edge findEdge(const Node& source, const Node& target, 
+    Edge findEdge(const Node& u, const Node& v, 
 		  const Edge& prev = INVALID) const {
-      if (inNode(source)) {
-        if (outNode(target)) {
-          if ((GraphNode&)source == (GraphNode&)target && prev == INVALID) {
-            return Edge(source);
+      if (inNode(u)) {
+        if (outNode(v)) {
+          if (static_cast<const GraphNode&>(u) == 
+              static_cast<const GraphNode&>(v) && prev == INVALID) {
+            return Edge(u);
           }
         }
       } else {
-        if (inNode(target)) {
-          return Edge(findEdge(*Parent::graph, source, target, prev));
+        if (inNode(v)) {
+          return Edge(findEdge(*Parent::graph, u, v, prev));
         }
       }
@@ -2192,5 +2193,5 @@
       virtual void add(const std::vector<GraphNode>& gn) {
         std::vector<Node> nodes;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
           nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
@@ -2208,5 +2209,5 @@
       virtual void erase(const std::vector<GraphNode>& gn) {
         std::vector<Node> nodes;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
           nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
@@ -2254,8 +2255,8 @@
         node_notifier_proxy(*this), edge_notifier_proxy(*this) {}
     
-    void setGraph(_Graph& graph) {
-      Parent::setGraph(graph);
-      node_notifier_proxy.setNotifier(graph.notifier(GraphNode()));
-      edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
+    void setGraph(_Graph& g) {
+      Parent::setGraph(g);
+      node_notifier_proxy.setNotifier(g.notifier(GraphNode()));
+      edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
     }
 
@@ -2308,5 +2309,5 @@
         std::vector<Node> nodes;
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           edges.push_back(AdaptorBase::Parent::edge(gn[i]));
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
@@ -2326,5 +2327,5 @@
         std::vector<Node> nodes;
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)gn.size(); ++i) {
+        for (int i = 0; i < int(gn.size()); ++i) {
           edges.push_back(AdaptorBase::Parent::edge(gn[i]));
           nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
@@ -2336,7 +2337,7 @@
       virtual void build() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphNode it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2346,7 +2347,7 @@
       virtual void clear() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphNode it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2386,5 +2387,5 @@
       virtual void add(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) {
+        for (int i = 0; i < int(ge.size()); ++i) {
           edges.push_back(AdaptorBase::edge(ge[i]));
         }
@@ -2396,5 +2397,5 @@
       virtual void erase(const std::vector<GraphEdge>& ge) {
         std::vector<Edge> edges;
-        for (int i = 0; i < (int)ge.size(); ++i) {
+        for (int i = 0; i < int(ge.size()); ++i) {
           edges.push_back(AdaptorBase::edge(ge[i]));
         }
@@ -2403,7 +2404,7 @@
       virtual void build() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphEdge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2412,7 +2413,7 @@
       virtual void clear() {
         std::vector<Edge> edges;
-        const typename Parent::Notifier* notifier = Parent::notifier();
+        const typename Parent::Notifier* nf = Parent::notifier();
         GraphEdge it;
-        for (notifier->first(it); it != INVALID; notifier->next(it)) {
+        for (nf->first(it); it != INVALID; nf->next(it)) {
           edges.push_back(AdaptorBase::Parent::edge(it));
         }
@@ -2510,6 +2511,6 @@
     ///
     /// Constructor of the adaptor.
-    SplitGraphAdaptor(_Graph& graph) {
-      Parent::setGraph(graph);
+    SplitGraphAdaptor(_Graph& g) {
+      Parent::setGraph(g);
     }
 
