Changeset 1909:2d806130e700 in lemon-0.x for lemon/lemon_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/lemon_writer.h (modified) (22 diffs)

lemon/lemon_writer.h

@@ -92 +92 @@
     class ForwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -116 +116 @@
     class BackwardComposeMap {
     public:
-      typedef typename Graph::UndirEdge Key;
+      typedef typename Graph::UEdge Key;
       typedef typename Map::Value Value;
 
@@ -709 +709 @@
   ///
   /// The lemon format can store multiple undirected edgesets with several 
-  /// maps. The undirected edgeset section's header line is \c \@undiredgeset 
-  /// \c undiredgeset_name, but the \c undiredgeset_name may be empty.
+  /// maps. The undirected edgeset section's header line is \c \@uedgeset 
+  /// \c uedgeset_name, but the \c uedgeset_name may be empty.
   ///
   /// The first line of the section contains the names of the maps separated
@@ -735 +735 @@
   /// \relates LemonWriter
   template <typename _Graph, typename _Traits = DefaultWriterTraits>
-  class UndirEdgeSetWriter : public LemonWriter::SectionWriter {
+  class UEdgeSetWriter : public LemonWriter::SectionWriter {
     typedef LemonWriter::SectionWriter Parent;
   public:
@@ -743 +743 @@
     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 
@@ -753 +753 @@
     /// "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(),
@@ -766 +766 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeSetWriter.
-    virtual ~UndirEdgeSetWriter() {
+    /// Destructor for UEdgeSetWriter.
+    virtual ~UEdgeSetWriter() {
       typename MapWriters::iterator it;
       for (it = writers.begin(); it != writers.end(); ++it) {
@@ -775 +775 @@
 
   private:
-    UndirEdgeSetWriter(const UndirEdgeSetWriter&);
-    void operator=(const UndirEdgeSetWriter&);
+    UEdgeSetWriter(const UEdgeSetWriter&);
+    void operator=(const UEdgeSetWriter&);
 
   public:
@@ -784 +784 @@
     /// Add a new undirected map writer command for the writer.
     template <typename Map>
-    UndirEdgeSetWriter& writeUndirEdgeMap(std::string name, const Map& map) {
-      return writeUndirEdgeMap<typename Traits::
+    UEdgeSetWriter& writeUEdgeMap(std::string name, const Map& map) {
+      return writeUEdgeMap<typename Traits::
         template Writer<typename Map::Value>, Map>(name, map);
     }
@@ -793 +793 @@
     /// 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;
     }
@@ -807 +807 @@
     /// 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);
@@ -816 +816 @@
     /// 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;
@@ -833 +833 @@
     /// It gives back the header of the section.
     virtual std::string header() {
-      return "@undiredgeset " + name;
+      return "@uedgeset " + name;
     }
 
@@ -858 +858 @@
       }
       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';
@@ -892 +892 @@
     /// 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);
@@ -923 +923 @@
 
     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;
    
@@ -1100 +1100 @@
   /// \brief SectionWriter for writing named undirected edges.
   ///
-  /// The undirected edges section's header line is \c \@undiredges 
-  /// \c undiredges_name, but the \c undiredges_name may be empty.
+  /// The undirected edges section's header line is \c \@uedges 
+  /// \c uedges_name, but the \c uedges_name may be empty.
   ///
   /// Each line in the section contains the name of the undirected edge and 
@@ -1108 +1108 @@
   /// \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>();
-      undirEdgeLabelWriter.reset(new _writer_bits::
-                              LabelWriter<UndirEdge, _LabelWriter>(_labelWriter));
+      checkConcept<_writer_bits::ItemLabelWriter<UEdge>, _LabelWriter>();
+      uEdgeLabelWriter.reset(new _writer_bits::
+                              LabelWriter<UEdge, _LabelWriter>(_labelWriter));
       edgeLabelWriter.reset(new _writer_bits::
                          LabelWriter<Edge, _LabelWriter>(_labelWriter));
@@ -1136 +1136 @@
     /// \brief Destructor.
     ///
-    /// Destructor for UndirEdgeWriter.
-    virtual ~UndirEdgeWriter() {}
-  private:
-    UndirEdgeWriter(const UndirEdgeWriter&);
-    void operator=(const UndirEdgeWriter&);
-
-  public:
-
-    /// \brief Add an edge writer command for the UndirEdgeWriter.
-    ///
-    /// Add an edge writer command for the UndirEdgeWriter.
+    /// Destructor for UEdgeWriter.
+    virtual ~UEdgeWriter() {}
+  private:
+    UEdgeWriter(const UEdgeWriter&);
+    void operator=(const UEdgeWriter&);
+
+  public:
+
+    /// \brief Add an edge writer command for the UEdgeWriter.
+    ///
+    /// 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.
-    ///
-    /// Add an undirected edge writer command for the UndirEdgeWriter.
-    void writeUndirEdge(const std::string& name, const UndirEdge& item) {
-      undirEdgeWriters.push_back(make_pair(name, &item));
+    /// \brief Add an undirected edge writer command for the UEdgeWriter.
+    ///
+    /// Add an undirected edge writer command for the UEdgeWriter.
+    void writeUEdge(const std::string& name, const UEdge& item) {
+      uEdgeWriters.push_back(make_pair(name, &item));
     }
 
@@ -1164 +1164 @@
     /// It gives back the header of the section.
     virtual std::string header() {
-      return "@undiredges " + name;
+      return "@uedges " + name;
     }
 
@@ -1174 +1174 @@
         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) {
-        os << undirEdgeWriters[i].first << ' ';
-        undirEdgeLabelWriter->write(os, *(undirEdgeWriters[i].second));
+      for (int i = 0; i < (int)uEdgeWriters.size(); ++i) {
+        os << uEdgeWriters[i].first << ' ';
+        uEdgeLabelWriter->write(os, *(uEdgeWriters[i].second));
         os << std::endl;
       }
@@ -1194 +1194 @@
 
     typedef std::vector<std::pair<std::string, 
-                                  const UndirEdge*> > UndirEdgeWriters;
-    UndirEdgeWriters undirEdgeWriters;
-    std::auto_ptr<_writer_bits::LabelWriterBase<UndirEdge> > undirEdgeLabelWriter;
+                                  const UEdge*> > UEdgeWriters;
+    UEdgeWriters uEdgeWriters;
+    std::auto_ptr<_writer_bits::LabelWriterBase<UEdge> > uEdgeLabelWriter;
 
     typedef std::vector<std::pair<std::string, const Edge*> > EdgeWriters;