Changeset 1909:2d806130e700 in lemon-0.x for lemon/graph_writer.h

Timestamp:

01/26/06 16:42:13 (18 years ago)

Author:

Mihaly Barasz

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2484

Message:

Undir -> U transition

File:

• lemon/graph_writer.h (modified) (27 diffs)

lemon/graph_writer.h

@@ -316 +316 @@
   /// \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 
-  /// writing and labeled Node, Edge or UndirEdge writing.
-  ///
-  /// \code
-  /// UndirGraphWriter<UndirListGraph> writer(std::cout, graph);
+  /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap 
+  /// writing and labeled Node, Edge or UEdge writing.
+  ///
+  /// \code
+  /// 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 
@@ -332 +332 @@
   ///
   /// \code
-  /// IdMap<UndirListGraph, Node> nodeLabelMap;
+  /// IdMap<ListUGraph, Node> nodeLabelMap;
   /// writer.writeNodeMap("label", nodeLabelMap);
   ///
@@ -339 +339 @@
   /// \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.
   ///
@@ -345 +345 @@
   /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 
   ///   edgeDescMap(graph);
-  /// writer.writeUndirEdgeMap("descriptor", edgeDescMap);
-  ///
-  /// writer.writeUndirEdgeMap("weight", weightMap);
-  /// writer.writeUndirEdgeMap("label", labelMap);
+  /// writer.writeUEdgeMap("descriptor", edgeDescMap);
+  ///
+  /// writer.writeUEdgeMap("weight", weightMap);
+  /// writer.writeUEdgeMap("label", labelMap);
   /// \endcode
   /// 
@@ -359 +359 @@
   ///
   ///
-  /// 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.
@@ -367 +367 @@
   /// writer.writeNode("target", targetNode);
   ///
-  /// writer.writeUndirEdge("observed", undirEdge);
+  /// writer.writeUEdge("observed", uEdge);
   /// \endcode
   ///
@@ -385 +385 @@
   /// \author Balazs Dezso
   template <typename _Graph, typename _WriterTraits = DefaultWriterTraits> 
-  class UndirGraphWriter {
+  class UGraphWriter {
   public:
     
@@ -391 +391 @@
     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.
-    ///
-    /// Construct a new UndirGraphWriter. It writes the given graph
+    /// \brief Construct a new UGraphWriter.
+    ///
+    /// 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.
-    ///
-    /// Construct a new UndirGraphWriter. It writes the given graph
+    /// \brief Construct a new UGraphWriter.
+    ///
+    /// 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.
-    ///
-    /// Construct a new UndirGraphWriter. It writes the given graph
+    /// \brief Construct a new UGraphWriter.
+    ///
+    /// 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()) {}
 
@@ -434 +434 @@
     ///
     /// Destruct the graph writer.
-    ~UndirGraphWriter() {
+    ~UGraphWriter() {
       if (own_writer) 
         delete writer;
@@ -443 +443 @@
    /// 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;
@@ -452 +452 @@
    /// 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);
@@ -462 +462 @@
    /// 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) { 
-      undir_edgeset_writer.writeEdgeMap(name, map);
+    UGraphWriter& writeEdgeMap(std::string name, const Map& map) { 
+      u_edgeset_writer.writeEdgeMap(name, map);
       return *this;
     }
@@ -471 +471 @@
    /// 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;
     }
@@ -482 +482 @@
     /// command</i> to the writer.
     template <typename Map>
-    UndirGraphWriter& writeUndirEdgeMap(std::string name, const Map& map) { 
-      undir_edgeset_writer.writeUndirEdgeMap(name, map);
+    UGraphWriter& writeUEdgeMap(std::string name, const Map& map) { 
+      u_edgeset_writer.writeUEdgeMap(name, map);
       return *this;
     }
@@ -492 +492 @@
     /// 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;
     }
@@ -502 +502 @@
     /// 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;
@@ -511 +511 @@
     /// This function issues a new <i> labeled edge writing
     /// command</i> to the writer.
-    UndirGraphWriter& writeEdge(std::string name, const Edge& edge) {
-      undir_edge_writer.writeEdge(name, edge);
+    UGraphWriter& writeEdge(std::string name, const Edge& edge) {
+      u_edge_writer.writeEdge(name, edge);
     }
 
@@ -520 +520 @@
     /// Issue a new <i>labeled undirected edge writing command</i> to
     /// the writer.
-    UndirGraphWriter& writeUndirEdge(std::string name, const UndirEdge& edge) {
-      undir_edge_writer.writeUndirEdge(name, edge);
+    UGraphWriter& writeUEdge(std::string name, const UEdge& edge) {
+      u_edge_writer.writeUEdge(name, edge);
     }
 
@@ -529 +529 @@
     /// 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;
@@ -539 +539 @@
     /// 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);
@@ -575 +575 @@
     /// 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);
     } 
 
@@ -583 +583 @@
     /// 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 {
-      undir_edgeset_writer.writeLabel(os, item);
+    void writeLabel(std::ostream& os, const UEdge& item) const {
+      u_edgeset_writer.writeLabel(os, item);
     } 
 
@@ -594 +594 @@
 
     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;
@@ -605 +605 @@
   ///
   /// 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.
@@ -612 +612 @@
   /// \param g The graph.
   template <typename Graph>
-  UndirGraphWriter<Graph> undirGraphWriter(std::ostream& os, const Graph &g) {
-    return UndirGraphWriter<Graph>(os, g);
+  UGraphWriter<Graph> uGraphWriter(std::ostream& os, const Graph &g) {
+    return UGraphWriter<Graph>(os, g);
   }
 
@@ -619 +619 @@
   ///
   /// 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.
@@ -628 +628 @@
   /// \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);
   }