lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:2a332d65368e
+:f56ab4dfc450
 namespace lemon {
 namespace _writer_bits {
 template <typename Item>
-class ItemIdWriter {
+class ItemLabelWriter {
 public:
-bool isIdWriter() { return true; }
+bool isLabelWriter() { return true; }
-void writeId(std::ostream&, const Item&) {}
+void writeLabel(std::ostream&, const Item&) {}
-template <class _ItemIdWriter>
+template <class _ItemLabelWriter>
 struct Constraints {
 	void constraints() {
-	  bool b = writer.isIdWriter();
+	  bool b = writer.isLabelWriter();
 	  ignore_unused_variable_warning(b);
-	  writer.writeId(os, item);
+	  writer.writeLabel(os, item);
 	}
-	_ItemIdWriter& writer;
+	_ItemLabelWriter& writer;
 	std::ostream& os;
 	const Item& item;
 };
 };
 Writer writer;
 };
 template <typename _Item>
-class IdWriterBase {
+class LabelWriterBase {
 public:
 typedef _Item Item;
-virtual ~IdWriterBase() {}
+virtual ~LabelWriterBase() {}
 virtual void write(std::ostream&, const Item&) const = 0;
-virtual bool isIdWriter() const = 0;
+virtual bool isLabelWriter() const = 0;
 };
-template <typename _Item, typename _BoxedIdWriter>
+template <typename _Item, typename _BoxedLabelWriter>
-class IdWriter : public IdWriterBase<_Item> {
+class LabelWriter : public LabelWriterBase<_Item> {
 public:
 typedef _Item Item;
-typedef _BoxedIdWriter BoxedIdWriter;
+typedef _BoxedLabelWriter BoxedLabelWriter;
-const BoxedIdWriter& idWriter;
+const BoxedLabelWriter& labelWriter;
-IdWriter(const BoxedIdWriter& _idWriter)
+LabelWriter(const BoxedLabelWriter& _labelWriter)
-	: idWriter(_idWriter) {}
+	: labelWriter(_labelWriter) {}
 virtual void write(std::ostream& os, const Item& item) const {
-	idWriter.writeId(os, item);
+	labelWriter.writeLabel(os, item);
 }
-virtual bool isIdWriter() const {
+virtual bool isLabelWriter() const {
-	return idWriter.isIdWriter();
+	return labelWriter.isLabelWriter();
 }
 };
 }
 /// \ingroup io_group
 /// \brief SectionWriter for writing 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
-/// \c nodeset_id may be empty.
+/// the \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
+/// as label map. This map should contain only unique values and when the
-/// \c writeId() member will be called with a node it will write it's id.
+/// \c writeLabel() member will be called with a node it will write it's
-/// Otherwise if the \c _forceIdMap constructor parameter is true then
+/// label. Otherwise if the \c _forceLabelMap constructor parameter is true
-/// the id map will be the id in the graph.
+/// then the label map will be the id in the graph.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
 class NodeSetWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 typedef typename Graph::Node Node;
 /// \brief Constructor.
 ///
 /// Constructor for NodeSetWriter. It creates the NodeSetWriter and
-/// attach it into the given LemonWriter. If the \c _forceIdMap
+/// attach it into the given LemonWriter. If the \c _forceLabelMap
-/// parameter is true then the writer will write own id map when
+/// parameter is true then the writer will write own label map when
-/// the user does not give "id" named map.
+/// the user does not give "label" named map.
 NodeSetWriter(LemonWriter& _writer, const Graph& _graph,
-		  const std::string& _id = std::string(),
+		  const std::string& _name = std::string(),
-		  bool _forceIdMap = true)
+		  bool _forceLabelMap = true)
-: Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
+: Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
-	graph(_graph), id(_id) {}
+	graph(_graph), name(_name) {}
 /// \brief Destructor.
 ///
 /// Destructor for NodeSetWriter.
 virtual ~NodeSetWriter() {
 /// \brief The header of the section.
 ///
 /// It gives back the header of the section.
 virtual std::string header() {
-return "@nodeset " + id;
+return "@nodeset " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
 for (int i = 0; i < (int)writers.size(); ++i) {
-	if (writers[i].first == "id") {
+	if (writers[i].first == "label" || (writers[i].first == "id" && labelMap == 0)) {
-	  idMap = writers[i].second;
+	  labelMap = writers[i].second;
-	  forceIdMap = false;
+	  forceLabelMap = false;
 	  break;
 	}
 }
-if (forceIdMap) {
+if (forceLabelMap) {
-	os << "id\t";
+	os << "label\t";
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
 	os << writers[i].first << '\t';
 }
 os << std::endl;
 for (typename Graph::NodeIt it(graph); it != INVALID; ++it) {
-	if (forceIdMap) {
+	if (forceLabelMap) {
 	  os << graph.id(it) << '\t';
 	}
 	for (int i = 0; i < (int)writers.size(); ++i) {
 	  writers[i].second->write(os, it);
 	  os << '\t';
 }
 }
 public:
-/// \brief Returns true if the nodeset can write the ids of the nodes.
+/// \brief Returns true if the nodeset can write the labels of the nodes.
 ///
-/// Returns true if the nodeset can write the ids of the nodes.
+/// Returns true if the nodeset can write the labels of the nodes.
-/// It is possible only if an "id" named map was written or the
+/// It is possible only if an "label" named map was written or the
-/// \c _forceIdMap constructor parameter was true.
+/// \c _forceLabelMap constructor parameter was true.
-bool isIdWriter() const {
+bool isLabelWriter() const {
-return idMap != 0 || forceIdMap;
+return labelMap != 0 || forceLabelMap;
 }
-/// \brief Write the id of the given node.
+/// \brief Write the label of the given node.
 ///
-/// It writes the id of the given node. If there was written an "id"
+/// It writes the label of the given node. If there was written an "label"
 /// named map then it will write the map value belongs to the node.
-/// Otherwise if the \c forceId parameter was true it will write
+/// Otherwise if the \c forceLabel parameter was true it will write
-/// its id in the graph.
+/// its label in the graph.
-void writeId(std::ostream& os, const Node& item) const {
+void writeLabel(std::ostream& os, const Node& item) const {
-if (forceIdMap) {
+if (forceLabelMap) {
 	os << graph.id(item);
 } else {
-	idMap->write(os, item);
+	labelMap->write(os, item);
 }
 }
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
 				  MapWriterBase<Node>*> > MapWriters;
 MapWriters writers;
-_writer_bits::MapWriterBase<Node>* idMap;
+_writer_bits::MapWriterBase<Node>* labelMap;
-bool forceIdMap;
+bool forceLabelMap;
 const Graph& graph;
-std::string id;
+std::string name;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing a graph's edgesets.
 ///
 /// 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
-/// \c edgeset_id may be empty.
+/// the \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 a edge in the edgeset. The
-/// line contains the source and the target nodes' id and the mapped
+/// line contains the source and the target nodes' label 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
+/// as label map. This map should contain only unique values and when the
-/// \c writeId() member will be called with an edge it will write it's id.
+/// \c writeLabel() member will be called with an edge it will write it's
-/// Otherwise if the \c _forceIdMap constructor parameter is true then
+/// label. Otherwise if the \c _forceLabelMap constructor parameter is true
-/// the id map will be the id in the graph.
+/// then the label map will be the id in the graph.
 ///
-/// The edgeset writer needs a node id writer to identify which nodes
+/// The edgeset writer needs a node label writer to identify which nodes
-/// have to be connected. If a NodeSetWriter can write the nodes' id,
+/// have to be connected. If a NodeSetWriter can write the nodes' label,
 /// it will be able to use with this class.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
 class EdgeSetWriter : public LemonWriter::SectionWriter {
 typedef typename Graph::Edge Edge;
 /// \brief Constructor.
 ///
 /// Constructor for EdgeSetWriter. It creates the EdgeSetWriter and
-/// attach it into the given LemonWriter. It will write node ids by
+/// attach it into the given LemonWriter. It will write node labels by
-/// the \c _nodeIdWriter. If the \c _forceIdMap parameter is true
+/// the \c _nodeLabelWriter. If the \c _forceLabelMap parameter is true
-/// then the writer will write own id map if the user does not give
+/// then the writer will write own label map if the user does not give
-/// "id" named map.
+/// "label" named map.
-template <typename NodeIdWriter>
+template <typename NodeLabelWriter>
 EdgeSetWriter(LemonWriter& _writer, const Graph& _graph,
-		  const NodeIdWriter& _nodeIdWriter,
+		  const NodeLabelWriter& _nodeLabelWriter,
-		  const std::string& _id = std::string(),
+		  const std::string& _name = std::string(),
-		  bool _forceIdMap = true)
+		  bool _forceLabelMap = true)
-: Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
+: Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
-	graph(_graph), id(_id) {
+	graph(_graph), name(_name) {
-checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<Node>, NodeLabelWriter>();
-nodeIdWriter.reset(new _writer_bits::
+nodeLabelWriter.reset(new _writer_bits::
-			 IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
+			 LabelWriter<Node, NodeLabelWriter>(_nodeLabelWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for EdgeSetWriter.
 /// \brief The header of the section.
 ///
 /// It gives back the header of the section.
 virtual std::string header() {
-return "@edgeset " + id;
+return "@edgeset " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
-if (!nodeIdWriter->isIdWriter()) {
+if (!nodeLabelWriter->isLabelWriter()) {
-	throw DataFormatError("Cannot find nodeset or ID map");
+	throw DataFormatError("Cannot find nodeset or label map");
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
-	if (writers[i].first == "id") {
+	if (writers[i].first == "label" || (writers[i].first == "id" && labelMap == 0)) {
-	  idMap = writers[i].second;
+	  labelMap = writers[i].second;
-	  forceIdMap = false;
+	  forceLabelMap = false;
 	  break;
 	}
 }
 os << "\t\t";
-if (forceIdMap) {
+if (forceLabelMap) {
-	os << "id\t";
+	os << "label\t";
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
 	os << writers[i].first << '\t';
 }
 os << std::endl;
 for (typename Graph::EdgeIt it(graph); it != INVALID; ++it) {
-	nodeIdWriter->write(os, graph.source(it));
+	nodeLabelWriter->write(os, graph.source(it));
 	os << '\t';
-	nodeIdWriter->write(os, graph.target(it));
+	nodeLabelWriter->write(os, graph.target(it));
 	os << '\t';
-	if (forceIdMap) {
+	if (forceLabelMap) {
 	  os << graph.id(it) << '\t';
 	}
 	for (int i = 0; i < (int)writers.size(); ++i) {
 	  writers[i].second->write(os, it);
 	  os << '\t';
 }
 }
 public:
-/// \brief Returns true if the edgeset can write the ids of the edges.
+/// \brief Returns true if the edgeset can write the labels of the edges.
 ///
-/// Returns true if the edgeset can write the ids of the edges.
+/// Returns true if the edgeset can write the labels of the edges.
-/// It is possible only if an "id" named map was written or the
+/// It is possible only if an "label" named map was written or the
-/// \c _forceIdMap constructor parameter was true.
+/// \c _forceLabelMap constructor parameter was true.
-bool isIdWriter() const {
+bool isLabelWriter() const {
-return forceIdMap || idMap != 0;
+return forceLabelMap || labelMap != 0;
 }
-/// \brief Write the id of the given edge.
+/// \brief Write the label of the given edge.
 ///
-/// It writes the id of the given edge. If there was written an "id"
+/// It writes the label of the given edge. If there was written an "label"
 /// named map then it will write the map value belongs to the edge.
-/// Otherwise if the \c forceId parameter was true it will write
+/// Otherwise if the \c forceLabel parameter was true it will write
-/// its id in the graph.
+/// its label in the graph.
-void writeId(std::ostream& os, const Edge& item) const {
+void writeLabel(std::ostream& os, const Edge& item) const {
-if (forceIdMap) {
+if (forceLabelMap) {
 	os << graph.id(item);
 } else {
-	idMap->write(os, item);
+	labelMap->write(os, item);
 }
 }
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
 				  MapWriterBase<Edge>*> > MapWriters;
 MapWriters writers;
-_writer_bits::MapWriterBase<Edge>* idMap;
+_writer_bits::MapWriterBase<Edge>* labelMap;
-bool forceIdMap;
+bool forceLabelMap;
 const Graph& graph;
-std::string id;
+std::string name;
-std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<Node> > nodeLabelWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing a undirected 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 undirected edge in the
-/// edgeset. The line contains the two connected nodes' id and the mapped
+/// edgeset. The line contains the two connected nodes' label and the mapped
 /// values for each undirected map.
 ///
 /// The section can handle the directed as a syntactical sugar. Two
 /// 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
+/// as label map. This map should contain only unique values and when the
-/// \c writeId() member will be called with an undirected edge it will
+/// \c writeLabel() member will be called with an undirected edge it will
-/// write it's id. Otherwise if the \c _forceIdMap constructor parameter
+/// write it's label. Otherwise if the \c _forceLabelMap constructor
-/// is true then the id map will be the id in the graph.
+/// parameter is true then the label map will be the id in the graph.
 ///
-/// The undirected edgeset writer needs a node id writer to identify
+/// The undirected edgeset writer needs a node label writer to identify
 /// which nodes have to be connected. If a NodeSetWriter can write the
-/// nodes' id, it will be able to use with this class.
+/// nodes' label, it will be able to use with this class.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
 class UndirEdgeSetWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 typedef typename Graph::UndirEdge UndirEdge;
 /// \brief Constructor.
 ///
 /// Constructor for UndirEdgeSetWriter. It creates the UndirEdgeSetWriter
-/// and attach it into the given LemonWriter. It will write node ids by
+/// and attach it into the given LemonWriter. It will write node labels by
-/// the \c _nodeIdWriter. If the \c _forceIdMap parameter is true
+/// the \c _nodeLabelWriter. If the \c _forceLabelMap parameter is true
-/// then the writer will write own id map if the user does not give
+/// then the writer will write own label map if the user does not give
-/// "id" named map.
+/// "label" named map.
-template <typename NodeIdWriter>
+template <typename NodeLabelWriter>
 UndirEdgeSetWriter(LemonWriter& _writer, const Graph& _graph,
-		       const NodeIdWriter& _nodeIdWriter,
+		       const NodeLabelWriter& _nodeLabelWriter,
-		       const std::string& _id = std::string(),
+		       const std::string& _name = std::string(),
-		       bool _forceIdMap = true)
+		       bool _forceLabelMap = true)
-: Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
+: Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
-	graph(_graph), id(_id) {
+	graph(_graph), name(_name) {
-checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<Node>, NodeLabelWriter>();
-nodeIdWriter.reset(new _writer_bits::
+nodeLabelWriter.reset(new _writer_bits::
-			 IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
+			 LabelWriter<Node, NodeLabelWriter>(_nodeLabelWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeSetWriter.
 /// \brief The header of the section.
 ///
 /// It gives back the header of the section.
 virtual std::string header() {
-return "@undiredgeset " + id;
+return "@undiredgeset " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
-if (!nodeIdWriter->isIdWriter()) {
+if (!nodeLabelWriter->isLabelWriter()) {
-	throw DataFormatError("Cannot find nodeset or ID map");
+	throw DataFormatError("Cannot find nodeset or label map");
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
-	if (writers[i].first == "id") {
+	if (writers[i].first == "label") {
-	  idMap = writers[i].second;
+	  labelMap = writers[i].second;
-	  forceIdMap = false;
+	  forceLabelMap = false;
 	  break;
 	}
 }
 os << "\t\t";
-if (forceIdMap) {
+if (forceLabelMap) {
-	os << "id\t";
+	os << "label\t";
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
 	os << writers[i].first << '\t';
 }
 os << std::endl;
 for (typename Graph::UndirEdgeIt it(graph); it != INVALID; ++it) {
-	nodeIdWriter->write(os, graph.source(it));
+	nodeLabelWriter->write(os, graph.source(it));
 	os << '\t';
-	nodeIdWriter->write(os, graph.target(it));
+	nodeLabelWriter->write(os, graph.target(it));
 	os << '\t';
-	if (forceIdMap) {
+	if (forceLabelMap) {
 	  os << graph.id(it) << '\t';
 	}
 	for (int i = 0; i < (int)writers.size(); ++i) {
 	  writers[i].second->write(os, it);
 	  os << '\t';
 }
 }
 public:
-/// \brief Returns true if the undirected edgeset can write the ids of
+/// \brief Returns true if the undirected edgeset can write the labels of
 /// the edges.
 ///
-/// Returns true if the undirected edgeset can write the ids of the
+/// Returns true if the undirected edgeset can write the labels of the
-/// undirected edges. It is possible only if an "id" named map was
+/// undirected edges. It is possible only if an "label" named map was
-/// written or the \c _forceIdMap constructor parameter was true.
+/// written or the \c _forceLabelMap constructor parameter was true.
-bool isIdWriter() const {
+bool isLabelWriter() const {
-return forceIdMap || idMap != 0;
+return forceLabelMap || labelMap != 0;
 }
-/// \brief Write the id of the given undirected edge.
+/// \brief Write the label of the given undirected edge.
 ///
-/// It writes the id of the given undirected edge. If there was written
+/// It writes the label of the given undirected edge. If there was written
-/// an "id" named map then it will write the map value belongs to the
+/// an "label" named map then it will write the map value belongs to the
-/// undirected edge. Otherwise if the \c forceId parameter was true it
+/// undirected edge. Otherwise if the \c forceLabel parameter was true it
 /// will write its id in the graph.
-void writeId(std::ostream& os, const UndirEdge& item) const {
+void writeLabel(std::ostream& os, const UndirEdge& item) const {
-if (forceIdMap) {
+if (forceLabelMap) {
 	os << graph.id(item);
 } else {
-	idMap->write(os, item);
+	labelMap->write(os, item);
 }
 }
-/// \brief Write the id of the given edge.
+/// \brief Write the label of the given edge.
 ///
-/// It writes the id of the given edge. If there was written
+/// It writes the label of the given edge. If there was written
-/// an "id" named map then it will write the map value belongs to the
+/// an "label" named map then it will write the map value belongs to the
-/// edge. Otherwise if the \c forceId parameter was true it
+/// edge. Otherwise if the \c forceLabel parameter was true it
 /// will write its id in the graph. If the edge is forward map
 /// then its prefix character is \c '+' elsewhere \c '-'.
-void writeId(std::ostream& os, const Edge& item) const {
+void writeLabel(std::ostream& os, const Edge& item) const {
 if (graph.direction(item)) {
 	os << "+ ";
 } else {
 	os << "- ";
 }
-if (forceIdMap) {
+if (forceLabelMap) {
 	os << graph.id(item);
 } else {
-	idMap->write(os, item);
+	labelMap->write(os, item);
 }
 }
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
 				  MapWriterBase<UndirEdge>*> > MapWriters;
 MapWriters writers;
-_writer_bits::MapWriterBase<UndirEdge>* idMap;
+_writer_bits::MapWriterBase<UndirEdge>* labelMap;
-bool forceIdMap;
+bool forceLabelMap;
 const Graph& graph;
-std::string id;
+std::string name;
-std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<Node> > nodeLabelWriter;
 };
 /// \ingroup io_group
-/// \brief SectionWriter for writing labeled nodes.
+/// \brief SectionWriter for writing named 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 label of the node and
+/// Each line in the section contains the name of the node and
-/// then the node id.
+/// then the node label.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
 class NodeWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for NodeWriter. It creates the NodeWriter and
-/// attach it into the given LemonWriter. The given \c _IdWriter
+/// attach it into the given LemonWriter. The given \c _LabelWriter
-/// will write the nodes' id what can be a nodeset writer.
+/// will write the nodes' label what can be a nodeset writer.
-template <typename _IdWriter>
+template <typename _LabelWriter>
-NodeWriter(LemonWriter& _writer, const _IdWriter& _idWriter,
+NodeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter,
-	       const std::string& _id = std::string())
+	       const std::string& _name = std::string())
-: Parent(_writer), id(_id) {
+: Parent(_writer), name(_name) {
-checkConcept<_writer_bits::ItemIdWriter<Node>, _IdWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<Node>, _LabelWriter>();
-idWriter.reset(new _writer_bits::IdWriter<Node, _IdWriter>(_idWriter));
+labelWriter.reset(new _writer_bits::LabelWriter<Node, _LabelWriter>
+(_labelWriter));
 }
 /// \brief Destructor.
 ///
 writers.push_back(make_pair(name, &item));
 }
 protected:
-/// \brief Header checking function.
+/// \brief The header of the section.
 ///
-/// It gives back true when the header line start with \c \@nodes,
+/// It gives back the header of the section.
-/// and the header line's id and the writer's id are the same.
 virtual std::string header() {
-return "@nodes " + id;
+return "@nodes " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
-if (!idWriter->isIdWriter()) {
+if (!labelWriter->isLabelWriter()) {
-	throw DataFormatError("Cannot find nodeset or ID map");
+	throw DataFormatError("Cannot find nodeset or label map");
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
 	os << writers[i].first << ' ';
-	idWriter->write(os, *(writers[i].second));
+	labelWriter->write(os, *(writers[i].second));
 	os << std::endl;
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::vector<std::pair<std::string, const Node*> > NodeWriters;
 NodeWriters writers;
-std::auto_ptr<_writer_bits::IdWriterBase<Node> > idWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<Node> > labelWriter;
 };
 /// \ingroup io_group
-/// \brief SectionWriter for writing labeled edges.
+/// \brief SectionWriter for writing named 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 label of the edge and
+/// Each line in the section contains the name of the edge and
-/// then the edge id.
+/// then the edge label.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
 class EdgeWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for EdgeWriter. It creates the EdgeWriter and
-/// attach it into the given LemonWriter. The given \c _IdWriter
+/// attach it into the given LemonWriter. The given \c _LabelWriter
-/// will write the edges' id what can be a edgeset writer.
+/// will write the edges' label what can be a edgeset writer.
-template <typename _IdWriter>
+template <typename _LabelWriter>
-EdgeWriter(LemonWriter& _writer, const _IdWriter& _idWriter,
+EdgeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter,
-	       const std::string& _id = std::string())
+	       const std::string& _name = std::string())
-: Parent(_writer), id(_id) {
+: Parent(_writer), name(_name) {
-checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<Edge>, _LabelWriter>();
-idWriter.reset(new _writer_bits::IdWriter<Edge, _IdWriter>(_idWriter));
+labelWriter.reset(new _writer_bits::LabelWriter<Edge, _LabelWriter>(_labelWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for EdgeWriter.
 writers.push_back(make_pair(name, &item));
 }
 protected:
-/// \brief Header checking function.
+/// \brief The header of the section.
 ///
-/// It gives back true when the header line start with \c \@edges,
+/// It gives back the header of the section.
-/// and the header line's id and the writer's id are the same.
 virtual std::string header() {
-return "@edges " + id;
+return "@edges " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
-if (!idWriter->isIdWriter()) {
+if (!labelWriter->isLabelWriter()) {
-	throw DataFormatError("Cannot find edgeset or ID map");
+	throw DataFormatError("Cannot find edgeset or label map");
 }
 for (int i = 0; i < (int)writers.size(); ++i) {
 	os << writers[i].first << ' ';
-	idWriter->write(os, *(writers[i].second));
+	labelWriter->write(os, *(writers[i].second));
 	os << std::endl;
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
 EdgeWriters writers;
-std::auto_ptr<_writer_bits::IdWriterBase<Edge> > idWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > labelWriter;
 };
 /// \ingroup io_group
-/// \brief SectionWriter for writing labeled undirected edges.
+/// \brief SectionWriter for writing named 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 label of the undirected edge and
+/// Each line in the section contains the name of the undirected edge and
-/// then the undirected edge id.
+/// then the undirected edge label.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
 class UndirEdgeWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for UndirEdgeWriter. It creates the UndirEdgeWriter and
-/// attach it into the given LemonWriter. The given \c _IdWriter
+/// attach it into the given LemonWriter. The given \c _LabelWriter
-/// will write the undirected edges' id what can be an undirected
+/// will write the undirected edges' label what can be an undirected
 /// edgeset writer.
-template <typename _IdWriter>
+template <typename _LabelWriter>
-UndirEdgeWriter(LemonWriter& _writer, const _IdWriter& _idWriter,
+UndirEdgeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter,
-	       const std::string& _id = std::string())
+	       const std::string& _name = std::string())
-: Parent(_writer), id(_id) {
+: Parent(_writer), name(_name) {
-checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<Edge>, _LabelWriter>();
-checkConcept<_writer_bits::ItemIdWriter<UndirEdge>, _IdWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<UndirEdge>, _LabelWriter>();
-undirEdgeIdWriter.reset(new _writer_bits::
+undirEdgeLabelWriter.reset(new _writer_bits::
-			      IdWriter<UndirEdge, _IdWriter>(_idWriter));
+			      LabelWriter<UndirEdge, _LabelWriter>(_labelWriter));
-edgeIdWriter.reset(new _writer_bits::
+edgeLabelWriter.reset(new _writer_bits::
-			 IdWriter<Edge, _IdWriter>(_idWriter));
+			 LabelWriter<Edge, _LabelWriter>(_labelWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeWriter.
 undirEdgeWriters.push_back(make_pair(name, &item));
 }
 protected:
-/// \brief Header checking function.
+/// \brief The header of the section.
 ///
-/// It gives back true when the header line start with \c \@undiredges,
+/// It gives back the header of the section.
-/// and the header line's id and the writer's id are the same.
 virtual std::string header() {
-return "@undiredges " + id;
+return "@undiredges " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
-if (!edgeIdWriter->isIdWriter()) {
+if (!edgeLabelWriter->isLabelWriter()) {
-	throw DataFormatError("Cannot find undirected edgeset or ID map");
+	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
-if (!undirEdgeIdWriter->isIdWriter()) {
+if (!undirEdgeLabelWriter->isLabelWriter()) {
-	throw DataFormatError("Cannot find undirected edgeset or ID map");
+	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
 for (int i = 0; i < (int)undirEdgeWriters.size(); ++i) {
 	os << undirEdgeWriters[i].first << ' ';
-	undirEdgeIdWriter->write(os, *(undirEdgeWriters[i].second));
+	undirEdgeLabelWriter->write(os, *(undirEdgeWriters[i].second));
 	os << std::endl;
 }
 for (int i = 0; i < (int)edgeWriters.size(); ++i) {
 	os << edgeWriters[i].first << ' ';
-	edgeIdWriter->write(os, *(edgeWriters[i].second));
+	edgeLabelWriter->write(os, *(edgeWriters[i].second));
 	os << std::endl;
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::vector<std::pair<std::string,
 				  const UndirEdge*> > UndirEdgeWriters;
 UndirEdgeWriters undirEdgeWriters;
-std::auto_ptr<_writer_bits::IdWriterBase<UndirEdge> > undirEdgeIdWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<UndirEdge> > undirEdgeLabelWriter;
 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
 EdgeWriters edgeWriters;
-std::auto_ptr<_writer_bits::IdWriterBase<Edge> > edgeIdWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > edgeLabelWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter 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 attributes_name, but the
-/// attributeset_id may be empty.
+/// attributeset_name may be empty.
 ///
 /// The attributeset section contains several lines. Each of them starts
 /// with the name of attribute and then the value.
 ///
 /// \relates LemonWriter
 /// \brief Constructor.
 ///
 /// Constructor for AttributeWriter. It creates the AttributeWriter and
 /// attach it into the given LemonWriter.
 AttributeWriter(LemonWriter& _writer,
-		    const std::string& _id = std::string())
+		    const std::string& _name = std::string())
-: Parent(_writer), id(_id) {}
+: Parent(_writer), name(_name) {}
 /// \brief Destructor.
 ///
 /// Destructor for AttributeWriter.
 virtual ~AttributeWriter() {
 public:
 /// \brief Add an attribute writer command for the writer.
 ///
 /// Add an attribute writer command for the writer.
 template <typename Value>
-AttributeWriter& writeAttribute(const std::string& id,
+AttributeWriter& writeAttribute(const std::string& name,
 				    const Value& value) {
 return
-	writeAttribute<typename Traits::template Writer<Value> >(id, value);
+	writeAttribute<typename Traits::template Writer<Value> >(name, value);
 }
 /// \brief Add an attribute writer command for the writer.
 ///
 /// Add an attribute writer command for the writer.
 /// \brief The header of section.
 ///
 /// It gives back the header of the section.
 std::string header() {
-return "@attributes " + id;
+return "@attributes " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 	os << std::endl;
 }
 }
 private:
-std::string id;
+std::string name;
 typedef std::vector<std::pair<std::string,
 				  _writer_bits::ValueWriterBase*> > Writers;
 Writers writers;
 };

changeset 1905	b0b3fa857d72
parent 1875	98698b69a902
child 1909	2d806130e700