lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:7116138bd85c
+:dbed5069139f
 }
 const Map& map;
 Less<typename Map::Value> less;
 };
+template <typename UGraph, typename Map>
+struct UEdgeComposeLess {
+UEdgeComposeLess(const UGraph& _ugraph, const Map& _map)
+	: ugraph(_ugraph), map(_map), less() {}
+bool operator()(const typename UGraph::Edge& p,
+const typename UGraph::Edge& q) const {
+	return p != q ? less(map[p], map[q]) :
+	  (!ugraph.direction(p) && ugraph.direction(q));
+}
+const UGraph& ugraph;
+const Map& map;
+Less<typename Map::Value> less;
+};
 template <typename Item>
 class ItemLabelWriter {
 public:
 bool isLabelWriter() { return true; }
 typedef typename Map::Value Value;
 ForwardComposeMap(const Graph& _graph, const Map& _map)
 	: graph(_graph), map(_map) {}
-Value operator[](const Key& key) {
+Value operator[](const Key& key) const {
-	return map[graph.direct(key, false)];
+	return map[graph.direct(key, true)];
 }
 private:
 typename Ref<Map>::Type map;
 const Graph& graph;
 typedef typename Map::Value Value;
 BackwardComposeMap(const Graph& _graph, const Map& _map)
 	: graph(_graph), map(_map) {}
-Value operator[](const Key& key) {
+Value operator[](const Key& key) const {
 	return map[graph.direct(key, false)];
 }
 private:
 typename Ref<Map>::Type map;
 typedef _Item Item;
 virtual ~MapWriterBase() {}
 virtual void write(std::ostream& os, const Item& item) const = 0;
-virtual void sortByMap(std::vector<Item>&) const = 0;
+virtual void sort(std::vector<Item>&) const = 0;
 };
 template <typename _Item, typename _Map, typename _Writer>
 class MapWriter : public MapWriterBase<_Item> {
 virtual void write(std::ostream& os, const Item& item) const {
 	Value value = map[item];
 	writer.write(os, value);
 }
-virtual void sortByMap(std::vector<Item>& items) const {
+virtual void sort(std::vector<Item>& items) const {
+ComposeLess<Map> less(map);
+std::sort(items.begin(), items.end(), less);
+}
+};
+template <typename _UGraph>
+class UEdgeMapWriterBase {
+public:
+typedef typename _UGraph::Edge Edge;
+typedef typename _UGraph::UEdge UEdge;
+typedef UEdge Item;
+virtual ~UEdgeMapWriterBase() {}
+virtual void write(std::ostream& os, const Item& item) const = 0;
+virtual void sort(const _UGraph&, std::vector<Edge>&) const = 0;
+virtual void sort(std::vector<UEdge>&) const = 0;
+};
+template <typename _UGraph, typename _Map, typename _Writer>
+class UEdgeMapWriter : public UEdgeMapWriterBase<_UGraph> {
+public:
+typedef _Map Map;
+typedef _Writer Writer;
+typedef typename Writer::Value Value;
+typedef typename _UGraph::Edge Edge;
+typedef typename _UGraph::UEdge UEdge;
+typedef UEdge Item;
+typename _writer_bits::Ref<Map>::Type map;
+Writer writer;
+UEdgeMapWriter(const Map& _map, const Writer& _writer)
+	: map(_map), writer(_writer) {}
+virtual ~UEdgeMapWriter() {}
+virtual void write(std::ostream& os, const Item& item) const {
+	Value value = map[item];
+	writer.write(os, value);
+}
+virtual void sort(const _UGraph& ugraph, std::vector<Edge>& items) const {
+UEdgeComposeLess<_UGraph, Map> less(ugraph, map);
+std::sort(items.begin(), items.end(), less);
+}
+virtual void sort(std::vector<UEdge>& items) const {
 ComposeLess<Map> less(map);
 std::sort(items.begin(), items.end(), less);
 }
 };
 class LabelWriterBase {
 public:
 typedef _Item Item;
 virtual ~LabelWriterBase() {}
 virtual void write(std::ostream&, const Item&) const = 0;
+virtual void sort(std::vector<Item>&) const = 0;
 virtual bool isLabelWriter() const = 0;
+virtual LabelWriterBase* clone() const = 0;
 };
 template <typename _Item, typename _BoxedLabelWriter>
 class LabelWriter : public LabelWriterBase<_Item> {
 public:
 	: labelWriter(_labelWriter) {}
 virtual void write(std::ostream& os, const Item& item) const {
 	labelWriter.writeLabel(os, item);
 }
+virtual void sort(std::vector<Item>& items) const {
+	labelWriter.sortByLabel(items);
+}
 virtual bool isLabelWriter() const {
 	return labelWriter.isLabelWriter();
+}
+virtual LabelWriter* clone() const {
+	return new LabelWriter(labelWriter);
 }
 };
 }
 /// If the nodeset contains an \c "label" named map then it will be regarded
 /// as label map. This map should contain only unique values and when the
 /// \c writeLabel() member will be called with a node it will write it's
 /// label. Otherwise if the \c _forceLabelMap constructor parameter is true
 /// then the label map will be the id in the graph. In addition if the
-/// the \c _sortByLabel is true then the writer will write the edges
+/// the \c _forceSort is true then the writer will write the edges
 /// sorted by the labels.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
 class NodeSetWriter : public LemonWriter::SectionWriter {
 ///
 /// Constructor for NodeSetWriter. It creates the NodeSetWriter and
 /// attach it into the given LemonWriter. If the \c _forceLabelMap
 /// parameter is true then the writer will write own label map when
 /// the user does not give "label" named map. In addition if the
-/// the \c _sortByLabel is true then the writer will write the edges
+/// the \c _forceSort is true then the writer will write the edges
 /// sorted by the labels.
 NodeSetWriter(LemonWriter& _writer, const Graph& _graph,
 		  const std::string& _name = std::string(),
-		  bool _forceLabelMap = true, bool _sortByLabel = true)
+		  bool _forceLabelMap = true, bool _forceSort = true)
 : Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
-	sortByLabel(_sortByLabel), graph(_graph), name(_name) {}
+	forceSort(_forceSort), graph(_graph), name(_name) {}
 /// \brief Destructor.
 ///
 /// Destructor for NodeSetWriter.
 virtual ~NodeSetWriter() {
 }
 std::vector<Node> items;
 for (typename Graph::NodeIt it(graph); it != INVALID; ++it) {
 items.push_back(it);
 }
-if (sortByLabel) {
+if (forceSort) {
 if (labelMap) {
-labelMap->sortByMap(items);
+labelMap->sort(items);
 } else {
 typedef IdMap<Graph, Node> Map;
 Map map(graph);
 _writer_bits::ComposeLess<Map> less(map);
 std::sort(items.begin(), items.end(), less);
 public:
 /// \brief Returns true if the nodeset can write the labels of the nodes.
 ///
 /// Returns true if the nodeset can write the labels of the nodes.
-/// It is possible only if an "label" named map was written or the
+/// It is possible only if a "label" named map was written or the
 /// \c _forceLabelMap constructor parameter was true.
 bool isLabelWriter() const {
 return labelMap != 0 || forceLabelMap;
 }
 /// \brief Write the label of the given node.
 ///
-/// It writes the label of the given node. If there was written an "label"
+/// It writes the label of the given node. If there was written a "label"
 /// named map then it will write the map value belongs to the node.
 /// Otherwise if the \c forceLabel parameter was true it will write
 /// its label in the graph.
 void writeLabel(std::ostream& os, const Node& item) const {
 if (forceLabelMap) {
 } else {
 	labelMap->write(os, item);
 }
 }
+/// \brief Sorts the given node vector by label.
+///
+/// Sorts the given node vector by label. If there was written an
+/// "label" named map then the vector will be sorted by the values
+/// of this map. Otherwise if the \c forceLabel parameter was true
+/// it will be sorted by its id in the graph.
+void sortByLabel(std::vector<Node>& nodes) const {
+if (labelMap) {
+	labelMap->sort(nodes);
+} else {
+	typedef IdMap<Graph, Node> Map;
+	Map map(graph);
+	_writer_bits::ComposeLess<Map> less(map);
+	std::sort(nodes.begin(), nodes.end(), less);
+}
+}
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
 				  MapWriterBase<Node>*> > MapWriters;
 MapWriters writers;
 _writer_bits::MapWriterBase<Node>* labelMap;
 bool forceLabelMap;
-bool sortByLabel;
+bool forceSort;
 const Graph& graph;
 std::string name;
 };
 /// If the edgeset contains an \c "label" named map then it will be regarded
 /// as label map. This map should contain only unique values and when the
 /// \c writeLabel() member will be called with an edge it will write it's
 /// label. Otherwise if the \c _forceLabelMap constructor parameter is true
 /// then the label map will be the id in the graph. In addition if the
-/// the \c _sortByLabel is true then the writer will write the edges
+/// the \c _forceSort is true then the writer will write the edges
 /// sorted by the labels.
 ///
 /// The edgeset writer needs a node label writer to identify which nodes
 /// have to be connected. If a NodeSetWriter can write the nodes' label,
 /// it will be able to use with this class.
 /// Constructor for EdgeSetWriter. It creates the EdgeSetWriter
 /// and attach it into the given LemonWriter. It will write node
 /// labels by the \c _nodeLabelWriter. If the \c _forceLabelMap
 /// parameter is true then the writer will write own label map if
 /// the user does not give "label" named map. In addition if the
-/// the \c _sortByLabel is true then the writer will write the
+/// the \c _forceSort is true then the writer will write the
 /// edges sorted by the labels.
 template <typename NodeLabelWriter>
 EdgeSetWriter(LemonWriter& _writer, const Graph& _graph,
 		  const NodeLabelWriter& _nodeLabelWriter,
 		  const std::string& _name = std::string(),
-		  bool _forceLabelMap = true, bool _sortByLabel = true)
+		  bool _forceLabelMap = true, bool _forceSort = true)
 : Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
-	sortByLabel(_sortByLabel), graph(_graph), name(_name) {
+	forceSort(_forceSort), graph(_graph), name(_name) {
 checkConcept<_writer_bits::ItemLabelWriter<Node>, NodeLabelWriter>();
 nodeLabelWriter.reset(new _writer_bits::
 			 LabelWriter<Node, NodeLabelWriter>(_nodeLabelWriter));
 }
 }
 std::vector<Edge> items;
 for (typename Graph::EdgeIt it(graph); it != INVALID; ++it) {
 items.push_back(it);
 }
-if (sortByLabel) {
+if (forceSort) {
 if (labelMap) {
-labelMap->sortByMap(items);
+labelMap->sort(items);
 } else {
 typedef IdMap<Graph, Edge> Map;
 Map map(graph);
 _writer_bits::ComposeLess<Map> less(map);
 std::sort(items.begin(), items.end(), less);
 public:
 /// \brief Returns true if the edgeset can write the labels of the edges.
 ///
 /// Returns true if the edgeset can write the labels of the edges.
-/// It is possible only if an "label" named map was written or the
+/// It is possible only if a "label" named map was written or the
 /// \c _forceLabelMap constructor parameter was true.
 bool isLabelWriter() const {
 return forceLabelMap || labelMap != 0;
 }
 /// \brief Write the label of the given edge.
 ///
-/// It writes the label of the given edge. If there was written an "label"
+/// It writes the label of the given edge. If there was written a "label"
 /// named map then it will write the map value belongs to the edge.
 /// Otherwise if the \c forceLabel parameter was true it will write
 /// its label in the graph.
 void writeLabel(std::ostream& os, const Edge& item) const {
 if (forceLabelMap) {
 } else {
 	labelMap->write(os, item);
 }
 }
+/// \brief Sorts the given edge vector by label.
+///
+/// Sorts the given edge vector by label. If there was written an
+/// "label" named map then the vector will be sorted by the values
+/// of this map. Otherwise if the \c forceLabel parameter was true
+/// it will be sorted by its id in the graph.
+void sortByLabel(std::vector<Edge>& edges) const {
+if (labelMap) {
+	labelMap->sort(edges);
+} else {
+	typedef IdMap<Graph, Edge> Map;
+	Map map(graph);
+	_writer_bits::ComposeLess<Map> less(map);
+	std::sort(edges.begin(), edges.end(), less);
+}
+}
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
 				  MapWriterBase<Edge>*> > MapWriters;
 MapWriters writers;
 _writer_bits::MapWriterBase<Edge>* labelMap;
 bool forceLabelMap;
-bool sortByLabel;
+bool forceSort;
 const Graph& graph;
 std::string name;
 std::auto_ptr<_writer_bits::LabelWriterBase<Node> > nodeLabelWriter;
 /// regarded as label map. This map should contain only unique
 /// values and when the \c writeLabel() member will be called with
 /// an undirected edge it will write it's label. Otherwise if the \c
 /// _forceLabelMap constructor parameter is true then the label map
 /// will be the id in the graph.  In addition if the the \c
-/// _sortByLabel is true then the writer will write the edges sorted
+/// _forceSort is true then the writer will write the edges sorted
 /// by the labels.
 ///
 /// The undirected edgeset writer needs a node label writer to identify
 /// which nodes have to be connected. If a NodeSetWriter can write the
 /// nodes' label, it will be able to use with this class.
 /// Constructor for UEdgeSetWriter. It creates the UEdgeSetWriter
 /// and attach it into the given LemonWriter. It will write node
 /// labels by the \c _nodeLabelWriter. If the \c _forceLabelMap
 /// parameter is true then the writer will write own label map if
 /// the user does not give "label" named map. In addition if the
-/// the \c _sortByLabel is true then the writer will write the
+/// the \c _forceSort is true then the writer will write the
 /// edges sorted by the labels.
 template <typename NodeLabelWriter>
 UEdgeSetWriter(LemonWriter& _writer, const Graph& _graph,
 		       const NodeLabelWriter& _nodeLabelWriter,
 		       const std::string& _name = std::string(),
-		       bool _forceLabelMap = true, bool _sortByLabel = true)
+		       bool _forceLabelMap = true, bool _forceSort = true)
 : Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
-	sortByLabel(_sortByLabel), graph(_graph), name(_name) {
+	forceSort(_forceSort), graph(_graph), name(_name) {
 checkConcept<_writer_bits::ItemLabelWriter<Node>, NodeLabelWriter>();
 nodeLabelWriter.reset(new _writer_bits::
-			 LabelWriter<Node, NodeLabelWriter>(_nodeLabelWriter));
+	LabelWriter<Node, NodeLabelWriter>(_nodeLabelWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UEdgeSetWriter.
 const ItemWriter& iw = ItemWriter()) {
 checkConcept<concepts::ReadMap<UEdge, typename Map::Value>, Map>();
 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, ItemWriter>();
 writers.push_back(
 	make_pair(label, new _writer_bits::
-		  MapWriter<UEdge, Map, ItemWriter>(map, iw)));
+		  UEdgeMapWriter<Graph, Map, ItemWriter>(map, iw)));
 return *this;
 }
 /// \brief Add a new directed edge map writer command for the writer.
 ///
 template <typename ItemWriter, typename Map>
 UEdgeSetWriter& writeEdgeMap(std::string label, const Map& map,
 const ItemWriter& iw = ItemWriter()) {
 checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, ItemWriter>();
-writeUEdgeMap("+" + name,
+writeUEdgeMap("+" + label,
 _writer_bits::forwardComposeMap(graph, map), iw);
-writeUEdgeMap("-" + name,
+writeUEdgeMap("-" + label,
 _writer_bits::backwardComposeMap(graph, map), iw);
 return *this;
 }
 protected:
 }
 std::vector<UEdge> items;
 for (typename Graph::UEdgeIt it(graph); it != INVALID; ++it) {
 items.push_back(it);
 }
-if (sortByLabel) {
+if (forceSort) {
 if (labelMap) {
-labelMap->sortByMap(items);
+labelMap->sort(items);
 } else {
 typedef IdMap<Graph, UEdge> Map;
 Map map(graph);
 _writer_bits::ComposeLess<Map> less(map);
 std::sort(items.begin(), items.end(), less);
 /// \brief Returns true if the undirected edgeset can write the labels of
 /// the edges.
 ///
 /// Returns true if the undirected edgeset can write the labels of the
-/// undirected edges. It is possible only if an "label" named map was
+/// undirected edges. It is possible only if a "label" named map was
 /// written or the \c _forceLabelMap constructor parameter was true.
 bool isLabelWriter() const {
 return forceLabelMap || labelMap != 0;
 }
 /// \brief Write the label of the given undirected edge.
 ///
 /// It writes the label of the given undirected edge. If there was written
-/// an "label" named map then it will write the map value belongs to the
+/// a "label" named map then it will write the map value belongs to the
 /// undirected edge. Otherwise if the \c forceLabel parameter was true it
 /// will write its id in the graph.
 void writeLabel(std::ostream& os, const UEdge& item) const {
 if (forceLabelMap) {
 	os << graph.id(item);
 }
 /// \brief Write the label of the given edge.
 ///
 /// 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
+/// a "label" named map then it will write the map value belongs to the
 /// 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 writeLabel(std::ostream& os, const Edge& item) const {
 if (graph.direction(item)) {
-	os << "+ ";
+	os << "+";
 } else {
-	os << "- ";
+	os << "-";
 }
 if (forceLabelMap) {
-	os << graph.id(item);
+	os << graph.id(static_cast<const UEdge&>(item));
 } else {
 	labelMap->write(os, item);
 }
 }
+/// \brief Sorts the given undirected edge vector by label.
+///
+/// Sorts the given undirected edge vector by label. If there was
+/// written a "label" named map then the vector will be sorted by
+/// the values of this map. Otherwise if the \c forceLabel
+/// parameter was true it will be sorted by its id in the graph.
+void sortByLabel(std::vector<UEdge>& uedges) const {
+if (labelMap) {
+	labelMap->sort(uedges);
+} else {
+	typedef IdMap<Graph, UEdge> Map;
+	Map map(graph);
+	_writer_bits::ComposeLess<Map> less(map);
+	std::sort(uedges.begin(), uedges.end(), less);
+}
+}
+/// \brief Sorts the given edge vector by label.
+///
+/// Sorts the given edge vector by label. If there was written a
+/// "label" named map then the vector will be sorted by the values
+/// of this map. Otherwise if the \c forceLabel parameter was true
+/// it will be sorted by its id in the graph.
+void sortByLabel(std::vector<Edge>& edges) const {
+if (labelMap) {
+	labelMap->sort(graph, edges);
+} else {
+	typedef IdMap<Graph, Edge> Map;
+	Map map(graph);
+	_writer_bits::ComposeLess<Map> less(map);
+	std::sort(edges.begin(), edges.end(), less);
+}
+}
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
-				  MapWriterBase<UEdge>*> > MapWriters;
+				  UEdgeMapWriterBase<Graph>*> > MapWriters;
 MapWriters writers;
-_writer_bits::MapWriterBase<UEdge>* labelMap;
+_writer_bits::UEdgeMapWriterBase<Graph>* labelMap;
 bool forceLabelMap;
-bool sortByLabel;
+bool forceSort;
 const Graph& graph;
 std::string name;
 std::auto_ptr<_writer_bits::LabelWriterBase<Node> > nodeLabelWriter;
 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
 EdgeWriters writers;
 std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > labelWriter;
 };
 /// \ingroup section_io
 /// \brief SectionWriter for writing named undirected edges.
 ///
 /// The undirected edges section's header line is \c \@uedges
 std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > edgeLabelWriter;
 };
 /// \ingroup section_io
+/// \brief SectionWriter for writing extra node maps.
+///
+/// The lemon format can store maps in the nodeset. This class let
+/// you make distinict section to store maps. The main purpose of
+/// this class is a logical separation of some maps. The other
+/// useful application could be to store paths in node maps.
+///
+/// The first line of the section contains the names of the maps
+/// separated with white spaces. Each next line describes an item
+/// in the itemset, and contains in the first column the label of
+/// the item and then the mapped values for each map.
+///
+/// \relates LemonWriter
+template <typename _Graph, typename _Traits = DefaultWriterTraits>
+class NodeMapWriter : public LemonWriter::SectionWriter {
+typedef LemonWriter::SectionWriter Parent;
+public:
+typedef _Graph Graph;
+typedef _Traits Traits;
+typedef typename Graph::Node Node;
+/// \brief Constructor.
+///
+/// Constructor for NodeMapWriter. It creates the NodeMapWriter and
+/// attach it into the given LemonWriter. If the the
+/// \c _forceSort is true then the writer will write the edges
+/// sorted by the labels.
+template <typename _LabelWriter>
+NodeMapWriter(LemonWriter& _writer, const Graph& _graph,
+		 const _LabelWriter& _labelWriter,
+		 const std::string& _name = std::string(),
+		 bool _forceSort = true)
+: Parent(_writer), graph(_graph), name(_name), forceSort(_forceSort) {
+checkConcept<_writer_bits::ItemLabelWriter<Node>, _LabelWriter>();
+labelWriter.reset(new _writer_bits::LabelWriter<Node,
+			_LabelWriter>(_labelWriter));
+}
+/// \brief Destructor.
+///
+/// Destructor for NodeMapWriter.
+virtual ~NodeMapWriter() {
+typename MapWriters::iterator it;
+for (it = writers.begin(); it != writers.end(); ++it) {
+	delete it->second;
+}
+}
+private:
+NodeMapWriter(const NodeMapWriter&);
+void operator=(const NodeMapWriter&);
+public:
+/// \brief Add a new node map writer command for the writer.
+///
+/// Add a new node map writer command for the writer.
+template <typename Map>
+NodeMapWriter& writeNodeMap(std::string label, const Map& map) {
+return writeNodeMap<typename Traits::
+	template Writer<typename Map::Value>, Map>(label, map);
+}
+/// \brief Add a new node map writer command for the writer.
+///
+/// Add a new node map writer command for the writer.
+template <typename ItemWriter, typename Map>
+NodeMapWriter& writeNodeMap(std::string label, const Map& map,
+			   const ItemWriter& iw = ItemWriter()) {
+checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+checkConcept<_writer_bits::ItemWriter<typename Map::Value>,ItemWriter>();
+writers.push_back(
+	make_pair(label, new _writer_bits::
+		  MapWriter<Node, Map, ItemWriter>(map, iw)));
+return *this;
+}
+protected:
+/// \brief The header of the section.
+///
+/// It gives back the header of the section.
+virtual std::string header() {
+return "@nodemaps " + name;
+}
+/// \brief  Writer function of the section.
+///
+/// Write the content of the section.
+virtual void write(std::ostream& os) {
+std::vector<Node> nodes;
+for (typename Graph::NodeIt it(graph); it != INVALID; ++it) {
+nodes.push_back(it);
+}
+if (forceSort) {
+	labelWriter->sort(nodes);
+}
+os << '\t';
+for (int i = 0; i < int(writers.size()); ++i) {
+	os << writers[i].first << '\t';
+}
+os << std::endl;
+for (typename std::vector<Node>::iterator it = nodes.begin();
+it != nodes.end(); ++it) {
+	labelWriter->write(os, *it); os << '\t';
+	for (int i = 0; i < int(writers.size()); ++i) {
+	  writers[i].second->write(os, *it);
+	  os << '\t';
+	}
+	os << std::endl;
+}
+}
+private:
+typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<Node>*> > MapWriters;
+MapWriters writers;
+_writer_bits::MapWriterBase<Node>* labelMap;
+const Graph& graph;
+std::string name;
+bool forceSort;
+std::auto_ptr<_writer_bits::LabelWriterBase<Node> > labelWriter;
+};
+/// \ingroup section_io
+/// \brief SectionWriter for writing extra edge maps.
+///
+/// The lemon format can store maps in the edgeset. This class let
+/// you make distinict section to store maps. The main purpose of
+/// this class is a logical separation of some maps. The other
+/// useful application could be to store paths in edge maps.
+///
+/// The first line of the section contains the names of the maps
+/// separated with white spaces. Each next line describes an item
+/// in the itemset, and contains in the first column the label of
+/// the item and then the mapped values for each map.
+///
+/// \relates LemonWriter
+template <typename _Graph, typename _Traits = DefaultWriterTraits>
+class EdgeMapWriter : public LemonWriter::SectionWriter {
+typedef LemonWriter::SectionWriter Parent;
+public:
+typedef _Graph Graph;
+typedef _Traits Traits;
+typedef typename Graph::Edge Edge;
+/// \brief Constructor.
+///
+/// Constructor for EdgeMapWriter. It creates the EdgeMapWriter and
+/// attach it into the given LemonWriter. If the the
+/// \c _forceSort is true then the writer will write the edges
+/// sorted by the labels.
+template <typename _LabelWriter>
+EdgeMapWriter(LemonWriter& _writer, const Graph& _graph,
+		 const _LabelWriter& _labelWriter,
+		 const std::string& _name = std::string(),
+		 bool _forceSort = true)
+: Parent(_writer), graph(_graph), name(_name), forceSort(_forceSort) {
+checkConcept<_writer_bits::ItemLabelWriter<Edge>, _LabelWriter>();
+labelWriter.reset(new _writer_bits::LabelWriter<Edge,
+			_LabelWriter>(_labelWriter));
+}
+/// \brief Destructor.
+///
+/// Destructor for EdgeMapWriter.
+virtual ~EdgeMapWriter() {
+typename MapWriters::iterator it;
+for (it = writers.begin(); it != writers.end(); ++it) {
+	delete it->second;
+}
+}
+private:
+EdgeMapWriter(const EdgeMapWriter&);
+void operator=(const EdgeMapWriter&);
+public:
+/// \brief Add a new edge map writer command for the writer.
+///
+/// Add a new edge map writer command for the writer.
+template <typename Map>
+EdgeMapWriter& writeEdgeMap(std::string label, const Map& map) {
+return writeEdgeMap<typename Traits::
+	template Writer<typename Map::Value>, Map>(label, map);
+}
+/// \brief Add a new edge map writer command for the writer.
+///
+/// Add a new edge map writer command for the writer.
+template <typename ItemWriter, typename Map>
+EdgeMapWriter& writeEdgeMap(std::string label, const Map& map,
+				const ItemWriter& iw = ItemWriter()) {
+checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
+checkConcept<_writer_bits::ItemWriter<typename Map::Value>,ItemWriter>();
+writers.push_back(
+	make_pair(label, new _writer_bits::
+		  MapWriter<Edge, Map, ItemWriter>(map, iw)));
+return *this;
+}
+protected:
+/// \brief The header of the section.
+///
+/// It gives back the header of the section.
+virtual std::string header() {
+return "@edgemaps " + name;
+}
+/// \brief  Writer function of the section.
+///
+/// Write the content of the section.
+virtual void write(std::ostream& os) {
+std::vector<Edge> edges;
+for (typename Graph::EdgeIt it(graph); it != INVALID; ++it) {
+edges.push_back(it);
+}
+if (forceSort) {
+	labelWriter->sort(edges);
+}
+os << '\t';
+for (int i = 0; i < int(writers.size()); ++i) {
+	os << writers[i].first << '\t';
+}
+os << std::endl;
+for (typename std::vector<Edge>::iterator it = edges.begin();
+it != edges.end(); ++it) {
+	labelWriter->write(os, *it); os << '\t';
+	for (int i = 0; i < int(writers.size()); ++i) {
+	  writers[i].second->write(os, *it);
+	  os << '\t';
+	}
+	os << std::endl;
+}
+}
+private:
+typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<Edge>*> > MapWriters;
+MapWriters writers;
+_writer_bits::MapWriterBase<Edge>* labelMap;
+const Graph& graph;
+std::string name;
+bool forceSort;
+std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > labelWriter;
+};
+/// \ingroup section_io
+/// \brief SectionWriter for writing extra undirected edge maps.
+///
+/// The lemon format can store maps in the uedgeset. This class let
+/// you make distinict section to store maps. The main purpose of
+/// this class is a logical separation of some maps. The other
+/// useful application could be to store paths in undirected edge
+/// maps.
+///
+/// The first line of the section contains the names of the maps
+/// separated with white spaces. Each next line describes an item
+/// in the itemset, and contains in the first column the label of
+/// the item and then the mapped values for each map.
+///
+/// \relates LemonWriter
+template <typename _Graph, typename _Traits = DefaultWriterTraits>
+class UEdgeMapWriter : public LemonWriter::SectionWriter {
+typedef LemonWriter::SectionWriter Parent;
+public:
+typedef _Graph Graph;
+typedef _Traits Traits;
+typedef typename Graph::UEdge UEdge;
+typedef typename Graph::Edge Edge;
+/// \brief Constructor.
+///
+/// Constructor for UEdgeMapWriter. It creates the UEdgeMapWriter and
+/// attach it into the given LemonWriter. If the the
+/// \c _forceSort is true then the writer will write the uedges
+/// sorted by the labels.
+template <typename _LabelWriter>
+UEdgeMapWriter(LemonWriter& _writer, const Graph& _graph,
+		 const _LabelWriter& _labelWriter,
+		 const std::string& _name = std::string(),
+		 bool _forceSort = true)
+: Parent(_writer), graph(_graph), name(_name), forceSort(_forceSort) {
+checkConcept<_writer_bits::ItemLabelWriter<UEdge>, _LabelWriter>();
+labelWriter.reset(new _writer_bits::LabelWriter<UEdge,
+			    _LabelWriter>(_labelWriter));
+}
+/// \brief Destructor.
+///
+/// Destructor for UEdgeMapWriter.
+virtual ~UEdgeMapWriter() {
+typename MapWriters::iterator it;
+for (it = writers.begin(); it != writers.end(); ++it) {
+	delete it->second;
+}
+}
+private:
+UEdgeMapWriter(const UEdgeMapWriter&);
+void operator=(const UEdgeMapWriter&);
+public:
+/// \brief Add a new undirected edge map writer command for the writer.
+///
+/// Add a new undirected edge map writer command for the writer.
+template <typename Map>
+UEdgeMapWriter& writeUEdgeMap(std::string label, const Map& map) {
+return writeUEdgeMap<typename Traits::
+	template Writer<typename Map::Value>, Map>(label, map);
+}
+/// \brief Add a new undirected edge map writer command for the writer.
+///
+/// Add a new undirected edge map writer command for the writer.
+template <typename ItemWriter, typename Map>
+UEdgeMapWriter& writeUEdgeMap(std::string label, const Map& map,
+			   const ItemWriter& iw = ItemWriter()) {
+checkConcept<concepts::ReadMap<UEdge, typename Map::Value>, Map>();
+checkConcept<_writer_bits::ItemWriter<typename Map::Value>,ItemWriter>();
+writers.push_back(
+	make_pair(label, new _writer_bits::
+		  MapWriter<UEdge, Map, ItemWriter>(map, iw)));
+return *this;
+}
+/// \brief Add a new directed edge map writer command for the writer.
+///
+/// Add a new directed map writer command for the writer.
+template <typename Map>
+UEdgeMapWriter& writeEdgeMap(std::string label, const Map& map) {
+return writeEdgeMap<typename Traits::
+	template Writer<typename Map::Value>, Map>(label, map);
+}
+/// \brief Add a new directed map writer command for the writer.
+///
+/// Add a new directed map writer command for the writer.
+template <typename ItemWriter, typename Map>
+UEdgeMapWriter& writeEdgeMap(std::string label, const Map& map,
+const ItemWriter& iw = ItemWriter()) {
+checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
+checkConcept<_writer_bits::ItemWriter<typename Map::Value>, ItemWriter>();
+writeUEdgeMap("+" + label,
+_writer_bits::forwardComposeMap(graph, map), iw);
+writeUEdgeMap("-" + label,
+_writer_bits::backwardComposeMap(graph, map), iw);
+return *this;
+}
+protected:
+/// \brief The header of the section.
+///
+/// It gives back the header of the section.
+virtual std::string header() {
+return "@uedgemaps " + name;
+}
+/// \brief  Writer function of the section.
+///
+/// Write the content of the section.
+virtual void write(std::ostream& os) {
+std::vector<UEdge> uedges;
+for (typename Graph::UEdgeIt it(graph); it != INVALID; ++it) {
+uedges.push_back(it);
+}
+if (forceSort) {
+	labelWriter->sort(uedges);
+}
+os << '\t';
+for (int i = 0; i < int(writers.size()); ++i) {
+	os << writers[i].first << '\t';
+}
+os << std::endl;
+for (typename std::vector<UEdge>::iterator it = uedges.begin();
+it != uedges.end(); ++it) {
+	labelWriter->write(os, *it); os << '\t';
+	for (int i = 0; i < int(writers.size()); ++i) {
+	  writers[i].second->write(os, *it);
+	  os << '\t';
+	}
+	os << std::endl;
+}
+}
+private:
+typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<UEdge>*> > MapWriters;
+MapWriters writers;
+_writer_bits::MapWriterBase<UEdge>* labelMap;
+const Graph& graph;
+std::string name;
+bool forceSort;
+std::auto_ptr<_writer_bits::LabelWriterBase<UEdge> > labelWriter;
+};
+/// \ingroup section_io
 /// \brief SectionWriter for attributes.
 ///
 /// The lemon format can store multiple attribute set. Each set has
 /// the header line \c \@attributes \c attributes_name, but the
 /// attributeset_name may be empty.

changeset 2481	ddb851e1481a
parent 2414	9e80927b7921
child 2502	9c23c3762bc5