lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:f56ab4dfc450
+:02103afb1393
 struct Ref { typedef const Map& Type; };
 template <typename Graph, typename Map>
 class ForwardComposeMap {
 public:
-typedef typename Graph::UndirEdge Key;
+typedef typename Graph::UEdge Key;
 typedef typename Map::Value Value;
 ForwardComposeMap(const Graph& _graph, const Map& _map)
 	: graph(_graph), map(_map) {}
 }
 template <typename Graph, typename Map>
 class BackwardComposeMap {
 public:
-typedef typename Graph::UndirEdge Key;
+typedef typename Graph::UEdge Key;
 typedef typename Map::Value Value;
 BackwardComposeMap(const Graph& _graph, const Map& _map)
 	: graph(_graph), map(_map) {}
 /// \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
+/// maps. The undirected edgeset section's header line is \c \@uedgeset
-/// \c undiredgeset_name, but the \c undiredgeset_name may be empty.
+/// \c uedgeset_name, but the \c uedgeset_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' label and the mapped
 /// values for each undirected map.
 /// which nodes 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 UndirEdgeSetWriter : public LemonWriter::SectionWriter {
+class UEdgeSetWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 public:
 typedef _Graph Graph;
 typedef _Traits Traits;
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
-typedef typename Graph::UndirEdge UndirEdge;
+typedef typename Graph::UEdge UEdge;
 /// \brief Constructor.
 ///
-/// Constructor for UndirEdgeSetWriter. It creates the UndirEdgeSetWriter
+/// 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.
 template <typename NodeLabelWriter>
-UndirEdgeSetWriter(LemonWriter& _writer, const Graph& _graph,
+UEdgeSetWriter(LemonWriter& _writer, const Graph& _graph,
 		       const NodeLabelWriter& _nodeLabelWriter,
 		       const std::string& _name = std::string(),
 		       bool _forceLabelMap = true)
 : Parent(_writer), labelMap(0), forceLabelMap(_forceLabelMap),
 	graph(_graph), name(_name) {
 			 LabelWriter<Node, NodeLabelWriter>(_nodeLabelWriter));
 }
 /// \brief Destructor.
 ///
-/// Destructor for UndirEdgeSetWriter.
+/// Destructor for UEdgeSetWriter.
-virtual ~UndirEdgeSetWriter() {
+virtual ~UEdgeSetWriter() {
 typename MapWriters::iterator it;
 for (it = writers.begin(); it != writers.end(); ++it) {
 	delete it->second;
 }
 }
 private:
-UndirEdgeSetWriter(const UndirEdgeSetWriter&);
+UEdgeSetWriter(const UEdgeSetWriter&);
-void operator=(const UndirEdgeSetWriter&);
+void operator=(const UEdgeSetWriter&);
 public:
 /// \brief Add a new undirected edge map writer command for the writer.
 ///
 /// Add a new undirected map writer command for the writer.
 template <typename Map>
-UndirEdgeSetWriter& writeUndirEdgeMap(std::string name, const Map& map) {
+UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map) {
-return writeUndirEdgeMap<typename Traits::
+return writeUEdgeMap<typename Traits::
 	template Writer<typename Map::Value>, Map>(name, map);
 }
 /// \brief Add a new undirected map writer command for the writer.
 ///
 /// Add a new undirected map writer command for the writer.
 template <typename Writer, typename Map>
-UndirEdgeSetWriter& writeUndirEdgeMap(std::string name, const Map& map,
+UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map,
 					  const Writer& writer = Writer()) {
-checkConcept<concept::ReadMap<UndirEdge, typename Map::Value>, Map>();
+checkConcept<concept::ReadMap<UEdge, typename Map::Value>, Map>();
 checkConcept<_writer_bits::ItemWriter<typename Map::Value>, Writer>();
 writers.push_back(
 	make_pair(name, new _writer_bits::
-		  MapWriter<UndirEdge, Map, Writer>(map, writer)));
+		  MapWriter<UEdge, Map, Writer>(map, writer)));
 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>
-UndirEdgeSetWriter& writeEdgeMap(std::string name, const Map& map) {
+UEdgeSetWriter& writeEdgeMap(std::string name, const Map& map) {
 return writeEdgeMap<typename Traits::
 	template Writer<typename Map::Value>, Map>(name, map);
 }
 /// \brief Add a new directed map writer command for the writer.
 ///
 /// Add a new directed map writer command for the writer.
 template <typename Writer, typename Map>
-UndirEdgeSetWriter& writeEdgeMap(std::string name, const Map& map,
+UEdgeSetWriter& 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>();
-writeUndirEdge("+" + name,
+writeUEdge("+" + name,
 		     _writer_bits::forwardComposeMap(graph, map), writer);
-writeUndirEdge("-" + name,
+writeUEdge("-" + name,
 		     _writer_bits::backwardComposeMap(graph, map), writer);
 return *this;
 }
 protected:
 /// \brief The header of the section.
 ///
 /// It gives back the header of the section.
 virtual std::string header() {
-return "@undiredgeset " + name;
+return "@uedgeset " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 }
 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) {
+for (typename Graph::UEdgeIt it(graph); it != INVALID; ++it) {
 	nodeLabelWriter->write(os, graph.source(it));
 	os << '\t';
 	nodeLabelWriter->write(os, graph.target(it));
 	os << '\t';
 	if (forceLabelMap) {
 ///
 /// 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
 /// undirected edge. Otherwise if the \c forceLabel parameter was true it
 /// will write its id in the graph.
-void writeLabel(std::ostream& os, const UndirEdge& item) const {
+void writeLabel(std::ostream& os, const UEdge& item) const {
 if (forceLabelMap) {
 	os << graph.id(item);
 } else {
 	labelMap->write(os, item);
 }
 }
 private:
 typedef std::vector<std::pair<std::string, _writer_bits::
-				  MapWriterBase<UndirEdge>*> > MapWriters;
+				  MapWriterBase<UEdge>*> > MapWriters;
 MapWriters writers;
-_writer_bits::MapWriterBase<UndirEdge>* labelMap;
+_writer_bits::MapWriterBase<UEdge>* labelMap;
 bool forceLabelMap;
 const Graph& graph;
 std::string name;
 };
 /// \ingroup io_group
 /// \brief SectionWriter for writing named undirected edges.
 ///
-/// The undirected edges section's header line is \c \@undiredges
+/// The undirected edges section's header line is \c \@uedges
-/// \c undiredges_name, but the \c undiredges_name may be empty.
+/// \c uedges_name, but the \c uedges_name may be empty.
 ///
 /// Each line in the section contains the name of the undirected edge and
 /// then the undirected edge label.
 ///
 /// \relates LemonWriter
 template <typename _Graph>
-class UndirEdgeWriter : public LemonWriter::SectionWriter {
+class UEdgeWriter : public LemonWriter::SectionWriter {
 typedef LemonWriter::SectionWriter Parent;
 typedef _Graph Graph;
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
-typedef typename Graph::UndirEdge UndirEdge;
+typedef typename Graph::UEdge UEdge;
 public:
 /// \brief Constructor.
 ///
-/// Constructor for UndirEdgeWriter. It creates the UndirEdgeWriter and
+/// Constructor for UEdgeWriter. It creates the UEdgeWriter and
 /// attach it into the given LemonWriter. The given \c _LabelWriter
 /// will write the undirected edges' label what can be an undirected
 /// edgeset writer.
 template <typename _LabelWriter>
-UndirEdgeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter,
+UEdgeWriter(LemonWriter& _writer, const _LabelWriter& _labelWriter,
 	       const std::string& _name = std::string())
 : Parent(_writer), name(_name) {
 checkConcept<_writer_bits::ItemLabelWriter<Edge>, _LabelWriter>();
-checkConcept<_writer_bits::ItemLabelWriter<UndirEdge>, _LabelWriter>();
+checkConcept<_writer_bits::ItemLabelWriter<UEdge>, _LabelWriter>();
-undirEdgeLabelWriter.reset(new _writer_bits::
+uEdgeLabelWriter.reset(new _writer_bits::
-			      LabelWriter<UndirEdge, _LabelWriter>(_labelWriter));
+			      LabelWriter<UEdge, _LabelWriter>(_labelWriter));
 edgeLabelWriter.reset(new _writer_bits::
 			 LabelWriter<Edge, _LabelWriter>(_labelWriter));
 }
 /// \brief Destructor.
 ///
-/// Destructor for UndirEdgeWriter.
+/// Destructor for UEdgeWriter.
-virtual ~UndirEdgeWriter() {}
+virtual ~UEdgeWriter() {}
 private:
-UndirEdgeWriter(const UndirEdgeWriter&);
+UEdgeWriter(const UEdgeWriter&);
-void operator=(const UndirEdgeWriter&);
+void operator=(const UEdgeWriter&);
 public:
-/// \brief Add an edge writer command for the UndirEdgeWriter.
+/// \brief Add an edge writer command for the UEdgeWriter.
 ///
-/// Add an edge writer command for the UndirEdgeWriter.
+/// Add an edge writer command for the UEdgeWriter.
 void writeEdge(const std::string& name, const Edge& item) {
 edgeWriters.push_back(make_pair(name, &item));
 }
-/// \brief Add an undirected edge writer command for the UndirEdgeWriter.
+/// \brief Add an undirected edge writer command for the UEdgeWriter.
 ///
-/// Add an undirected edge writer command for the UndirEdgeWriter.
+/// Add an undirected edge writer command for the UEdgeWriter.
-void writeUndirEdge(const std::string& name, const UndirEdge& item) {
+void writeUEdge(const std::string& name, const UEdge& item) {
-undirEdgeWriters.push_back(make_pair(name, &item));
+uEdgeWriters.push_back(make_pair(name, &item));
 }
 protected:
 /// \brief The header of the section.
 ///
 /// It gives back the header of the section.
 virtual std::string header() {
-return "@undiredges " + name;
+return "@uedges " + name;
 }
 /// \brief  Writer function of the section.
 ///
 /// Write the content of the section.
 virtual void write(std::ostream& os) {
 if (!edgeLabelWriter->isLabelWriter()) {
 	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
-if (!undirEdgeLabelWriter->isLabelWriter()) {
+if (!uEdgeLabelWriter->isLabelWriter()) {
 	throw DataFormatError("Cannot find undirected edgeset or label map");
 }
-for (int i = 0; i < (int)undirEdgeWriters.size(); ++i) {
+for (int i = 0; i < (int)uEdgeWriters.size(); ++i) {
-	os << undirEdgeWriters[i].first << ' ';
+	os << uEdgeWriters[i].first << ' ';
-	undirEdgeLabelWriter->write(os, *(undirEdgeWriters[i].second));
+	uEdgeLabelWriter->write(os, *(uEdgeWriters[i].second));
 	os << std::endl;
 }
 for (int i = 0; i < (int)edgeWriters.size(); ++i) {
 	os << edgeWriters[i].first << ' ';
 	edgeLabelWriter->write(os, *(edgeWriters[i].second));
 private:
 std::string name;
 typedef std::vector<std::pair<std::string,
-				  const UndirEdge*> > UndirEdgeWriters;
+				  const UEdge*> > UEdgeWriters;
-UndirEdgeWriters undirEdgeWriters;
+UEdgeWriters uEdgeWriters;
-std::auto_ptr<_writer_bits::LabelWriterBase<UndirEdge> > undirEdgeLabelWriter;
+std::auto_ptr<_writer_bits::LabelWriterBase<UEdge> > uEdgeLabelWriter;
 typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;
 EdgeWriters edgeWriters;
 std::auto_ptr<_writer_bits::LabelWriterBase<Edge> > edgeLabelWriter;

changeset 1923	e1b0ef823e9e
parent 1901	723b2b81d900
child 1956	a055123339d5