# HG changeset patch
# User deba
# Date 1107273397 0
# Node ID 444f69240539534fcb9cb0c3372ee8b3f71acee5
# Parent  eb57527fd1836189951b6e7e38c6165b69279bd9
Some changes in the IO and map utilities.

diff -r eb57527fd183 -r 444f69240539 src/work/deba/graph_io_test.cc
--- a/src/work/deba/graph_io_test.cc	Tue Feb 01 15:51:22 2005 +0000
+++ b/src/work/deba/graph_io_test.cc	Tue Feb 01 15:56:37 2005 +0000
@@ -18,27 +18,27 @@
   GraphReader<SmartGraph> reader(input, graph);
 
   SmartGraph::NodeMap<int> id(graph);
-  reader.readNodeMap("id", id);
+  reader.addNodeMap("id", id);
 
   SmartGraph::NodeMap<int> cost(graph);
-  reader.readNodeMap("cost", cost);
+  reader.addNodeMap("cost", cost);
  
   SmartGraph::NodeMap<string> color(graph);
-  reader.readNodeMap("color", color);
+  reader.addNodeMap("color", color);
 
   SmartGraph::NodeMap<string> description(graph);
-  reader.readNodeMap<QuotedStringReader>("description", description);
+  reader.addNodeMap<QuotedStringReader>("description", description);
 
   SmartGraph::EdgeMap<char> mmap(graph);
-  reader.readEdgeMap("mmap", mmap);
+  reader.addEdgeMap("mmap", mmap);
 
   reader.skipEdgeMap<QuotedStringReader>("description");
 
   SmartGraph::Node source;
-  reader.readNode("source", source);
+  reader.addNode("source", source);
   
   SmartGraph::Edge newedge;
-  reader.readEdge("newedge", newedge);
+  reader.addEdge("newedge", newedge);
 
   try {
     reader.read();
@@ -47,32 +47,37 @@
   } catch (Exception e) {
     cerr << e.what() << endl;
   }
+
   for (SmartGraph::NodeIt it(graph); it != INVALID; ++it) {
     cout << cost[it] << ' ' << color[it] << ' ' << description[it] << endl;
   }
 
   for (SmartGraph::EdgeIt it(graph); it != INVALID; ++it) {
-    cout << mmap[it] << ' ' << id[graph.source(it)] << ' ' << id[graph.target(it)]  << endl;
+    cout << mmap[it] << ' ' << id[graph.source(it)] << ' ' << 
+      id[graph.target(it)]  << endl;
   }
 
-  cout << id[source] << ' ' << cost[source] << ' ' << color[source] << ' ' << description[source] << endl;
-  cout << mmap[newedge] << ' ' << id[graph.source(newedge)] << ' ' << id[graph.target(newedge)]  << endl;
+  cout << id[source] << ' ' << cost[source] << ' ' <<
+    color[source] << ' ' << description[source] << endl;
+  cout << mmap[newedge] << ' ' << id[graph.source(newedge)] << 
+    ' ' << id[graph.target(newedge)]  << endl;
 
   ofstream output("copy.lgf");
   GraphWriter<SmartGraph> writer(output, graph);
   
-  DescriptorMap<SmartGraph, SmartGraph::Node, SmartGraph::NodeIt, SmartGraph::NodeMap<int> > node_ids(graph);
+  DescriptorMap<SmartGraph, SmartGraph::Node, SmartGraph::NodeMap<int> > 
+    node_ids(graph);
   
-  writer.writeNodeMap("id", node_ids);
-  writer.writeNodeMap<QuotedStringWriter>("format", description);
+  writer.addNodeMap("id", node_ids);
+  writer.addNodeMap<QuotedStringWriter>("format", description);
 
-  DescriptorMap<SmartGraph, SmartGraph::Edge, SmartGraph::EdgeIt, SmartGraph::EdgeMap<int> > edge_ids(graph);
+  IdMap<SmartGraph, SmartGraph::Edge > edge_ids(graph);
 
-  writer.writeEdgeMap("id", edge_ids);
-  writer.writeEdgeMap("chars", mmap);
+  writer.addEdgeMap("id", edge_ids);
+  writer.addEdgeMap("chars", mmap);
   
-  writer.writeNode("source", node_ids.inverse()[3]);
-  writer.writeEdge("elek", edge_ids.inverse()[6]);
+  writer.addNode("source", node_ids.inverse()[3]);
+  //  writer.addEdge("elek", edge_ids.inverse()[6]);
   writer.write();
   
   return 0;
diff -r eb57527fd183 -r 444f69240539 src/work/deba/graph_reader.h
--- a/src/work/deba/graph_reader.h	Tue Feb 01 15:51:22 2005 +0000
+++ b/src/work/deba/graph_reader.h	Tue Feb 01 15:56:37 2005 +0000
@@ -37,6 +37,7 @@
 
   class IOException {
   public:
+    virtual ~IOException() {}
     virtual string what() const = 0;
   };
 
@@ -55,10 +56,13 @@
   public:
     typedef _Exception Exception;
     StreamException(int _line, Exception _exception) 
-      : line_num(_line), Exception(_exception) {}
+      : Exception(_exception), line_num(_line) {}
     virtual int line() const {
       return line_num;
     }
+
+    virtual ~StreamException() {}
+
     virtual std::string what() const {
       ostringstream os;
       os << Exception::what() << " in line " << line();
@@ -70,7 +74,10 @@
 
 
   // Readers and ReaderTraits
-  
+  /// \brief Standard ReaderTraits for the GraphReader class.
+  ///
+  /// 
+ 
   struct DefaultReaderTraits {
 
     template <typename _Value>
@@ -96,7 +103,8 @@
       char c;
       value.clear();
       is >> ws;
-      if (!is.get(c) || c != '\"') throw DataFormatException("Quoted string format");
+      if (!is.get(c) || c != '\"') 
+	throw DataFormatException("Quoted string format");
       while (is.get(c) && c != '\"') {
 	if (escaped && c == '\\') {
 	  value += readEscape(is);
@@ -192,17 +200,20 @@
     typedef _ReaderTraits ReaderTraits;
     typedef typename ReaderTraits::DefaultReader DefaultReader;
 
-    GraphReader(std::istream& _is, Graph& _graph, const DefaultReader& _reader = DefaultReader()) 
+    GraphReader(std::istream& _is, Graph& _graph, 
+		const DefaultReader& _reader = DefaultReader()) 
       : is(_is), graph(_graph), nodeSkipper(_reader), edgeSkipper(_reader) {}
 
 
     ~GraphReader() {
 
-      for (typename NodeMapReaders::iterator it = node_map_readers.begin(); it != node_map_readers.end(); ++it) {
+      for (typename NodeMapReaders::iterator it = node_map_readers.begin(); 
+	   it != node_map_readers.end(); ++it) {
 	delete it->second;
       }
 
-      for (typename EdgeMapReaders::iterator it = edge_map_readers.begin(); it != edge_map_readers.end(); ++it) {
+      for (typename EdgeMapReaders::iterator it = edge_map_readers.begin(); 
+	   it != edge_map_readers.end(); ++it) {
 	delete it->second;
       }
 
@@ -211,69 +222,81 @@
     // Node map rules
 
     template <typename Map>
-    GraphReader& readNodeMap(std::string name, Map& map) {
-      return readNodeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
+    GraphReader& addNodeMap(std::string name, Map& map) {
+      return addNodeMap<typename ReaderTraits::template 
+	Reader<typename Map::Value>, Map>(name, map);
     }
 
     template <typename Reader, typename Map>
-    GraphReader& readNodeMap(std::string name, Map& map, const Reader& reader = Reader()) {
+    GraphReader& addNodeMap(std::string name, Map& map, 
+			     const Reader& reader = Reader()) {
       if (node_map_readers.find(name) != node_map_readers.end()) {
 	throw Exception() << "Multiple read rule for node map: " << name;
       }
-      node_map_readers.insert(make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
+      node_map_readers.insert(
+        make_pair(name, new MapReader<Node, Map, Reader>(map, reader)));
       return *this;
     }
 
     template <typename Reader>
-    GraphReader& skipNodeMap(std::string name, const Reader& reader = Reader()) {
+    GraphReader& skipNodeMap(std::string name, 
+			     const Reader& reader = Reader()) {
       if (node_map_readers.find(name) != node_map_readers.end()) {
 	throw Exception() << "Multiple read rule for node map: " << name;
       }
-      node_map_readers.insert(make_pair(name, new SkipReader<Node, Reader>(reader)));
+      node_map_readers.insert(
+        make_pair(name, new SkipReader<Node, Reader>(reader)));
       return *this;
     }
 
     // Edge map rules
 
     template <typename Map>
-    GraphReader& readEdgeMap(std::string name, Map& map) { 
-      return readEdgeMap<typename ReaderTraits::template Reader<typename Map::Value>, Map>(name, map);
+    GraphReader& addEdgeMap(std::string name, Map& map) { 
+      return addEdgeMap<typename ReaderTraits::template
+	Reader<typename Map::Value>, Map>(name, map);
     }
 
 
     template <typename Reader, typename Map>
-    GraphReader& readEdgeMap(std::string name, Map& map, const Reader& reader = Reader()) {
+    GraphReader& addEdgeMap(std::string name, Map& map,
+			     const Reader& reader = Reader()) {
       if (edge_map_readers.find(name) != edge_map_readers.end()) {
 	throw Exception() << "Multiple read rule for edge map: " << name;
       }
-      edge_map_readers.insert(make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
+      edge_map_readers.insert(
+        make_pair(name, new MapReader<Edge, Map, Reader>(map, reader)));
       return *this;
     }
 
     template <typename Reader>
-    GraphReader& skipEdgeMap(std::string name, const Reader& reader = Reader()) {
+    GraphReader& skipEdgeMap(std::string name,
+			     const Reader& reader = Reader()) {
       if (edge_map_readers.find(name) != edge_map_readers.end()) {
 	throw Exception() << "Multiple read rule for edge map: " << name;
       }
-      edge_map_readers.insert(make_pair(name, new SkipReader<Edge, Reader>(reader)));
+      edge_map_readers.insert(
+        make_pair(name, new SkipReader<Edge, Reader>(reader)));
       return *this;
     }
 
     // Node rules
-    GraphReader& readNode(std::string name, Node& node) {
+    GraphReader& addNode(std::string name, Node& node) {
       if (node_readers.find(name) != node_readers.end()) {
 	throw Exception() << "Multiple read rule for node";
       }
       node_readers.insert(make_pair(name, &node));
+      return *this;
     }
 
     // Edge rules
 
-    GraphReader& readEdge(std::string name, Edge& edge) {
+    GraphReader& addEdge(std::string name, Edge& edge) {
       if (edge_readers.find(name) != edge_readers.end()) {
 	throw Exception() << "Multiple read rule for edge";
       }
       edge_readers.insert(make_pair(name, &edge));
+      return *this;
     }
 
     void read() {
@@ -306,7 +329,8 @@
 
     template <typename Item> class InverterBase;
 
-    std::string readNodeSet(int& line_num, auto_ptr<InverterBase<Node> > & nodeInverter) {
+    std::string readNodeSet(int& line_num, 
+			    auto_ptr<InverterBase<Node> > & nodeInverter) {
       std::vector<ReaderBase<Node>* > index;
       {
 	std::string line = readNotEmptyLine(is, line_num);    
@@ -334,7 +358,7 @@
 	Node node = graph.addNode();
 	std::istringstream ls(line);
 	nodeInverter->read(ls, node);
-	for (int i = 1; i < index.size(); ++i) {
+	for (int i = 1; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, node);
 	}
       }
@@ -342,7 +366,8 @@
     }
 
     std::string readEdgeSet(int& line_num, 
-		     auto_ptr<InverterBase<Edge> > & edgeInverter, auto_ptr<InverterBase<Node> > & nodeInverter) {
+			    auto_ptr<InverterBase<Edge> > & edgeInverter, 
+			    auto_ptr<InverterBase<Node> > & nodeInverter) {
       std::vector<ReaderBase<Edge>*> index;
       {
 	std::string line = readNotEmptyLine(is, line_num);    
@@ -372,14 +397,15 @@
 	Node target = nodeInverter->read(ls);
 	Edge edge = graph.addEdge(source, target);
 	edgeInverter->read(ls, edge);
-	for (int i = 1; i < index.size(); ++i) {
+	for (int i = 1; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
       }      
       return line;
     }
 
-    std::string readNodes(int& line_num, auto_ptr<InverterBase<Node> >& nodeInverter) {
+    std::string readNodes(int& line_num, 
+			  auto_ptr<InverterBase<Node> >& nodeInverter) {
       std::string line;
       while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	std::istringstream ls(line);
@@ -393,7 +419,8 @@
       return line;
     }
 
-    std::string readEdges(int& line_num, auto_ptr<InverterBase<Edge> >& edgeInverter) {
+    std::string readEdges(int& line_num, 
+			  auto_ptr<InverterBase<Edge> >& edgeInverter) {
       std::string line;
       while (line = readNotEmptyLine(is, line_num), line[0] != '@') {
 	std::istringstream ls(line);
@@ -411,7 +438,7 @@
       std::string line;
       while (++line_num, getline(is, line)) {	
 	int vi = line.find_first_not_of(" \t");
-	if (vi != string::npos && line[vi] != '#') {
+	if (vi != (int)string::npos && line[vi] != '#') {
 	  return line.substr(vi);
 	}
       }
@@ -445,6 +472,8 @@
       MapReaderInverter(Map& _map, const Reader& _reader) 
 	: map(_map), reader(_reader) {}
 
+      virtual ~MapReaderInverter() {}
+
       virtual void read(std::istream& is, const Item& item) {
 	Value value;
 	reader.read(is, value);
@@ -482,6 +511,8 @@
       SkipReaderInverter(const Reader& _reader) 
 	: reader(_reader) {}
 
+      virtual ~SkipReaderInverter() {}
+
       virtual void read(std::istream& is, const Item& item) {
 	Value value;
 	reader.read(is, value);
@@ -514,6 +545,8 @@
     public:
       typedef _Item Item;
 
+      //      virtual ~ReaderBase() {}
+
       virtual void read(std::istream& is, const Item& item) = 0;
       virtual InverterBase<_Item>* getInverter() = 0;
     };
@@ -532,6 +565,7 @@
       MapReader(Map& _map, const Reader& _reader) 
 	: map(_map), reader(_reader) {}
 
+      virtual ~MapReader() {}
 
       virtual void read(std::istream& is, const Item& item) {
 	Value value;
@@ -555,6 +589,8 @@
       Reader reader;
       SkipReader(const Reader& _reader) : reader(_reader) {}
 
+      virtual ~SkipReader() {}
+
       virtual void read(std::istream& is, const Item& item) {
 	Value value;
 	reader.read(is, value);
diff -r eb57527fd183 -r 444f69240539 src/work/deba/graph_writer.h
--- a/src/work/deba/graph_writer.h	Tue Feb 01 15:51:22 2005 +0000
+++ b/src/work/deba/graph_writer.h	Tue Feb 01 15:56:37 2005 +0000
@@ -54,11 +54,10 @@
     QuotedStringWriter(bool _escaped = true) : escaped(_escaped) {}
 
     void write(std::ostream& os, const std::string& value) {
-      char c;
       os << "\"";
       if (escaped) {
 	ostringstream ls;
-	for (int i = 0; i < value.size(); ++i) {
+	for (int i = 0; i < (int)value.size(); ++i) {
 	  writeEscape(ls, value[i]);
 	}
 	os << ls.str();
@@ -136,12 +135,13 @@
 
 
     ~GraphWriter() {
-
-      for (typename NodeMapWriters::iterator it = node_map_writers.begin(); it != node_map_writers.end(); ++it) {
+      for (typename NodeMapWriters::iterator it = node_map_writers.begin(); 
+	   it != node_map_writers.end(); ++it) {
 	delete it->second;
       }
 
-      for (typename EdgeMapWriters::iterator it = edge_map_writers.begin(); it != edge_map_writers.end(); ++it) {
+      for (typename EdgeMapWriters::iterator it = edge_map_writers.begin();
+	   it != edge_map_writers.end(); ++it) {
 	delete it->second;
       }
 
@@ -150,29 +150,33 @@
     // Node map rules
 
     template <typename Map>
-    GraphWriter& writeNodeMap(std::string name, const Map& map) {
-      return writeNodeMap<typename WriterTraits::template Writer<typename Map::Value>, Map>(name, map);
+    GraphWriter& addNodeMap(std::string name, const Map& map) {
+      return addNodeMap<typename WriterTraits::template Writer<
+	typename Map::Value>, Map>(name, map);
     }
 
     template <typename Writer, typename Map>
-    GraphWriter& writeNodeMap(std::string name, const Map& map, const Writer& writer = Writer()) {
+    GraphWriter& addNodeMap(std::string name, const Map& map, 
+			      const Writer& writer = Writer()) {
       //      if (node_map_writers.find(name) != node_map_writers.end()) {
-      //	throw Exception() << "Multiple write rule for node map: " << name;
+      //	throw Exception() << "Multiple write rule for node map: " 
+      //        << name;
       //      }
-      node_map_writers.push_back(make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
+      node_map_writers.push_back(
+        make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
       return *this;
     }
 
     // Edge map rules
 
     template <typename Map>
-    GraphWriter& writeEdgeMap(std::string name, const Map& map) { 
-      return writeEdgeMap<typename WriterTraits::template Writer<typename Map::Value>, Map>(name, map);
+    GraphWriter& addEdgeMap(std::string name, const Map& map) { 
+      return addEdgeMap<typename WriterTraits::template Writer<typename Map::Value>, Map>(name, map);
     }
 
 
     template <typename Writer, typename Map>
-    GraphWriter& writeEdgeMap(std::string name, const Map& map, const Writer& writer = Writer()) {
+    GraphWriter& addEdgeMap(std::string name, const Map& map, const Writer& writer = Writer()) {
       //      if (edge_map_writers.find(name) != edge_map_writers.end()) {
       //	throw Exception() << "Multiple write rule for edge map: " << name;
       //      }
@@ -181,20 +185,22 @@
     }
 
     // Node rules
-    GraphWriter& writeNode(std::string name, const Node& node) {
+    GraphWriter& addNode(std::string name, const Node& node) {
       //      if (node_writers.find(name) != node_writers.end()) {
       //	throw Exception() << "Multiple write rule for node";
       //      }
       node_writers.push_back(make_pair(name, node));
+      return *this;
     }
 
     // Edge rules
 
-    GraphWriter& writeEdge(std::string name, const Edge& edge) {
+    GraphWriter& addEdge(std::string name, const Edge& edge) {
       //      if (edge_writers.find(name) != edge_writers.end()) {
       //	throw Exception() << "Multiple write rule for edge";
       //      }
       edge_writers.push_back(make_pair(name, edge));
+      return *this;
     }
 
     void write() {   
@@ -210,12 +216,12 @@
     void writeNodeSet() {
       if (node_map_writers.size() == 0) return;
       os << "@nodeset" << std::endl;
-      for (int i = 0; i < node_map_writers.size(); ++i) {
+      for (int i = 0; i < (int)node_map_writers.size(); ++i) {
 	os << node_map_writers[i].first << '\t';
       } 
       os << std::endl;
       for (NodeIt it(graph); it != INVALID; ++it) {
-	for (int i = 0; i < node_map_writers.size(); ++i) {
+	for (int i = 0; i < (int)node_map_writers.size(); ++i) {
 	  node_map_writers[i].second->write(os, it);
 	}
 	os << std::endl;
@@ -230,14 +236,14 @@
       }
       os << "@edgeset" << std::endl;
       os << "\t\t";
-      for (int i = 0; i < edge_map_writers.size(); ++i) {
+      for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
 	os << edge_map_writers[i].first << '\t';
       } 
       os << std::endl;
       for (EdgeIt it(graph); it != INVALID; ++it) {
 	node_map_writers[0].second->write(os, graph.source(it));
 	node_map_writers[0].second->write(os, graph.target(it));
-	for (int i = 0; i < edge_map_writers.size(); ++i) {
+	for (int i = 0; i < (int)edge_map_writers.size(); ++i) {
 	  edge_map_writers[i].second->write(os, it);
 	}
 	os << std::endl;
@@ -250,7 +256,7 @@
 	throw Exception() << "Missing node id map";
       }
       os << "@nodes" << std::endl;
-      for (int i = 0; i < node_writers.size(); ++i) {
+      for (int i = 0; i < (int)node_writers.size(); ++i) {
 	os << node_writers[i].first << '\t';
 	node_map_writers[0].second->write(os, node_writers[i].second);
 	os << std::endl;
@@ -263,7 +269,7 @@
 	throw Exception() << "Missing edge id map";
       }
       os << "@edges" << std::endl;
-      for (int i = 0; i < edge_writers.size(); ++i) {
+      for (int i = 0; i < (int)edge_writers.size(); ++i) {
 	os << edge_writers[i].first << '\t';
 	edge_map_writers[0].second->write(os, edge_writers[i].second);
 	os << std::endl;
@@ -295,7 +301,6 @@
 
 
       virtual void write(std::ostream& os, const Item& item) {
-	Value value;
 	writer.write(os, map[item]);
       }
 
@@ -303,10 +308,12 @@
 
 
 
-    typedef std::vector< std::pair<std::string, WriterBase<Node>*> > NodeMapWriters;
+    typedef std::vector< std::pair<std::string, WriterBase<Node>*> > 
+      NodeMapWriters;
     NodeMapWriters node_map_writers;
 
-    typedef std::vector< std::pair<std::string, WriterBase<Edge>*> > EdgeMapWriters;
+    typedef std::vector< std::pair<std::string, WriterBase<Edge>*> > 
+      EdgeMapWriters;
     EdgeMapWriters edge_map_writers;
 
     typedef std::vector<std::pair<std::string, Node> > NodeWriters;
diff -r eb57527fd183 -r 444f69240539 src/work/deba/map_utils.h
--- a/src/work/deba/map_utils.h	Tue Feb 01 15:51:22 2005 +0000
+++ b/src/work/deba/map_utils.h	Tue Feb 01 15:56:37 2005 +0000
@@ -14,7 +14,7 @@
  *
  */
 
-///\ingroup gutils
+///\ingroup mutils
 ///\file
 ///\brief Map utilities.
 
@@ -49,15 +49,15 @@
     
     typedef typename _Map::ConstReference ConstReference;
 
-    /// Constructor.
-
+    /// \brief Constructor.
+    ///
     /// Construct a new InversableMap for the graph.
     ///
     InversableMap(const Graph& graph) : Map(graph) {} 
     
-    /// The setter function of the map.
-
-    /// It sets the map and the inverse map 
+    /// \brief The setter function of the map.
+    ///
+    /// It sets the map and the inverse map to given key-value pair.
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
       typename InverseMap::iterator it = inv_map.find(oldval);
@@ -95,27 +95,42 @@
   };
 
 
-  // unique, continous, mutable
+  
+  /// \brief Provides a mutable, continous and unique descriptor for each 
+  /// item in the graph.
+  ///
+  /// The DescriptorMap class provides a mutable, continous and immutable
+  /// mapping for each item in the graph.
+  ///
+  /// \param _Graph The graph class the \c DescriptorMap belongs to.
+  /// \param _Item The Item is the Key of the Map. It may be Node, Edge or 
+  /// UndirEdge.
+  /// \param _Map A ReadWriteMap mapping from the item type to integer.
 
   template <
     typename _Graph,   
     typename _Item,
-    typename _ItemIt,
     typename _Map
   >
   class DescriptorMap : protected _Map {
-  public:
-    typedef _Graph Graph;
+
     typedef _Item Item;
-    typedef _ItemIt ItemIt;
     typedef _Map Map;
 
+  public:
+    /// The graph class of DescriptorMap.
+    typedef _Graph Graph;
 
+    /// The key type of DescriptorMap (Node, Edge, UndirEdge).
     typedef typename _Map::Key Key;
+    /// The value type of DescriptorMap.
     typedef typename _Map::Value Value;
 
-    typedef vector<Item> InverseMap;
+    typedef std::vector<Item> InverseMap;
 
+    /// \brief Constructor.
+    ///
+    /// Constructor for creating descriptor map.
     DescriptorMap(const Graph& _graph) : Map(_graph) {
       build();
     }
@@ -134,7 +149,8 @@
 
     virtual void build() {
       Map::build();
-      for (ItemIt it(*Map::getGraph()); it != INVALID; ++it) {
+      Item it;
+      for (getGraph()->first(it); it != INVALID; getGraph()->next(it)) {
 	Map::set(it, inv_map.size());
 	inv_map.push_back(it);	
       }      
@@ -145,11 +161,16 @@
       Map::clear();
     }
 
+    /// \brief Gives back the \e descriptor of the item.
+    ///
+    /// Gives back the mutable and unique \e descriptor of the map.
     int operator[](const Item& item) const {
       return Map::operator[](item);
     }
-
     
+    /// \brief Gives back the inverse of the map.
+    ///
+    /// Gives back the inverse of the map.
     const InverseMap inverse() const {
       return inv_map;
     }
@@ -157,10 +178,57 @@
   private:
     vector<Item> inv_map;
   };
+  
+  /// Provides an immutable and unique id for each item in the graph.
 
-  // unique, immutable => IDMap
-  
-  
+  /// The IdMap class provides an unique and immutable mapping for each item
+  /// in the graph.
+  ///
+  template <typename _Graph, typename _Item>
+  class IdMap {
+  public:
+    typedef _Graph Graph;
+    typedef int Value;
+    typedef _Item Item;
+
+    /// \brief The class represents the inverse of the map.
+    ///
+    /// The class represents the inverse of the map.
+    /// \see inverse()
+    class InverseMap {
+    protected:
+      InverseMap(const Graph& _graph) : graph(_graph) {}
+    public:
+      /// \brief Gives back the given item by its id.
+      ///
+      /// Gives back the given item by its id.
+      /// 
+      Item operator[](int id) const { return graph->fromId(id, Item());}
+    private:
+      Graph* graph;
+    };
+
+    /// \brief Constructor.
+    ///
+    /// Constructor for creating id map.
+    IdMap(const Graph& _graph) : graph(&_graph) {}
+
+    /// \brief Gives back the \e id of the item.
+    ///
+    /// Gives back the immutable and unique \e id of the map.
+    int operator[](const Item& item) const { return graph->id(item);}
+
+    /// \brief Gives back the inverse of the map.
+    ///
+    /// Gives back the inverse of the map.
+    InverseMap inverse() const { return InverseMap(*graph);} 
+
+  private:
+    const Graph* graph;
+
+  };
+
+
 
 }