lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:9f7876c449c6
+:028ac22cb3c4
 namespace _reader_bits {
 template <typename T>
 bool operator<(T, T) {
-throw DataFormatError("Id is not comparable");
+throw DataFormatError("Label is not comparable");
 }
 template <typename T>
 struct Less {
 bool operator()(const T& p, const T& q) const {
 	return p < q;
 }
 };
 template <typename Item>
-class ItemIdReader {
+class ItemLabelReader {
 public:
-bool isIdReader() { return true; }
+bool isLabelReader() { return true; }
-void readId(std::istream&, Item&) {}
+void readLabel(std::istream&, Item&) {}
-template <class _ItemIdReader>
+template <class _ItemLabelReader>
 struct Constraints {
 	void constraints() {
-	  bool b = reader.isIdReader();
+	  bool b = reader.isLabelReader();
 	  ignore_unused_variable_warning(b);
 	  Item item;
-	  reader.readId(is, item);
+	  reader.readLabel(is, item);
 	}
-	_ItemIdReader& reader;
+	_ItemLabelReader& reader;
 	std::istream& is;
 };
 };
 	map.set(item, value);
 	typename Inverse::iterator it = inverse.find(value);
 	if (it == inverse.end()) {
 	  inverse.insert(std::make_pair(value, item));
 	} else {
-	  throw DataFormatError("Multiple ID occurence");
+	  throw DataFormatError("Multiple label occurence");
 	}
 }
 virtual Item read(std::istream& is) const {
 	Value value;
 	reader.read(is, value);
 	typename Inverse::const_iterator it = inverse.find(value);
 	if (it != inverse.end()) {
 	  return it->second;
 	} else {
-	  throw DataFormatError("Invalid ID error");
+	  throw DataFormatError("Invalid label error");
 	}
 }
 };
 template <typename _Item, typename _Reader>
 	reader.read(is, value);
 	typename Inverse::iterator it = inverse.find(value);
 	if (it == inverse.end()) {
 	  inverse.insert(std::make_pair(value, item));
 	} else {
-	  throw DataFormatError("Multiple ID occurence error");
+	  throw DataFormatError("Multiple label occurence error");
 	}
 }
 virtual Item read(std::istream& is) const {
 	Value value;
 	reader.read(is, value);
 	typename Inverse::const_iterator it = inverse.find(value);
 	if (it != inverse.end()) {
 	  return it->second;
 	} else {
-	  throw DataFormatError("Invalid ID error");
+	  throw DataFormatError("Invalid label error");
 	}
 }
 private:
 Inverse inverse;
 	return new SkipReaderInverter<Item, Reader>(reader);
 }
 };
 template <typename _Item>
-class IdReaderBase {
+class LabelReaderBase {
 public:
 typedef _Item Item;
-virtual ~IdReaderBase() {}
+virtual ~LabelReaderBase() {}
 virtual Item read(std::istream& is) const = 0;
-virtual bool isIdReader() const = 0;
+virtual bool isLabelReader() const = 0;
 };
-template <typename _Item, typename _BoxedIdReader>
+template <typename _Item, typename _BoxedLabelReader>
-class IdReader : public IdReaderBase<_Item> {
+class LabelReader : public LabelReaderBase<_Item> {
 public:
 typedef _Item Item;
-typedef _BoxedIdReader BoxedIdReader;
+typedef _BoxedLabelReader BoxedLabelReader;
-const BoxedIdReader& boxedIdReader;
+const BoxedLabelReader& boxedLabelReader;
-IdReader(const BoxedIdReader& _boxedIdReader)
+LabelReader(const BoxedLabelReader& _boxedLabelReader)
-	: boxedIdReader(_boxedIdReader) {}
+	: boxedLabelReader(_boxedLabelReader) {}
 virtual Item read(std::istream& is) const {
 	Item item;
-	boxedIdReader.readId(is, item);
+	boxedLabelReader.readLabel(is, item);
 	return item;
 }
-virtual bool isIdReader() const {
+virtual bool isLabelReader() const {
-	return boxedIdReader.isIdReader();
+	return boxedLabelReader.isLabelReader();
 }
 };
 template <typename _Item>
 class ItemStore {
 /// \ingroup io_group
 /// \brief SectionReader for reading a graph's nodeset.
 ///
 /// The lemon format can store multiple graph nodesets with several maps.
-/// The nodeset section's header line is \c \@nodeset \c nodeset_id, but the
+/// The nodeset section's header line is \c \@nodeset \c nodeset_name, but the
-/// \c nodeset_id may be empty.
+/// \c nodeset_name may be empty.
 ///
 /// The first line of the section contains the names of the maps separated
 /// with white spaces. Each next lines describes a node in the nodeset, and
 /// contains the mapped values for each map.
 ///
-/// If the nodeset contains an \c "id" named map then it will be regarded
+/// If the nodeset contains an \c "label" named map then it will be regarded
 /// as id map. This map should contain only unique values and when the
-/// \c readId() member will read a value from the given stream it will
+/// \c readLabel() member will read a value from the given stream it will
 /// give back that node which is mapped to this value.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
 class NodeSetReader : public LemonReader::SectionReader {
 /// \brief Constructor.
 ///
 /// Constructor for NodeSetReader. It creates the NodeSetReader and
 /// attach it into the given LemonReader. The nodeset reader will
 /// add the readed nodes to the given Graph. The reader will read
-/// the section when the \c section_id and the \c _id are the same.
+/// the section when the \c section_name and the \c _name are the same.
 NodeSetReader(LemonReader& _reader,
 		  Graph& _graph,
-		  const std::string& _id = std::string(),
+		  const std::string& _name = std::string(),
 		  const DefaultSkipper& _skipper = DefaultSkipper())
-: Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {}
+: Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {}
 /// \brief Destructor.
 ///
 /// Destructor for NodeSetReader.
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
 /// It gives back true when the header line starts with \c \@nodeset,
-/// and the header line's id and the nodeset's id are the same.
+/// and the header line's name and the nodeset's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@nodeset" && name == id;
 }
 /// \brief Reader function of the section.
 virtual void read(std::istream& is) {
 std::vector<_reader_bits::MapReaderBase<Node>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
+std::string id;
 while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  it->second->touch();
 	  index.push_back(it->second);
 	} else {
 	  index.push_back(&skipper);
 	}
-	if (id == "id" && inverter.get() == 0) {
+	if (id == "label" || (id =="id" && inverter.get() == 0)) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
 	}
 }
 for (typename MapReaders::iterator it = readers.begin();
 }
 }
 public:
-/// \brief Returns true if the nodeset can give back the node by its id.
+/// \brief Returns true if the nodeset can give back the node by its label.
 ///
-/// Returns true if the nodeset can give back the node by its id.
+/// Returns true if the nodeset can give back the node by its label.
-/// It is possible only if an "id" named map was read.
+/// It is possible only if an "label" named map was read.
-bool isIdReader() const {
+bool isLabelReader() const {
 return inverter.get() != 0;
 }
-/// \brief Gives back the node by its id.
+/// \brief Gives back the node by its label.
 ///
 /// It reads an id from the stream and gives back which node belongs to
-/// it. It is possible only if there was read an "id" named map.
+/// it. It is possible only if there was read an "label" named map.
-void readId(std::istream& is, Node& node) const {
+void readLabel(std::istream& is, Node& node) const {
 node = inverter->read(is);
 }
 private:
 typedef std::map<std::string, _reader_bits::MapReaderBase<Node>*> MapReaders;
 MapReaders readers;
 Graph& graph;
-std::string id;
+std::string name;
 _reader_bits::SkipReader<Node, DefaultSkipper> skipper;
 std::auto_ptr<_reader_bits::MapInverterBase<Node> > inverter;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading a graph's edgeset.
 ///
 /// The lemon format can store multiple graph edgesets with several maps.
-/// The edgeset section's header line is \c \@edgeset \c edgeset_id, but the
+/// The edgeset section's header line is \c \@edgeset \c edgeset_name, but the
-/// \c edgeset_id may be empty.
+/// \c edgeset_name may be empty.
 ///
 /// The first line of the section contains the names of the maps separated
 /// with white spaces. Each next lines describes an edge in the edgeset. The
 /// line contains the source and the target nodes' id and the mapped
 /// values for each map.
 ///
-/// If the edgeset contains an \c "id" named map then it will be regarded
+/// If the edgeset contains an \c "label" named map then it will be regarded
 /// as id map. This map should contain only unique values and when the
-/// \c readId() member will read a value from the given stream it will
+/// \c readLabel() member will read a value from the given stream it will
 /// give back that edge which is mapped to this value.
 ///
 /// The edgeset reader needs a node id reader to identify which nodes
-/// have to be connected. If a NodeSetReader reads an "id" named map,
+/// have to be connected. If a NodeSetReader reads an "label" named map,
 /// it will be able to resolve the nodes by ids.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
 class EdgeSetReader : public LemonReader::SectionReader {
 ///
 /// Constructor for EdgeSetReader. It creates the EdgeSetReader and
 /// attach it into the given LemonReader. The edgeset reader will
 /// add the readed edges to the given Graph. It will use the given
 /// node id reader to read the source and target nodes of the edges.
-/// The reader will read the section only if the \c _id and the
+/// The reader will read the section only if the \c _name and the
-/// \c edgset_id are the same.
+/// \c edgset_name are the same.
-template <typename NodeIdReader>
+template <typename NodeLabelReader>
 EdgeSetReader(LemonReader& _reader,
 		  Graph& _graph,
-		  const NodeIdReader& _nodeIdReader,
+		  const NodeLabelReader& _nodeLabelReader,
-		  const std::string& _id = std::string(),
+		  const std::string& _name = std::string(),
 		  const DefaultSkipper& _skipper = DefaultSkipper())
-: Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
+: Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
-checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
+checkConcept<_reader_bits::ItemLabelReader<Node>, NodeLabelReader>();
-nodeIdReader.reset(new _reader_bits::
+nodeLabelReader.reset(new _reader_bits::
-			 IdReader<Node, NodeIdReader>(_nodeIdReader));
+			 LabelReader<Node, NodeLabelReader>(_nodeLabelReader));
 }
 /// \brief Destructor.
 ///
 /// Destructor for EdgeSetReader.
 virtual ~EdgeSetReader() {
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
 /// It gives back true when the header line starts with \c \@edgeset,
-/// and the header line's id and the edgeset's id are the same.
+/// and the header line's name and the edgeset's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@edgeset" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
-if (!nodeIdReader->isIdReader()) {
+if (!nodeLabelReader->isLabelReader()) {
-	throw DataFormatError("Cannot find nodeset or ID map");
+	throw DataFormatError("Cannot find nodeset or label map");
 }
 std::vector<_reader_bits::MapReaderBase<Edge>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
+std::string id;
 while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  index.push_back(it->second);
 	  it->second->touch();
 	} else {
 	  index.push_back(&skipper);
 	}
-	if (id == "id" && inverter.get() == 0) {
+	if (id == "label" || (id =="id" && inverter.get() == 0)) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
 	}
 }
 for (typename MapReaders::iterator it = readers.begin();
 	  throw IOParameterError(msg.message());
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
-	Node from = nodeIdReader->read(ls);
+	Node from = nodeLabelReader->read(ls);
-	Node to = nodeIdReader->read(ls);
+	Node to = nodeLabelReader->read(ls);
 	Edge edge = graph.addEdge(from, to);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 }
 public:
-/// \brief Returns true if the edgeset can give back the edge by its id.
+/// \brief Returns true if the edgeset can give back the edge by its label.
 ///
-/// Returns true if the edgeset can give back the edge by its id.
+/// Returns true if the edgeset can give back the edge by its label.
-/// It is possible only if an "id" named map was read.
+/// It is possible only if an "label" named map was read.
-bool isIdReader() const {
+bool isLabelReader() const {
 return inverter.get() != 0;
 }
-/// \brief Gives back the edge by its id.
+/// \brief Gives back the edge by its label.
 ///
 /// It reads an id from the stream and gives back which edge belongs to
-/// it. It is possible only if there was read an "id" named map.
+/// it. It is possible only if there was read an "label" named map.
-void readId(std::istream& is, Edge& edge) const {
+void readLabel(std::istream& is, Edge& edge) const {
 edge = inverter->read(is);
 }
 private:
 typedef std::map<std::string, _reader_bits::MapReaderBase<Edge>*> MapReaders;
 MapReaders readers;
 Graph& graph;
-std::string id;
+std::string name;
 _reader_bits::SkipReader<Edge, DefaultSkipper> skipper;
 std::auto_ptr<_reader_bits::MapInverterBase<Edge> > inverter;
-std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading a undirected graph's edgeset.
 ///
 /// The lemon format can store multiple undirected edgesets with several
 /// maps. The undirected edgeset section's header line is \c \@undiredgeset
-/// \c undiredgeset_id, but the \c undiredgeset_id may be empty.
+/// \c undiredgeset_name, but the \c undiredgeset_name may be empty.
 ///
 /// The first line of the section contains the names of the maps separated
 /// with white spaces. Each next lines describes an edge in the edgeset. The
 /// line contains the connected nodes' id and the mapped values for each map.
 ///
 /// undirected edge map describes one directed edge map. This two maps
 /// are the forward map and the backward map and the names of this map
 /// is near the same just with a prefix \c '+' or \c '-' character
 /// difference.
 ///
-/// If the edgeset contains an \c "id" named map then it will be regarded
+/// If the edgeset contains an \c "label" named map then it will be regarded
 /// as id map. This map should contain only unique values and when the
-/// \c readId() member will read a value from the given stream it will
+/// \c readLabel() member will read a value from the given stream it will
 /// give back that undiricted edge which is mapped to this value.
 ///
 /// The undirected edgeset reader needs a node id reader to identify which
-/// nodes have to be connected. If a NodeSetReader reads an "id" named map,
+/// nodes have to be connected. If a NodeSetReader reads an "label" named map,
 /// it will be able to resolve the nodes by ids.
 ///
 /// \relates LemonReader
 template <typename _Graph, typename _Traits = DefaultReaderTraits>
 class UndirEdgeSetReader : public LemonReader::SectionReader {
 /// Constructor for UndirEdgeSetReader. It creates the UndirEdgeSetReader
 /// and attach it into the given LemonReader. The undirected edgeset
 /// reader will add the readed undirected edges to the given Graph. It
 /// will use the given node id reader to read the source and target
 /// nodes of the edges. The reader will read the section only if the
-/// \c _id and the \c undiredgset_id are the same.
+/// \c _name and the \c undiredgset_name are the same.
-template <typename NodeIdReader>
+template <typename NodeLabelReader>
 UndirEdgeSetReader(LemonReader& _reader,
 		       Graph& _graph,
-		       const NodeIdReader& _nodeIdReader,
+		       const NodeLabelReader& _nodeLabelReader,
-		       const std::string& _id = std::string(),
+		       const std::string& _name = std::string(),
 		       const DefaultSkipper& _skipper = DefaultSkipper())
-: Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
+: Parent(_reader), graph(_graph), name(_name), skipper(_skipper) {
-checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
+checkConcept<_reader_bits::ItemLabelReader<Node>, NodeLabelReader>();
-nodeIdReader.reset(new _reader_bits::
+nodeLabelReader.reset(new _reader_bits::
-			 IdReader<Node, NodeIdReader>(_nodeIdReader));
+			 LabelReader<Node, NodeLabelReader>(_nodeLabelReader));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeSetReader.
 virtual ~UndirEdgeSetReader() {
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
 /// It gives back true when the header line starts with \c \@undiredgeset,
-/// and the header line's id and the edgeset's id are the same.
+/// and the header line's name and the edgeset's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@undiredgeset" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
-if (!nodeIdReader->isIdReader()) {
+if (!nodeLabelReader->isLabelReader()) {
-	throw DataFormatError("Cannot find nodeset or ID map");
+	throw DataFormatError("Cannot find nodeset or label map");
 }
 std::vector<_reader_bits::MapReaderBase<UndirEdge>* > index;
 std::string line;
 getline(is, line);
 std::istringstream ls(line);
+std::string id;
 while (ls >> id) {
 	typename MapReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  index.push_back(it->second);
 	  it->second->touch();
 	} else {
 	  index.push_back(&skipper);
 	}
-	if (id == "id" && inverter.get() == 0) {
+	if (id == "label" || (id =="id" && inverter.get() == 0)) {
 	  inverter.reset(index.back()->getInverter());
 	  index.back() = inverter.get();
 	}
 }
 for (typename MapReaders::iterator it = readers.begin();
 	  throw IOParameterError(msg.message());
 	}
 }
 while (getline(is, line)) {
 	std::istringstream ls(line);
-	Node from = nodeIdReader->read(ls);
+	Node from = nodeLabelReader->read(ls);
-	Node to = nodeIdReader->read(ls);
+	Node to = nodeLabelReader->read(ls);
 	UndirEdge edge = graph.addEdge(from, to);
 	for (int i = 0; i < (int)index.size(); ++i) {
 	  index[i]->read(ls, edge);
 	}
 }
 }
 public:
-/// \brief Returns true if the edgeset can give back the edge by its id.
+/// \brief Returns true if the edgeset can give back the edge by its label.
 ///
 /// Returns true if the edgeset can give back the undirected edge by its
-/// id. It is possible only if an "id" named map was read.
+/// id. It is possible only if an "label" named map was read.
-bool isIdReader() const {
+bool isLabelReader() const {
 return inverter.get() != 0;
 }
-/// \brief Gives back the undirected edge by its id.
+/// \brief Gives back the undirected edge by its label.
 ///
 /// It reads an id from the stream and gives back which undirected edge
-/// belongs to it. It is possible only if there was read an "id" named map.
+/// belongs to it. It is possible only if there was read an "label" named map.
-void readId(std::istream& is, UndirEdge& undirEdge) const {
+void readLabel(std::istream& is, UndirEdge& undirEdge) const {
 undirEdge = inverter->read(is);
 }
-/// \brief Gives back the directed edge by its id.
+/// \brief Gives back the directed edge by its label.
 ///
 /// It reads an id from the stream and gives back which directed edge
 /// belongs to it. The directed edge id is the \c '+' or \c '-' character
 /// and the undirected edge id. It is possible only if there was read
-/// an "id" named map.
+/// an "label" named map.
-void readId(std::istream& is, Edge& edge) const {
+void readLabel(std::istream& is, Edge& edge) const {
 char c;
 is >> c;
 UndirEdge undirEdge = inverter->read(is);
 if (c == '+') {
 	edge = graph.direct(undirEdge, true);
 typedef std::map<std::string,
 		     _reader_bits::MapReaderBase<UndirEdge>*> MapReaders;
 MapReaders readers;
 Graph& graph;
-std::string id;
+std::string name;
 _reader_bits::SkipReader<UndirEdge, DefaultSkipper> skipper;
 std::auto_ptr<_reader_bits::MapInverterBase<UndirEdge> > inverter;
-std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled nodes.
 ///
-/// The nodes section's header line is \c \@nodes \c nodes_id, but the
+/// The nodes section's header line is \c \@nodes \c nodes_name, but the
-/// \c nodes_id may be empty.
+/// \c nodes_name may be empty.
 ///
 /// Each line in the section contains the name of the node
 /// and then the node id.
 ///
 /// \relates LemonReader
 /// \brief Constructor.
 ///
 /// Constructor for NodeReader. It creates the NodeReader and
 /// attach it into the given LemonReader. It will use the given
 /// node id reader to give back the nodes. The reader will read the
-/// section only if the \c _id and the \c nodes_id are the same.
+/// section only if the \c _name and the \c nodes_name are the same.
-template <typename _IdReader>
+template <typename _LabelReader>
-NodeReader(LemonReader& _reader, const _IdReader& _idReader,
+NodeReader(LemonReader& _reader, const _LabelReader& _labelReader,
-	       const std::string& _id = std::string())
+	       const std::string& _name = std::string())
-: Parent(_reader), id(_id) {
+: Parent(_reader), name(_name) {
-checkConcept<_reader_bits::ItemIdReader<Node>, _IdReader>();
+checkConcept<_reader_bits::ItemLabelReader<Node>, _LabelReader>();
-nodeIdReader.reset(new _reader_bits::
+nodeLabelReader.reset(new _reader_bits::
-			 IdReader<Node, _IdReader>(_idReader));
+			 LabelReader<Node, _LabelReader>(_labelReader));
 }
 /// \brief Destructor.
 ///
 /// Destructor for NodeReader.
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
 /// It gives back true when the header line start with \c \@nodes,
-/// and the header line's id and the reader's id are the same.
+/// and the header line's name and the reader's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@nodes" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
-if (!nodeIdReader->isIdReader()) {
+if (!nodeLabelReader->isLabelReader()) {
-	throw DataFormatError("Cannot find nodeset or ID map");
+	throw DataFormatError("Cannot find nodeset or label map");
 }
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 	ls >> id;
 	typename NodeReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
-	  it->second.read(nodeIdReader->read(ls));
+	  it->second.read(nodeLabelReader->read(ls));
 	  it->second.touch();
 	}
 }
 for (typename NodeReaders::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::map<std::string, _reader_bits::ItemStore<Node> > NodeReaders;
 NodeReaders readers;
-std::auto_ptr<_reader_bits::IdReaderBase<Node> > nodeIdReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<Node> > nodeLabelReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled edges.
 ///
-/// The edges section's header line is \c \@edges \c edges_id, but the
+/// The edges section's header line is \c \@edges \c edges_name, but the
-/// \c edges_id may be empty.
+/// \c edges_name may be empty.
 ///
 /// Each line in the section contains the name of the edge
 /// and then the edge id.
 ///
 /// \relates LemonReader
 /// \brief Constructor.
 ///
 /// Constructor for EdgeReader. It creates the EdgeReader and
 /// attach it into the given LemonReader. It will use the given
 /// edge id reader to give back the edges. The reader will read the
-/// section only if the \c _id and the \c edges_id are the same.
+/// section only if the \c _name and the \c edges_name are the same.
-template <typename _IdReader>
+template <typename _LabelReader>
-EdgeReader(LemonReader& _reader, const _IdReader& _idReader,
+EdgeReader(LemonReader& _reader, const _LabelReader& _labelReader,
-	       const std::string& _id = std::string())
+	       const std::string& _name = std::string())
-: Parent(_reader), id(_id) {
+: Parent(_reader), name(_name) {
-checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
+checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>();
-edgeIdReader.reset(new _reader_bits::
+edgeLabelReader.reset(new _reader_bits::
-			 IdReader<Edge, _IdReader>(_idReader));
+			 LabelReader<Edge, _LabelReader>(_labelReader));
 }
 /// \brief Destructor.
 ///
 /// Destructor for EdgeReader.
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
 /// It gives back true when the header line start with \c \@edges,
-/// and the header line's id and the reader's id are the same.
+/// and the header line's name and the reader's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@edges" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
-if (!edgeIdReader->isIdReader()) {
+if (!edgeLabelReader->isLabelReader()) {
-	throw DataFormatError("Cannot find edgeset or ID map");
+	throw DataFormatError("Cannot find edgeset or label map");
 }
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 	ls >> id;
 	typename EdgeReaders::iterator it = readers.find(id);
 	if (it != readers.end()) {
-	  it->second.read(edgeIdReader->read(ls));
+	  it->second.read(edgeLabelReader->read(ls));
 	  it->second.touch();
 	}
 }
 for (typename EdgeReaders::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
 EdgeReaders readers;
-std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > edgeLabelReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for reading labeled undirected edges.
 ///
 /// The undirected edges section's header line is \c \@undiredges
-/// \c undiredges_id, but the \c undiredges_id may be empty.
+/// \c undiredges_name, but the \c undiredges_name may be empty.
 ///
 /// Each line in the section contains the name of the undirected edge
 /// and then the undirected edge id.
 ///
 /// \relates LemonReader
 /// \brief Constructor.
 ///
 /// Constructor for UndirEdgeReader. It creates the UndirEdgeReader and
 /// attach it into the given LemonReader. It will use the given
 /// undirected edge id reader to give back the edges. The reader will
-/// read the section only if the \c _id and the \c undiredges_id are
+/// read the section only if the \c _name and the \c undiredges_name are
 /// the same.
-template <typename _IdReader>
+template <typename _LabelReader>
-UndirEdgeReader(LemonReader& _reader, const _IdReader& _idReader,
+UndirEdgeReader(LemonReader& _reader, const _LabelReader& _labelReader,
-	       const std::string& _id = std::string())
+	       const std::string& _name = std::string())
-: Parent(_reader), id(_id) {
+: Parent(_reader), name(_name) {
-checkConcept<_reader_bits::ItemIdReader<UndirEdge>, _IdReader>();
+checkConcept<_reader_bits::ItemLabelReader<UndirEdge>, _LabelReader>();
-checkConcept<_reader_bits::ItemIdReader<Edge>, _IdReader>();
+checkConcept<_reader_bits::ItemLabelReader<Edge>, _LabelReader>();
-undirEdgeIdReader.reset(new _reader_bits::
+undirEdgeLabelReader.reset(new _reader_bits::
-			      IdReader<UndirEdge, _IdReader>(_idReader));
+			      LabelReader<UndirEdge, _LabelReader>(_labelReader));
-edgeIdReader.reset(new _reader_bits::
+edgeLabelReader.reset(new _reader_bits::
-			 IdReader<Edge, _IdReader>(_idReader));
+			 LabelReader<Edge, _LabelReader>(_labelReader));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeReader.
 /// \brief Gives back true when the SectionReader can process
 /// the section with the given header line.
 ///
 /// It gives back true when the header line start with \c \@edges,
-/// and the header line's id and the reader's id are the same.
+/// and the header line's name and the reader's name are the same.
 virtual bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@undiredges" && name == id;
 }
 /// \brief Reader function of the section.
 ///
 /// It reads the content of the section.
 virtual void read(std::istream& is) {
-if (!edgeIdReader->isIdReader()) {
+if (!edgeLabelReader->isLabelReader()) {
-	throw DataFormatError("Cannot find undirected edgeset or ID map");
+	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
-if (!undirEdgeIdReader->isIdReader()) {
+if (!undirEdgeLabelReader->isLabelReader()) {
-	throw DataFormatError("Cannot find undirected edgeset or ID map");
+	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
 std::string line;
 while (getline(is, line)) {
 	std::istringstream ls(line);
 	std::string id;
 	ls >> id;
 	{
 	  typename UndirEdgeReaders::iterator it = undirEdgeReaders.find(id);
 	  if (it != undirEdgeReaders.end()) {
-	    it->second.read(undirEdgeIdReader->read(ls));
+	    it->second.read(undirEdgeLabelReader->read(ls));
 	    it->second.touch();
 	    continue;
 	  }
 	} {
 	  typename EdgeReaders::iterator it = edgeReaders.find(id);
 	  if (it != edgeReaders.end()) {
-	    it->second.read(edgeIdReader->read(ls));
+	    it->second.read(edgeLabelReader->read(ls));
 	    it->second.touch();
 	    continue;
 	  }
 	}
 }
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::map<std::string,
 		     _reader_bits::ItemStore<UndirEdge> > UndirEdgeReaders;
 UndirEdgeReaders undirEdgeReaders;
-std::auto_ptr<_reader_bits::IdReaderBase<UndirEdge> > undirEdgeIdReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<UndirEdge> > undirEdgeLabelReader;
 typedef std::map<std::string, _reader_bits::ItemStore<Edge> > EdgeReaders;
 EdgeReaders edgeReaders;
-std::auto_ptr<_reader_bits::IdReaderBase<Edge> > edgeIdReader;
+std::auto_ptr<_reader_bits::LabelReaderBase<Edge> > edgeLabelReader;
 };
 /// \ingroup io_group
 /// \brief SectionReader for attributes.
 ///
 /// The lemon format can store multiple attribute set. Each set has
-/// the header line \c \@attributes \c attributeset_id, but the
+/// the header line \c \@attributes \c attributeset_name, but the
-/// attributeset_id may be empty.
+/// attributeset_name may be empty.
 ///
 /// The attributeset section contains several lines. Each of them starts
 /// with an attribute and then a the value for the id.
 ///
 /// \relates LemonReader
 public:
 /// \brief Constructor.
 ///
 /// Constructor for AttributeReader. It creates the AttributeReader and
 /// attach it into the given LemonReader. The reader process a section
-/// only if the \c section_id and the \c _id are the same.
+/// only if the \c section_name and the \c _name are the same.
 AttributeReader(LemonReader& _reader,
-		    const std::string& _id = std::string())
+		    const std::string& _name = std::string())
-: Parent(_reader), id(_id) {}
+: Parent(_reader), name(_name) {}
 /// \brief Destructor.
 ///
 /// Destructor for AttributeReader.
 virtual ~AttributeReader() {
 /// It gives back true when the header line start with \c \@attributes,
 /// and the header line's id and the attributeset's id are the same.
 bool header(const std::string& line) {
 std::istringstream ls(line);
 std::string command;
-std::string name;
+std::string id;
 ls >> command >> name;
 return command == "@attributes" && name == id;
 }
 /// \brief Reader function of the section.
 	std::string id;
 	ls >> id;
 	typename Readers::iterator it = readers.find(id);
 	if (it != readers.end()) {
 	  it->second->read(ls);
 	  it->second->touch();
 	}
 }
 for (typename Readers::iterator it = readers.begin();
 	   it != readers.end(); ++it) {
 	if (!it->second->touched()) {
 	}
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::map<std::string, _reader_bits::ValueReaderBase*> Readers;
 Readers readers;
 };
 }
 private:
 void readMapNames(std::istream& is, std::vector<std::string>& maps) {
-std::string line, id;
+std::string line, name;
 std::getline(is, line);
 std::istringstream ls(line);
-while (ls >> id) {
+while (ls >> name) {
-	maps.push_back(id);
+	maps.push_back(name);
 }
 while (getline(is, line));
 }
 void readItemNames(std::istream& is, std::vector<std::string>& maps) {
-std::string line, id;
+std::string line, name;
 while (std::getline(is, line)) {
 	std::istringstream ls(line);
-	ls >> id;
+	ls >> name;
-	maps.push_back(id);
+	maps.push_back(name);
 }
 }
 struct SectionInfo {
 std::string name;

changeset 1903	f3d24016dad5
parent 1875	98698b69a902
child 1909	2d806130e700