lemon-0.x: comparison lemon/graph

equal deleted inserted replaced

-:c2dc12d5f62b
+:9bd64ab18422
 return GraphReader<Graph>(fn, g);
 }
 /// \brief The undirected graph reader class.
 ///
-/// The \c UndirGraphReader class provides the graph input.
+/// The \c UGraphReader class provides the graph input.
 /// Before you read this documentation it might be useful to read the general
 /// description of  \ref graph-io-page "Graph Input-Output".
 ///
 /// If you don't need very sophisticated
 /// behaviour then you can use the versions of the public function
 ///
 /// The given file format may contain several maps and labeled nodes or
 /// edges.
 ///
 /// If you read a graph you need not read all the maps and items just those
-/// that you need. The interface of the \c UndirGraphReader is very similar
+/// that you need. The interface of the \c UGraphReader is very similar
-/// to the UndirGraphWriter but the reading method does not depend on the
+/// to the UGraphWriter but the reading method does not depend on the
 /// order of the given commands.
 ///
 /// The reader object suppose that each not readed value does not contain
 /// whitespaces, therefore it has some extra possibilities to control how
 /// it should skip the values when the string representation contains spaces.
 ///
 /// \code
-/// UndirGraphReader<UndirListGraph> reader(std::cin, graph);
+/// UGraphReader<ListUGraph> reader(std::cin, graph);
 /// \endcode
 ///
 /// The \c readNodeMap() function reads a map from the \c \@nodeset section.
 /// If there is a map that you do not want to read from the file and there is
 /// whitespace in the string represenation of the values then you should
 /// reader.skipNodeMap("description", desc);
 ///
 /// reader.readNodeMap("color", colorMap);
 /// \endcode
 ///
-/// With the \c readUndirEdgeMap() member function you can give an
+/// With the \c readUEdgeMap() member function you can give an
-/// undir edge map reading command similar to the NodeMaps.
+/// uedge map reading command similar to the NodeMaps.
 ///
 /// \code
-/// reader.readUndirEdgeMap("capacity", capacityMap);
+/// reader.readUEdgeMap("capacity", capacityMap);
 /// \endcode
 ///
 /// The reading of the directed edge maps is just a syntactical sugar.
 /// It reads two undirected edgemaps into a directed edge map. The
 /// undirected edge maps' name should be start with the \c '+' and the
 ///
 /// \code
 /// reader.readEdgeMap("flow", flowMap);
 /// \endcode
 ///
-/// With \c readNode() and \c readUndirEdge() functions you can read
+/// With \c readNode() and \c readUEdge() functions you can read
-/// labeled Nodes and UndirEdges.
+/// labeled Nodes and UEdges.
 ///
 /// \code
 /// reader.readNode("source", sourceNode);
 /// reader.readNode("target", targetNode);
 ///
-/// reader.readUndirEdge("observed", undirEdge);
+/// reader.readUEdge("observed", uEdge);
 /// \endcode
 ///
 /// With the \c readAttribute() functions you can read an attribute
 /// in a variable. You can specify the reader for the attribute as
 /// the nodemaps.
 /// reader.run();
 /// \endcode
 ///
 /// \see GraphReader
 /// \see DefaultReaderTraits
-/// \see \ref UndirGraphWriter
+/// \see \ref UGraphWriter
 /// \see \ref graph-io-page
 ///
 /// \author Balazs Dezso
 template <typename _Graph, typename _ReaderTraits = DefaultReaderTraits>
-class UndirGraphReader {
+class UGraphReader {
 public:
 typedef _Graph Graph;
 typedef typename Graph::Node Node;
 typedef typename Graph::Edge Edge;
-typedef typename Graph::UndirEdge UndirEdge;
+typedef typename Graph::UEdge UEdge;
 typedef _ReaderTraits ReaderTraits;
 typedef typename ReaderTraits::Skipper DefaultSkipper;
-/// \brief Construct a new UndirGraphReader.
+/// \brief Construct a new UGraphReader.
 ///
-/// Construct a new UndirGraphReader. It reads into the given graph
+/// Construct a new UGraphReader. It reads into the given graph
 /// and it use the given reader as the default skipper.
-UndirGraphReader(std::istream& _is, Graph& _graph,
+UGraphReader(std::istream& _is, Graph& _graph,
 		     const DefaultSkipper& _skipper = DefaultSkipper())
 : reader(new LemonReader(_is)), own_reader(true), skipper(_skipper),
 	nodeset_reader(*reader, _graph, std::string(), skipper),
-	undir_edgeset_reader(*reader, _graph, nodeset_reader,
+	u_edgeset_reader(*reader, _graph, nodeset_reader,
 			     std::string(), skipper),
 	node_reader(*reader, nodeset_reader, std::string()),
-	undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+	u_edge_reader(*reader, u_edgeset_reader, std::string()),
 	attribute_reader(*reader, std::string()) {}
-/// \brief Construct a new UndirGraphReader.
+/// \brief Construct a new UGraphReader.
 ///
-/// Construct a new UndirGraphReader. It reads into the given graph
+/// Construct a new UGraphReader. It reads into the given graph
 /// and it use the given reader as the default skipper.
-UndirGraphReader(const std::string& _filename, Graph& _graph,
+UGraphReader(const std::string& _filename, Graph& _graph,
 		     const DefaultSkipper& _skipper = DefaultSkipper())
 : reader(new LemonReader(_filename)), own_reader(true),
 	skipper(_skipper),
 	nodeset_reader(*reader, _graph, std::string(), skipper),
-	undir_edgeset_reader(*reader, _graph, nodeset_reader,
+	u_edgeset_reader(*reader, _graph, nodeset_reader,
 			     std::string(), skipper),
 	node_reader(*reader, nodeset_reader, std::string()),
-	undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+	u_edge_reader(*reader, u_edgeset_reader, std::string()),
 	attribute_reader(*reader, std::string()) {}
-/// \brief Construct a new UndirGraphReader.
+/// \brief Construct a new UGraphReader.
 ///
-/// Construct a new UndirGraphReader. It reads into the given graph
+/// Construct a new UGraphReader. It reads into the given graph
 /// and it use the given reader as the default skipper.
-UndirGraphReader(LemonReader& _reader, Graph& _graph,
+UGraphReader(LemonReader& _reader, Graph& _graph,
 		     const DefaultSkipper& _skipper = DefaultSkipper())
 : reader(_reader), own_reader(false), skipper(_skipper),
 	nodeset_reader(*reader, _graph, std::string(), skipper),
-	undir_edgeset_reader(*reader, _graph, nodeset_reader,
+	u_edgeset_reader(*reader, _graph, nodeset_reader,
 			     std::string(), skipper),
 	node_reader(*reader, nodeset_reader, std::string()),
-	undir_edge_reader(*reader, undir_edgeset_reader, std::string()),
+	u_edge_reader(*reader, u_edgeset_reader, std::string()),
 	attribute_reader(*reader, std::string()) {}
 /// \brief Destruct the graph reader.
 ///
 /// Destruct the graph reader.
-~UndirGraphReader() {
+~UGraphReader() {
 if (own_reader)
 	delete reader;
 }
 /// \brief Give a new node map reading command to the reader.
 ///
 /// Give a new node map reading command to the reader.
 template <typename Map>
-UndirGraphReader& readNodeMap(std::string name, Map& map) {
+UGraphReader& readNodeMap(std::string name, Map& map) {
 nodeset_reader.readNodeMap(name, map);
 return *this;
 }
 template <typename Map>
-UndirGraphReader& readNodeMap(std::string name, const Map& map) {
+UGraphReader& readNodeMap(std::string name, const Map& map) {
 nodeset_reader.readNodeMap(name, map);
 return *this;
 }
 /// \brief Give a new node map reading command to the reader.
 ///
 /// Give a new node map reading command to the reader.
 template <typename Reader, typename Map>
-UndirGraphReader& readNodeMap(std::string name, Map& map,
+UGraphReader& readNodeMap(std::string name, Map& map,
 				  const Reader& reader = Reader()) {
 nodeset_reader.readNodeMap(name, map, reader);
 return *this;
 }
 template <typename Reader, typename Map>
-UndirGraphReader& readNodeMap(std::string name, const Map& map,
+UGraphReader& readNodeMap(std::string name, const Map& map,
 				  const Reader& reader = Reader()) {
 nodeset_reader.readNodeMap(name, map, reader);
 return *this;
 }
 /// \brief Give a new node map skipping command to the reader.
 ///
 /// Give a new node map skipping command to the reader.
 template <typename Reader>
-UndirGraphReader& skipNodeMap(std::string name,
+UGraphReader& skipNodeMap(std::string name,
 			     const Reader& reader = Reader()) {
 nodeset_reader.skipNodeMap(name, reader);
 return *this;
 }
 /// \brief Give a new undirected edge map reading command to the reader.
 ///
 /// Give a new undirected edge map reading command to the reader.
 template <typename Map>
-UndirGraphReader& readUndirEdgeMap(std::string name, Map& map) {
+UGraphReader& readUEdgeMap(std::string name, Map& map) {
-undir_edgeset_reader.readUndirEdgeMap(name, map);
+u_edgeset_reader.readUEdgeMap(name, map);
 return *this;
 }
 template <typename Map>
-UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map) {
+UGraphReader& readUEdgeMap(std::string name, const Map& map) {
-undir_edgeset_reader.readUndirEdgeMap(name, map);
+u_edgeset_reader.readUEdgeMap(name, map);
 return *this;
 }
 /// \brief Give a new undirected edge map reading command to the reader.
 ///
 /// Give a new undirected edge map reading command to the reader.
 template <typename Reader, typename Map>
-UndirGraphReader& readUndirEdgeMap(std::string name, Map& map,
+UGraphReader& readUEdgeMap(std::string name, Map& map,
 				       const Reader& reader = Reader()) {
-undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
+u_edgeset_reader.readUEdgeMap(name, map, reader);
 return *this;
 }
 template <typename Reader, typename Map>
-UndirGraphReader& readUndirEdgeMap(std::string name, const Map& map,
+UGraphReader& readUEdgeMap(std::string name, const Map& map,
 				       const Reader& reader = Reader()) {
-undir_edgeset_reader.readUndirEdgeMap(name, map, reader);
+u_edgeset_reader.readUEdgeMap(name, map, reader);
 return *this;
 }
 /// \brief Give a new undirected edge map skipping command to the reader.
 ///
 /// Give a new undirected edge map skipping command to the reader.
 template <typename Reader>
-UndirGraphReader& skipUndirEdgeMap(std::string name,
+UGraphReader& skipUEdgeMap(std::string name,
 				       const Reader& reader = Reader()) {
-undir_edgeset_reader.skipUndirMap(name, reader);
+u_edgeset_reader.skipUMap(name, reader);
 return *this;
 }
 /// \brief Give a new edge map reading command to the reader.
 ///
 /// Give a new edge map reading command to the reader.
 template <typename Map>
-UndirGraphReader& readEdgeMap(std::string name, Map& map) {
+UGraphReader& readEdgeMap(std::string name, Map& map) {
-undir_edgeset_reader.readEdgeMap(name, map);
+u_edgeset_reader.readEdgeMap(name, map);
 return *this;
 }
 template <typename Map>
-UndirGraphReader& readEdgeMap(std::string name, const Map& map) {
+UGraphReader& readEdgeMap(std::string name, const Map& map) {
-undir_edgeset_reader.readEdgeMap(name, map);
+u_edgeset_reader.readEdgeMap(name, map);
 return *this;
 }
 /// \brief Give a new edge map reading command to the reader.
 ///
 /// Give a new edge map reading command to the reader.
 template <typename Reader, typename Map>
-UndirGraphReader& readEdgeMap(std::string name, Map& map,
+UGraphReader& readEdgeMap(std::string name, Map& map,
 				       const Reader& reader = Reader()) {
-undir_edgeset_reader.readEdgeMap(name, map, reader);
+u_edgeset_reader.readEdgeMap(name, map, reader);
 return *this;
 }
 template <typename Reader, typename Map>
-UndirGraphReader& readEdgeMap(std::string name, const Map& map,
+UGraphReader& readEdgeMap(std::string name, const Map& map,
 				       const Reader& reader = Reader()) {
-undir_edgeset_reader.readEdgeMap(name, map, reader);
+u_edgeset_reader.readEdgeMap(name, map, reader);
 return *this;
 }
 /// \brief Give a new edge map skipping command to the reader.
 ///
 /// Give a new edge map skipping command to the reader.
 template <typename Reader>
-UndirGraphReader& skipEdgeMap(std::string name,
+UGraphReader& skipEdgeMap(std::string name,
 				       const Reader& reader = Reader()) {
-undir_edgeset_reader.skipEdgeMap(name, reader);
+u_edgeset_reader.skipEdgeMap(name, reader);
 return *this;
 }
 /// \brief Give a new labeled node reading command to the reader.
 ///
 /// Give a new labeled node reading command to the reader.
-UndirGraphReader& readNode(std::string name, Node& node) {
+UGraphReader& readNode(std::string name, Node& node) {
 node_reader.readNode(name, node);
 return *this;
 }
 /// \brief Give a new labeled edge reading command to the reader.
 ///
 /// Give a new labeled edge reading command to the reader.
-UndirGraphReader& readEdge(std::string name, Edge& edge) {
+UGraphReader& readEdge(std::string name, Edge& edge) {
-undir_edge_reader.readEdge(name, edge);
+u_edge_reader.readEdge(name, edge);
 }
 /// \brief Give a new labeled undirected edge reading command to the
 /// reader.
 ///
 /// Give a new labeled undirected edge reading command to the reader.
-UndirGraphReader& readUndirEdge(std::string name, UndirEdge& edge) {
+UGraphReader& readUEdge(std::string name, UEdge& edge) {
-undir_edge_reader.readUndirEdge(name, edge);
+u_edge_reader.readUEdge(name, edge);
 }
 /// \brief Give a new attribute reading command.
 ///
 ///  Give a new attribute reading command.
 template <typename Value>
-UndirGraphReader& readAttribute(std::string name, Value& value) {
+UGraphReader& readAttribute(std::string name, Value& value) {
 attribute_reader.readAttribute(name, value);
 return *this;
 }
 /// \brief Give a new attribute reading command.
 ///
 ///  Give a new attribute reading command.
 template <typename Reader, typename Value>
-UndirGraphReader& readAttribute(std::string name, Value& value,
+UGraphReader& readAttribute(std::string name, Value& value,
 			       const Reader& reader) {
 attribute_reader.readAttribute<Reader>(name, value, reader);
 return *this;
 }
 /// \brief Returns true if the reader can give back the items by its label.
 ///
 /// \brief Returns true if the reader can give back the items by its label.
 bool isLabelReader() const {
 return nodeset_reader.isLabelReader() &&
-undir_edgeset_reader.isLabelReader();
+u_edgeset_reader.isLabelReader();
 }
 /// \brief Gives back the node by its label.
 ///
 /// It reads an label from the stream and gives back which node belongs to
 /// \brief Gives back the edge by its label.
 ///
 /// It reads an label from the stream and gives back which edge belongs to
 /// it. It is possible only if there was read an "label" named edge map.
 void readLabel(std::istream& is, Edge& edge) const {
-return undir_edgeset_reader.readLabel(is, edge);
+return u_edgeset_reader.readLabel(is, edge);
 }
 /// \brief Gives back the undirected edge by its label.
 ///
 /// It reads an label from the stream and gives back which undirected edge
 /// belongs to it. It is possible only if there was read an "label" named
 /// edge map.
-void readLabel(std::istream& is, UndirEdge& uedge) const {
+void readLabel(std::istream& is, UEdge& uedge) const {
-return undir_edgeset_reader.readLabel(is, uedge);
+return u_edgeset_reader.readLabel(is, uedge);
 }
 private:
 bool own_reader;
 DefaultSkipper skipper;
 NodeSetReader<Graph, ReaderTraits> nodeset_reader;
-UndirEdgeSetReader<Graph, ReaderTraits> undir_edgeset_reader;
+UEdgeSetReader<Graph, ReaderTraits> u_edgeset_reader;
 NodeReader<Graph> node_reader;
-UndirEdgeReader<Graph> undir_edge_reader;
+UEdgeReader<Graph> u_edge_reader;
 AttributeReader<ReaderTraits> attribute_reader;
 };
 /// \brief Read an undirected graph from the input.
 ///
 /// It is a helper function to read an undirected graph from the given input
-/// stream. It gives back an UndirGraphReader object and this object
+/// stream. It gives back an UGraphReader object and this object
 /// can read more maps, labeled nodes, edges, undirected edges and
 /// attributes.
 ///
 /// \warning Do not forget to call the \c run() function.
 ///
 /// \param is The input stream.
 /// \param g The graph.
 template<typename Graph>
-UndirGraphReader<Graph> undirGraphReader(std::istream& is, Graph &g) {
+UGraphReader<Graph> uGraphReader(std::istream& is, Graph &g) {
 return GraphReader<Graph>(is, g);
 }
 /// \brief Read an undirected graph from the input.
 ///
 /// It is a helper function to read an undirected graph from the given input
-/// file. It gives back an UndirGraphReader object and this object
+/// file. It gives back an UGraphReader object and this object
 /// can read more maps, labeled nodes, edges, undirected edges and
 /// attributes.
 ///
 /// \warning Do not forget to call the \c run() function.
 ///
 /// \param fn The input filename.
 /// \param g The graph.
 template<typename Graph>
-UndirGraphReader<Graph> undirGraphReader(const std::string& fn, Graph &g) {
+UGraphReader<Graph> uGraphReader(const std::string& fn, Graph &g) {
 return GraphReader<Graph>(fn, g);
 }
 /// @}
 }

changeset 1917	87d3518d73d8
parent 1901	723b2b81d900
child 1935	67b38d699ea7