Index: src/lemon/max_matching.h
===================================================================
--- src/lemon/max_matching.h	(revision 1090)
+++ src/lemon/max_matching.h	(revision 1093)
@@ -19,6 +19,6 @@
 
 #include <queue>
-#include <invalid.h>
-#include <unionfind.h>
+#include <lemon/invalid.h>
+#include <lemon/unionfind.h>
 #include <lemon/graph_utils.h>
 
@@ -82,10 +82,10 @@
     static const int HEUR_density=2;
     const Graph& g;
-    typename Graph::template NodeMap<Node> mate;
+    typename Graph::template NodeMap<Node> _mate;
     typename Graph::template NodeMap<pos_enum> position;
      
   public:
     
-    MaxMatching(const Graph& _g) : g(_g), mate(_g,INVALID), position(_g) {}
+    MaxMatching(const Graph& _g) : g(_g), _mate(_g,INVALID), position(_g) {}
 
     ///Runs Edmonds' algorithm.
@@ -120,4 +120,12 @@
     ///
     void resetMatching();
+
+    ///Returns the mate of a node in the actual matching.
+
+    ///Returns the mate of a \c node in the actual matching. 
+    ///Returns INVALID if the \c node is not covered by the actual matching. 
+    Node mate(Node& node) const {
+      return _mate[node];
+    } 
 
     ///Reads a matching from a \c Node map of \c Nodes.
@@ -129,5 +137,5 @@
     void readNMapNode(NMapN& map) {
       for(NodeIt v(g); v!=INVALID; ++v) {
-	mate.set(v,map[v]);   
+	_mate.set(v,map[v]);   
       } 
     } 
@@ -141,5 +149,5 @@
     void writeNMapNode (NMapN& map) const {
       for(NodeIt v(g); v!=INVALID; ++v) {
-	map.set(v,mate[v]);   
+	map.set(v,_mate[v]);   
       } 
     } 
@@ -156,5 +164,5 @@
 	Edge e=map[v];
 	if ( g.valid(e) )
-	  g.source(e) == v ? mate.set(v,g.target(e)) : mate.set(v,g.source(e)); 
+	  g.source(e) == v ? _mate.set(v,g.target(e)) : _mate.set(v,g.source(e)); 
       } 
     } 
@@ -170,6 +178,6 @@
       typename Graph::template NodeMap<bool> todo(g,true); 
       for(NodeIt v(g); v!=INVALID; ++v) {
-	if ( todo[v] && mate[v]!=INVALID ) {
-	  Node u=mate[v];
+	if ( todo[v] && _mate[v]!=INVALID ) {
+	  Node u=_mate[v];
 	  for(IncEdgeIt e(g,v); e!=INVALID; ++e) {
 	    if ( g.target(e) == u ) {
@@ -198,6 +206,6 @@
 	  Node u=g.source(e);	  
 	  Node v=g.target(e);
-	  mate.set(u,v);
-	  mate.set(v,u);
+	  _mate.set(u,v);
+	  _mate.set(v,u);
 	} 
       } 
@@ -217,6 +225,6 @@
       typename Graph::template NodeMap<bool> todo(g,true); 
       for(NodeIt v(g); v!=INVALID; ++v) {
-	if ( todo[v] && mate[v]!=INVALID ) {
-	  Node u=mate[v];
+	if ( todo[v] && _mate[v]!=INVALID ) {
+	  Node u=_mate[v];
 	  for(IncEdgeIt e(g,v); e!=INVALID; ++e) {
 	    if ( g.target(e) == u ) {
@@ -293,5 +301,5 @@
 
     for(NodeIt v(g); v!=INVALID; ++v) {
-      if ( position[v]==C && mate[v]==INVALID ) {
+      if ( position[v]==C && _mate[v]==INVALID ) {
 	blossom.insert(v);
 	tree.insert(v); 
@@ -334,9 +342,9 @@
 	  Node b=blossom.find(x);
 	  path.set(b,true);
-	  b=mate[b];
+	  b=_mate[b];
 	  while ( b!=INVALID ) { 
 	    b=blossom.find(ear[b]);
 	    path.set(b,true);
-	    b=mate[b];
+	    b=_mate[b];
 	  } //going till the root
 	
@@ -391,9 +399,9 @@
 	    Node b=blossom.find(x);
 	    path.set(b,true);
-	    b=mate[b];
+	    b=_mate[b];
 	    while ( b!=INVALID ) { 
 	      b=blossom.find(ear[b]);
 	      path.set(b,true);
-	      b=mate[b];
+	      b=_mate[b];
 	    } //going till the root
 	
@@ -416,8 +424,8 @@
 	  break;
 	case C:
-	  if ( mate[y]!=INVALID ) {   //grow
+	  if ( _mate[y]!=INVALID ) {   //grow
 
 	    ear.set(y,x);
-	    Node w=mate[y];
+	    Node w=_mate[y];
 	    blossom.insert(w);
 	    position.set(y,A); 
@@ -430,6 +438,6 @@
 	  } else {                 //augment  
 	    augment(x, ear, blossom, tree);
-	    mate.set(x,y);
-	    mate.set(y,x);
+	    _mate.set(x,y);
+	    _mate.set(y,x);
 	    return;
 	  } //if 
@@ -444,10 +452,10 @@
   void MaxMatching<Graph>::greedyMatching() {
     for(NodeIt v(g); v!=INVALID; ++v)
-      if ( mate[v]==INVALID ) {
+      if ( _mate[v]==INVALID ) {
 	for( IncEdgeIt e(g,v); e!=INVALID ; ++e ) {
 	  Node y=g.target(e);
-	  if ( mate[y]==INVALID && y!=v ) {
-	    mate.set(v,y);
-	    mate.set(y,v);
+	  if ( _mate[y]==INVALID && y!=v ) {
+	    _mate.set(v,y);
+	    _mate.set(y,v);
 	    break;
 	  }
@@ -460,5 +468,5 @@
     int s=0;
     for(NodeIt v(g); v!=INVALID; ++v) {
-      if ( mate[v]!=INVALID ) {
+      if ( _mate[v]!=INVALID ) {
 	++s;
       }
@@ -470,5 +478,5 @@
   void MaxMatching<Graph>::resetMatching() {
     for(NodeIt v(g); v!=INVALID; ++v)
-      mate.set(v,INVALID);      
+      _mate.set(v,INVALID);      
   }
 
@@ -480,7 +488,7 @@
 	
       if ( position[y]==C ) {
-	if ( mate[y]!=INVALID ) {       //grow
+	if ( _mate[y]!=INVALID ) {       //grow
 	  ear.set(y,x);
-	  Node w=mate[y];
+	  Node w=_mate[y];
 	  blossom.insert(w);
 	  position.set(y,A);
@@ -493,6 +501,6 @@
 	} else {                      //augment 
 	  augment(x, ear, blossom, tree);
-	  mate.set(x,y);
-	  mate.set(y,x);
+	  _mate.set(x,y);
+	  _mate.set(y,x);
 	  return true;
 	}
@@ -508,9 +516,9 @@
     Node t=top;
     while ( t!=middle ) {
-      Node u=mate[t];
+      Node u=_mate[t];
       t=ear[u];
       ear.set(t,u);
     } 
-    bottom=mate[middle];
+    bottom=_mate[middle];
     position.set(bottom,D);
     Q.push(bottom);
@@ -528,12 +536,12 @@
   void MaxMatching<Graph>::augment(Node x, typename Graph::NodeMap<Node>& ear,  
 				   UFE& blossom, UFE& tree) { 
-    Node v=mate[x];
+    Node v=_mate[x];
     while ( v!=INVALID ) {
 	
       Node u=ear[v];
-      mate.set(v,u);
+      _mate.set(v,u);
       Node tmp=v;
-      v=mate[u];
-      mate.set(u,tmp);
+      v=_mate[u];
+      _mate.set(u,tmp);
     }
     typename UFE::ItemIt it;
