lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:808c7adc60aa
+:bd5b02f9e3b1
 template <typename Map>
 struct Ref<ConstYMap<Map> > {
 typedef ConstYMap<Map> Type;
 };
+template <typename _Item>
+class MapWriterBase {
+public:
+typedef _Item Item;
+virtual ~MapWriterBase() {}
+virtual void write(std::ostream& os, const Item& item) = 0;
+};
+template <typename _Item, typename _Map, typename _Writer>
+class MapWriter : public MapWriterBase<_Item> {
+public:
+typedef _Map Map;
+typedef _Writer Writer;
+typedef typename Writer::Value Value;
+typedef _Item Item;
+typename _writer_bits::Ref<Map>::Type map;
+Writer writer;
+MapWriter(const Map& _map, const Writer& _writer)
+	: map(_map), writer(_writer) {}
+virtual ~MapWriter() {}
+virtual void write(std::ostream& os, const Item& item) {
+	Value value = map[item];
+	writer.write(os, value);
+}
+};
+class ValueWriterBase {
+public:
+virtual ~ValueWriterBase() {}
+virtual void write(std::ostream&) = 0;
+};
+template <typename _Value, typename _Writer>
+class ValueWriter : public ValueWriterBase {
+public:
+typedef _Value Value;
+typedef _Writer Writer;
+ValueWriter(const Value& _value, const Writer& _writer)
+	: value(_value), writer(_writer) {}
+virtual void write(std::ostream& os) {
+	writer.write(os, value);
+}
+private:
+const Value& value;
+Writer writer;
+};
+template <typename _Item>
+class IdWriterBase {
+public:
+typedef _Item Item;
+virtual ~IdWriterBase() {}
+virtual void write(std::ostream&, const Item&) const = 0;
+virtual bool isIdWriter() const = 0;
+};
+template <typename _Item, typename _BoxedIdWriter>
+class IdWriter : public IdWriterBase<_Item> {
+public:
+typedef _Item Item;
+typedef _BoxedIdWriter BoxedIdWriter;
+const BoxedIdWriter& idWriter;
+IdWriter(const BoxedIdWriter& _idWriter)
+	: idWriter(_idWriter) {}
+virtual void write(std::ostream& os, const Item& item) const {
+	idWriter.writeId(os, item);
+}
+virtual bool isIdWriter() const {
+	return idWriter.isIdWriter();
+}
+};
 }
 /// \ingroup io_group
 /// \brief Lemon Format writer class.
 ///
 typedef std::vector<SectionWriter*> SectionWriters;
 SectionWriters writers;
 };
-/// \brief Helper class for implementing the common SectionWriters.
-///
-/// Helper class for implementing the common SectionWriters.
-class CommonSectionWriterBase : public LemonWriter::SectionWriter {
-typedef LemonWriter::SectionWriter Parent;
-protected:
-/// \brief Constructor for CommonSectionWriterBase.
-///
-/// Constructor for CommonSectionWriterBase. It attach this writer to
-/// the given LemonWriter.
-CommonSectionWriterBase(LemonWriter& _writer)
-: Parent(_writer) {}
-template <typename _Item>
-class WriterBase {
-public:
-typedef _Item Item;
-virtual ~WriterBase() {}
-virtual void write(std::ostream& os, const Item& item) = 0;
-};
-template <typename _Item, typename _Map, typename _Writer>
-class MapWriter : public WriterBase<_Item> {
-public:
-typedef _Map Map;
-typedef _Writer Writer;
-typedef typename Writer::Value Value;
-typedef _Item Item;
-typename _writer_bits::Ref<Map>::Type map;
-Writer writer;
-MapWriter(const Map& _map, const Writer& _writer)
-	: map(_map), writer(_writer) {}
-virtual ~MapWriter() {}
-virtual void write(std::ostream& os, const Item& item) {
-	Value value = map[item];
-	writer.write(os, value);
-}
-};
-class ValueWriterBase {
-public:
-virtual ~ValueWriterBase() {}
-virtual void write(std::ostream&) = 0;
-};
-template <typename _Value, typename _Writer>
-class ValueWriter : public ValueWriterBase {
-public:
-typedef _Value Value;
-typedef _Writer Writer;
-ValueWriter(const Value& _value, const Writer& _writer)
-	: value(_value), writer(_writer) {}
-virtual void write(std::ostream& os) {
-	writer.write(os, value);
-}
-private:
-const Value& value;
-Writer writer;
-};
-template <typename _Item>
-class IdWriterBase {
-public:
-typedef _Item Item;
-virtual ~IdWriterBase() {}
-virtual void write(std::ostream&, const Item&) const = 0;
-virtual bool isIdWriter() const = 0;
-};
-template <typename _Item, typename _BoxedIdWriter>
-class IdWriter : public IdWriterBase<_Item> {
-public:
-typedef _Item Item;
-typedef _BoxedIdWriter BoxedIdWriter;
-const BoxedIdWriter& idWriter;
-IdWriter(const BoxedIdWriter& _idWriter)
-	: idWriter(_idWriter) {}
-virtual void write(std::ostream& os, const Item& item) const {
-	idWriter.writeId(os, item);
-}
-virtual bool isIdWriter() const {
-	return idWriter.isIdWriter();
-}
-};
-};
 /// \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
 /// Otherwise if the \c _forceIdMap constructor parameter is true then
 /// the id map will be the id in the graph.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
-class NodeSetWriter : public CommonSectionWriterBase {
+class NodeSetWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 NodeSetWriter& writeNodeMap(std::string name, const Map& map,
 			    const Writer& writer = Writer()) {
 checkConcept<concept::ReadMap<Node, typename Map::Value>, Map>();
 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
 writers.push_back(
-	make_pair(name, new MapWriter<Node, Map, Writer>(map, writer)));
+	make_pair(name, new _writer_bits::
+		  MapWriter<Node, Map, Writer>(map, writer)));
 return *this;
 }
 protected:
 }
 }
 private:
-typedef std::vector<std::pair<std::string, WriterBase<Node>*> > MapWriters;
+typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<Node>*> > MapWriters;
 MapWriters writers;
-WriterBase<Node>* idMap;
+_writer_bits::MapWriterBase<Node>* idMap;
 bool forceIdMap;
 const Graph& graph;
 std::string id;
 /// have to be connected. If a NodeSetWriter can write the nodes' id,
 /// it will be able to use with this class.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
-class EdgeSetWriter : public CommonSectionWriterBase {
+class EdgeSetWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 		  const std::string& _id = std::string(),
 		  bool _forceIdMap = true)
 : Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
 	graph(_graph), id(_id) {
 checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
-nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
+nodeIdWriter.reset(new _writer_bits::
+			 IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for EdgeSetWriter.
 EdgeSetWriter& writeEdgeMap(std::string name, const Map& map,
 			    const Writer& writer = Writer()) {
 checkConcept<concept::ReadMap<Edge, typename Map::Value>, Map>();
 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
 writers.push_back(
-	make_pair(name, new MapWriter<Edge, Map, Writer>(map, writer)));
+	make_pair(name, new _writer_bits::
+		  MapWriter<Edge, Map, Writer>(map, writer)));
 return *this;
 }
 protected:
 }
 }
 private:
-typedef std::vector<std::pair<std::string, WriterBase<Edge>*> > MapWriters;
+typedef std::vector<std::pair<std::string, _writer_bits::
+				  MapWriterBase<Edge>*> > MapWriters;
 MapWriters writers;
-WriterBase<Edge>* idMap;
+_writer_bits::MapWriterBase<Edge>* idMap;
 bool forceIdMap;
 const Graph& graph;
 std::string id;
-std::auto_ptr<IdWriterBase<Node> > nodeIdWriter;
+std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing a undirected edgeset.
 ///
 /// which nodes have to be connected. If a NodeSetWriter can write the
 /// nodes' id, it will be able to use with this class.
 ///
 /// \relates LemonWriter
 template <typename _Graph, typename _Traits = DefaultWriterTraits>
-class UndirEdgeSetWriter : public CommonSectionWriterBase {
+class UndirEdgeSetWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 		       const std::string& _id = std::string(),
 		       bool _forceIdMap = true)
 : Parent(_writer), idMap(0), forceIdMap(_forceIdMap),
 	graph(_graph), id(_id) {
 checkConcept<_writer_bits::ItemIdWriter<Node>, NodeIdWriter>();
-nodeIdWriter.reset(new IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
+nodeIdWriter.reset(new _writer_bits::
+			 IdWriter<Node, NodeIdWriter>(_nodeIdWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeSetWriter.
 UndirEdgeSetWriter& writeUndirEdgeMap(std::string name, const Map& map,
 					  const Writer& writer = Writer()) {
 checkConcept<concept::ReadMap<UndirEdge, typename Map::Value>, Map>();
 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
 writers.push_back(
-	make_pair(name, new MapWriter<UndirEdge, Map, Writer>(map, writer)));
+	make_pair(name, new _writer_bits::
+		  MapWriter<UndirEdge, Map, Writer>(map, writer)));
 return *this;
 }
 /// \brief Add a new directed edge map writer command for the writer.
 ///
 }
 }
 private:
-typedef std::vector<std::pair<std::string,
+typedef std::vector<std::pair<std::string, _writer_bits::
-				  WriterBase<UndirEdge>*> > MapWriters;
+				  MapWriterBase<UndirEdge>*> > MapWriters;
 MapWriters writers;
-WriterBase<UndirEdge>* idMap;
+_writer_bits::MapWriterBase<UndirEdge>* idMap;
 bool forceIdMap;
 const Graph& graph;
 std::string id;
-std::auto_ptr<IdWriterBase<Node> > nodeIdWriter;
+std::auto_ptr<_writer_bits::IdWriterBase<Node> > nodeIdWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing labeled nodes.
 ///
 /// Each line in the section contains the label of the node and
 /// then the node id.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
-class NodeWriter : public CommonSectionWriterBase {
+class NodeWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 typedef _Graph Graph;
 typedef typename Graph::Node Node;
 public:
 /// \brief Constructor.
 template <typename _IdWriter>
 NodeWriter(LemonWriter& _writer, const _IdWriter& _idWriter,
 	       const std::string& _id = std::string())
 : Parent(_writer), id(_id) {
 checkConcept<_writer_bits::ItemIdWriter<Node>, _IdWriter>();
-idWriter.reset(new IdWriter<Node, _IdWriter>(_idWriter));
+idWriter.reset(new _writer_bits::IdWriter<Node, _IdWriter>(_idWriter));
 }
 /// \brief Destructor.
 ///
 std::string id;
 typedef std::vector<std::pair<std::string, const Node*> > NodeWriters;
 NodeWriters writers;
-std::auto_ptr<IdWriterBase<Node> > idWriter;
+std::auto_ptr<_writer_bits::IdWriterBase<Node> > idWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing labeled edges.
 ///
 /// Each line in the section contains the label of the edge and
 /// then the edge id.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
-class EdgeWriter : public CommonSectionWriterBase {
+class EdgeWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 typedef _Graph Graph;
 typedef typename Graph::Edge Edge;
 public:
 /// \brief Constructor.
 template <typename _IdWriter>
 EdgeWriter(LemonWriter& _writer, const _IdWriter& _idWriter,
 	       const std::string& _id = std::string())
 : Parent(_writer), id(_id) {
 checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
-idWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));
+idWriter.reset(new _writer_bits::IdWriter<Edge, _IdWriter>(_idWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for EdgeWriter.
 std::string id;
 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
 EdgeWriters writers;
-std::auto_ptr<IdWriterBase<Edge> > idWriter;
+std::auto_ptr<_writer_bits::IdWriterBase<Edge> > idWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing labeled undirected edges.
 ///
 /// Each line in the section contains the label of the undirected edge and
 /// then the undirected edge id.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
-class UndirEdgeWriter : public CommonSectionWriterBase {
+class UndirEdgeWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 typedef _Graph Graph;
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
 typedef typename Graph::UndirEdge UndirEdge;
 public:
 UndirEdgeWriter(LemonWriter& _writer, const _IdWriter& _idWriter,
 	       const std::string& _id = std::string())
 : Parent(_writer), id(_id) {
 checkConcept<_writer_bits::ItemIdWriter<Edge>, _IdWriter>();
 checkConcept<_writer_bits::ItemIdWriter<UndirEdge>, _IdWriter>();
-undirEdgeIdWriter.reset(new IdWriter<UndirEdge, _IdWriter>(_idWriter));
+undirEdgeIdWriter.reset(new _writer_bits::
-edgeIdWriter.reset(new IdWriter<Edge, _IdWriter>(_idWriter));
+			      IdWriter<UndirEdge, _IdWriter>(_idWriter));
+edgeIdWriter.reset(new _writer_bits::
+			 IdWriter<Edge, _IdWriter>(_idWriter));
 }
 /// \brief Destructor.
 ///
 /// Destructor for UndirEdgeWriter.
 std::string id;
 typedef std::vector<std::pair<std::string,
 				  const UndirEdge*> > UndirEdgeWriters;
 UndirEdgeWriters undirEdgeWriters;
-std::auto_ptr<IdWriterBase<UndirEdge> > undirEdgeIdWriter;
+std::auto_ptr<_writer_bits::IdWriterBase<UndirEdge> > undirEdgeIdWriter;
 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
 EdgeWriters edgeWriters;
-std::auto_ptr<IdWriterBase<Edge> > edgeIdWriter;
+std::auto_ptr<_writer_bits::IdWriterBase<Edge> > edgeIdWriter;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for attributes.
 /// The attributeset section contains several lines. Each of them starts
 /// with the name of attribute and then the value.
 ///
 /// \relates LemonWriter
 template <typename _Traits = DefaultWriterTraits>
-class AttributeWriter : public CommonSectionWriterBase {
+class AttributeWriter : public LemonWriter::SectionWriter {
-typedef CommonSectionWriterBase Parent;
+typedef LemonWriter::SectionWriter Parent;
 typedef _Traits Traits;
 public:
 /// \brief Constructor.
 ///
 /// Constructor for AttributeWriter. It creates the AttributeWriter and
 template <typename Writer, typename Value>
 AttributeWriter& writeAttribute(const std::string& name,
 				    const Value& value,
 				    const Writer& writer = Writer()) {
 checkConcept<_writer_bits::ItemWriter<Value>, Writer>();
-writers.push_back(make_pair(name, new ValueWriter<Value, Writer>
+writers.push_back(make_pair(name, new _writer_bits::
-			       (value, writer)));
+				  ValueWriter<Value, Writer>(value, writer)));
 return *this;
 }
 protected:
 }
 private:
 std::string id;
-typedef std::vector<std::pair<std::string, ValueWriterBase*> > Writers;
+typedef std::vector<std::pair<std::string,
+				  _writer_bits::ValueWriterBase*> > Writers;
 Writers writers;
 };
 }

changeset 1845	f8bbfed86036
parent 1705	3f63d9db307b
child 1852	ffa7c6e96330