lemon-0.x: comparison lemon/graph

equal deleted inserted replaced

-:2e2fe4aa6fb4
+:a9c4cee68f43
 return GraphWriter<Graph>(fn, g);
 }
 /// \brief The undirected graph writer class.
 ///
-/// The \c UndirGraphWriter class provides the undir graph output. To write
+/// The \c UGraphWriter class provides the ugraph output. To write
 /// a graph you should first give writing commands to the writer. You can
-/// declare write command as \c NodeMap, \c EdgeMap or \c UndirEdgeMap
+/// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap
-/// writing and labeled Node, Edge or UndirEdge writing.
+/// writing and labeled Node, Edge or UEdge writing.
 ///
 /// \code
-/// UndirGraphWriter<UndirListGraph> writer(std::cout, graph);
+/// UGraphWriter<ListUGraph> writer(std::cout, graph);
 /// \endcode
 ///
 /// The \c writeNodeMap() function declares a \c NodeMap writing
-/// command in the \c UndirGraphWriter. You should give as parameter
+/// command in the \c UGraphWriter. You should give as parameter
 /// the name of the map and the map object. The NodeMap writing
 /// command with name "label" should write a unique map because it
 /// is regarded as label map.
 ///
 /// \code
-/// IdMap<UndirListGraph, Node> nodeLabelMap;
+/// IdMap<ListUGraph, Node> nodeLabelMap;
 /// writer.writeNodeMap("label", nodeLabelMap);
 ///
 /// writer.writeNodeMap("coords", coords);
 /// writer.writeNodeMap("color", colorMap);
 /// \endcode
 ///
-/// With the \c writeUndirEdgeMap() member function you can give an
+/// With the \c writeUEdgeMap() member function you can give an
 /// undirected edge map writing command similar to the NodeMaps.
 ///
 /// \code
 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> >
 ///   edgeDescMap(graph);
-/// writer.writeUndirEdgeMap("descriptor", edgeDescMap);
+/// writer.writeUEdgeMap("descriptor", edgeDescMap);
 ///
-/// writer.writeUndirEdgeMap("weight", weightMap);
+/// writer.writeUEdgeMap("weight", weightMap);
-/// writer.writeUndirEdgeMap("label", labelMap);
+/// writer.writeUEdgeMap("label", labelMap);
 /// \endcode
 ///
 /// The EdgeMap handling is just a syntactical sugar. It writes
 /// two undirected edge map with '+' and '-' prefix in the name.
 ///
 /// \code
 /// writer.writeEdgeMap("capacity", capacityMap);
 /// \endcode
 ///
 ///
-/// With \c writeNode() and \c writeUndirEdge() functions you can
+/// With \c writeNode() and \c writeUEdge() functions you can
 /// designate nodes and undirected edges in the graph. For example, you can
 /// write out the source and target of the graph.
 ///
 /// \code
 /// writer.writeNode("source", sourceNode);
 /// writer.writeNode("target", targetNode);
 ///
-/// writer.writeUndirEdge("observed", undirEdge);
+/// writer.writeUEdge("observed", uEdge);
 /// \endcode
 ///
 /// After you give all write commands you must call the \c run() member
 /// function, which executes all the writing commands.
 ///
 /// \see DescriptorMap
 /// \see \ref GraphWriter
 /// \see \ref graph-io-page
 /// \author Balazs Dezso
 template <typename _Graph, typename _WriterTraits = DefaultWriterTraits>
-class UndirGraphWriter {
+class UGraphWriter {
 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 _WriterTraits WriterTraits;
-/// \brief Construct a new UndirGraphWriter.
+/// \brief Construct a new UGraphWriter.
 ///
-/// Construct a new UndirGraphWriter. It writes the given graph
+/// Construct a new UGraphWriter. It writes the given graph
 /// to the given stream.
-UndirGraphWriter(std::ostream& _os, const Graph& _graph)
+UGraphWriter(std::ostream& _os, const Graph& _graph)
 : writer(new LemonWriter(_os)), own_writer(true),
 	nodeset_writer(*writer, _graph, std::string()),
-	undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
+	u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
 	node_writer(*writer, nodeset_writer, std::string()),
-	undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
+	u_edge_writer(*writer, u_edgeset_writer, std::string()),
 	attribute_writer(*writer, std::string()) {}
-/// \brief Construct a new UndirGraphWriter.
+/// \brief Construct a new UGraphWriter.
 ///
-/// Construct a new UndirGraphWriter. It writes the given graph
+/// Construct a new UGraphWriter. It writes the given graph
 /// to the given file.
-UndirGraphWriter(const std::string& _filename, const Graph& _graph)
+UGraphWriter(const std::string& _filename, const Graph& _graph)
 : writer(new LemonWriter(_filename)), own_writer(true),
 	nodeset_writer(*writer, _graph, std::string()),
-	undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
+	u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
 	node_writer(*writer, nodeset_writer, std::string()),
-	undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
+	u_edge_writer(*writer, u_edgeset_writer, std::string()),
 	attribute_writer(*writer, std::string()) {}
-/// \brief Construct a new UndirGraphWriter.
+/// \brief Construct a new UGraphWriter.
 ///
-/// Construct a new UndirGraphWriter. It writes the given graph
+/// Construct a new UGraphWriter. It writes the given graph
 /// to given LemonReader.
-UndirGraphWriter(LemonWriter& _writer, const Graph& _graph)
+UGraphWriter(LemonWriter& _writer, const Graph& _graph)
 : writer(_writer), own_writer(false),
 	nodeset_writer(*writer, _graph, std::string()),
-	undir_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
+	u_edgeset_writer(*writer, _graph, nodeset_writer, std::string()),
 	node_writer(*writer, nodeset_writer, std::string()),
-	undir_edge_writer(*writer, undir_edgeset_writer, std::string()),
+	u_edge_writer(*writer, u_edgeset_writer, std::string()),
 	attribute_writer(*writer, std::string()) {}
 /// \brief Destruct the graph writer.
 ///
 /// Destruct the graph writer.
-~UndirGraphWriter() {
+~UGraphWriter() {
 if (own_writer)
 	delete writer;
 }
 /// \brief Issue a new node map writing command to the writer.
 ///
 /// This function issues a new <i> node map writing command</i> to the writer.
 template <typename Map>
-UndirGraphWriter& writeNodeMap(std::string name, const Map& map) {
+UGraphWriter& writeNodeMap(std::string name, const Map& map) {
 nodeset_writer.writeNodeMap(name, map);
 return *this;
 }
 /// \brief Issue a new node map writing command to the writer.
 ///
 /// This function issues a new <i> node map writing command</i> to the writer.
 template <typename Writer, typename Map>
-UndirGraphWriter& writeNodeMap(std::string name, const Map& map,
+UGraphWriter& writeNodeMap(std::string name, const Map& map,
 			      const Writer& writer = Writer()) {
 nodeset_writer.writeNodeMap(name, map, writer);
 return *this;
 }
 /// \brief Issue a new edge map writing command to the writer.
 ///
 /// This function issues a new <i> edge map writing command</i> to the writer.
 template <typename Map>
-UndirGraphWriter& writeEdgeMap(std::string name, const Map& map) {
+UGraphWriter& writeEdgeMap(std::string name, const Map& map) {
-undir_edgeset_writer.writeEdgeMap(name, map);
+u_edgeset_writer.writeEdgeMap(name, map);
 return *this;
 }
 /// \brief Issue a new edge map writing command to the writer.
 ///
 /// This function issues a new <i> edge map writing command</i> to the writer.
 template <typename Writer, typename Map>
-UndirGraphWriter& writeEdgeMap(std::string name, const Map& map,
+UGraphWriter& writeEdgeMap(std::string name, const Map& map,
 				   const Writer& writer = Writer()) {
-undir_edgeset_writer.writeEdgeMap(name, map, writer);
+u_edgeset_writer.writeEdgeMap(name, map, writer);
 return *this;
 }
 /// \brief Issue a new undirected edge map writing command to the writer.
 ///
 /// This function issues a new <i> undirected edge map writing
 /// command</i> to the writer.
 template <typename Map>
-UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map) {
+UGraphWriter& writeUEdgeMap(std::string name, const Map& map) {
-undir_edgeset_writer.writeUndirEdgeMap(name, map);
+u_edgeset_writer.writeUEdgeMap(name, map);
 return *this;
 }
 /// \brief Issue a new undirected edge map writing command to the writer.
 ///
 /// This function issues a new <i> undirected edge map writing
 /// command</i> to the writer.
 template <typename Writer, typename Map>
-UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map,
+UGraphWriter& writeUEdgeMap(std::string name, const Map& map,
 					const Writer& writer = Writer()) {
-undir_edgeset_writer.writeUndirEdgeMap(name, map, writer);
+u_edgeset_writer.writeUEdgeMap(name, map, writer);
 return *this;
 }
 /// \brief Issue a new labeled node writer to the writer.
 ///
 /// This function issues a new <i> labeled node writing
 /// command</i> to the writer.
-UndirGraphWriter& writeNode(std::string name, const Node& node) {
+UGraphWriter& writeNode(std::string name, const Node& node) {
 node_writer.writeNode(name, node);
 return *this;
 }
 /// \brief Issue a new labeled edge writer to the writer.
 ///
 /// This function issues a new <i> labeled edge writing
 /// command</i> to the writer.
-UndirGraphWriter& writeEdge(std::string name, const Edge& edge) {
+UGraphWriter& writeEdge(std::string name, const Edge& edge) {
-undir_edge_writer.writeEdge(name, edge);
+u_edge_writer.writeEdge(name, edge);
 }
 /// \brief Issue a new labeled undirected edge writing command to
 /// the writer.
 ///
 /// Issue a new <i>labeled undirected edge writing command</i> to
 /// the writer.
-UndirGraphWriter& writeUndirEdge(std::string name, const UndirEdge& edge) {
+UGraphWriter& writeUEdge(std::string name, const UEdge& edge) {
-undir_edge_writer.writeUndirEdge(name, edge);
+u_edge_writer.writeUEdge(name, edge);
 }
 /// \brief Issue a new attribute writing command.
 ///
 /// This function issues a new <i> attribute writing
 /// command</i> to the writer.
 template <typename Value>
-UndirGraphWriter& writeAttribute(std::string name, const Value& value) {
+UGraphWriter& writeAttribute(std::string name, const Value& value) {
 attribute_writer.writeAttribute(name, value);
 return *this;
 }
 /// \brief Issue a new attribute writing command.
 ///
 /// This function issues a new <i> attribute writing
 /// command</i> to the writer.
 template <typename Writer, typename Value>
-UndirGraphWriter& writeAttribute(std::string name, const Value& value,
+UGraphWriter& writeAttribute(std::string name, const Value& value,
 			       const Writer& writer) {
 attribute_writer.writeAttribute<Writer>(name, value, writer);
 return *this;
 }
 /// \brief Write the label of the given edge.
 ///
 /// It writes the label of the given edge. If there was written an "label"
 /// named edge map then it will write the map value belonging to the edge.
 void writeLabel(std::ostream& os, const Edge& item) const {
-undir_edgeset_writer.writeLabel(os, item);
+u_edgeset_writer.writeLabel(os, item);
 }
 /// \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 edge map then it will write the map value belonging to
 /// the edge.
-void writeLabel(std::ostream& os, const UndirEdge& item) const {
+void writeLabel(std::ostream& os, const UEdge& item) const {
-undir_edgeset_writer.writeLabel(os, item);
+u_edgeset_writer.writeLabel(os, item);
 }
 private:
 LemonWriter* writer;
 bool own_writer;
 NodeSetWriter<Graph, WriterTraits> nodeset_writer;
-UndirEdgeSetWriter<Graph, WriterTraits> undir_edgeset_writer;
+UEdgeSetWriter<Graph, WriterTraits> u_edgeset_writer;
 NodeWriter<Graph> node_writer;
-UndirEdgeWriter<Graph> undir_edge_writer;
+UEdgeWriter<Graph> u_edge_writer;
 AttributeWriter<WriterTraits> attribute_writer;
 };
 /// \brief Write an undirected graph to the output.
 ///
 /// It is a helper function to write an undirected graph to the given output
-/// stream. It gives back an UndirGraphWriter object and this object
+/// stream. It gives back an UGraphWriter object and this object
 /// can write more maps, labeled nodes and edges and attributes.
 /// \warning Do not forget to call the \c run() function.
 ///
 /// \param os The output stream.
 /// \param g The graph.
 template <typename Graph>
-UndirGraphWriter<Graph> undirGraphWriter(std::ostream& os, const Graph &g) {
+UGraphWriter<Graph> uGraphWriter(std::ostream& os, const Graph &g) {
-return UndirGraphWriter<Graph>(os, g);
+return UGraphWriter<Graph>(os, g);
 }
 /// \brief Write an undirected graph to the output.
 ///
 /// It is a helper function to write an undirected graph to the given output
-/// file. It gives back an UndirGraphWriter object and this object
+/// file. It gives back an UGraphWriter object and this object
 /// can write more maps, labeled nodes, edges, undirected edges and
 /// attributes.
 ///
 /// \warning Do not forget to call the \c run() function.
 ///
 /// \param fn The output file.
 /// \param g The graph.
 template <typename Graph>
-UndirGraphWriter<Graph> undirGraphWriter(const std::string& fn,
+UGraphWriter<Graph> uGraphWriter(const std::string& fn,
 					   const Graph &g) {
-return UndirGraphWriter<Graph>(fn, g);
+return UGraphWriter<Graph>(fn, g);
 }
 /// @}
 }

changeset 1913	49fe71fce7fb
parent 1901	723b2b81d900
child 1946	17eb3eaad9f8