Context Navigation

Reverse Diff

Changes in lemon/lgf_reader.h [190:1e6af6f0843c:201:9757e3d9bfeb] in lemon-1.2

File:

: 1 edited

lemon/lgf_reader.h (modified) (44 diffs)

Legend:

: Unmodified
: Added
: Removed

lemon/lgf_reader.h

-                      r190
+                      r201
 ///\ingroup lemon_io
 ///\file
 ///\brief Lemon Graph Format reader.
+///\brief \ref lgf-format "Lemon Graph Format" reader.
 …
     };
     bool isWhiteSpace(char c) {
+    inline bool isWhiteSpace(char c) {
       return c == ' ' || c == '\t' || c == '\v' ||
         c == '\n' || c == '\r' || c == '\f';
+    }
     bool isOct(char c) {
+    inline bool isOct(char c) {
       return '0' <= c && c <='7';
+    }
     int valueOct(char c) {
+    inline int valueOct(char c) {
       LEMON_ASSERT(isOct(c), "The character is not octal.");
       return c - '0';
+    }
     bool isHex(char c) {
+    inline bool isHex(char c) {
       return ('0' <= c && c <= '9') ||
         ('a' <= c && c <= 'z') ||
 …
+    }
     int valueHex(char c) {
+    inline int valueHex(char c) {
       LEMON_ASSERT(isHex(c), "The character is not hexadecimal.");
       if ('0' <= c && c <= '9') return c - '0';
 …
+    }
     bool isIdentifierFirstChar(char c) {
+    inline bool isIdentifierFirstChar(char c) {
       return ('a' <= c && c <= 'z') ||
         ('A' <= c && c <= 'Z') || c == '_';
+    }
     bool isIdentifierChar(char c) {
+    inline bool isIdentifierChar(char c) {
       return isIdentifierFirstChar(c) ||
         ('0' <= c && c <= '9');
+    }
     char readEscape(std::istream& is) {
+    inline char readEscape(std::istream& is) {
       char c;
       if (!is.get(c))
 …
+    }
     std::istream& readToken(std::istream& is, std::string& str) {
+    inline std::istream& readToken(std::istream& is, std::string& str) {
       std::ostringstream os;
 …
   /// \ingroup lemon_io
   ///
   /// \brief LGF reader for directed graphs
+  /// \brief \ref lgf-format "LGF" reader for directed graphs
   ///
   /// This utility reads an \ref lgf-format "LGF" file.
 …
   /// with the \c nodeMap() or \c arcMap() members. An optional
   /// converter parameter can also be added as a standard functor
   /// converting from std::string to the value type of the map. If it
+  /// converting from \c std::string to the value type of the map. If it
   /// is set, it will determine how the tokens in the file should be
   /// is converted to the map's value type. If the functor is not set,
+  /// converted to the value type of the map. If the functor is not set,
   /// then a default conversion will be used. One map can be read into
   /// multiple map objects at the same time. The \c attribute(), \c
 …
   ///
   ///\code
   ///     DigraphReader<Digraph>(std::cin, digraph).
   ///       nodeMap("coordinates", coord_map).
   ///       arcMap("capacity", cap_map).
   ///       node("source", src).
   ///       node("target", trg).
   ///       attribute("caption", caption).
   ///       run();
+  /// DigraphReader<Digraph>(std::cin, digraph).
+  ///   nodeMap("coordinates", coord_map).
+  ///   arcMap("capacity", cap_map).
+  ///   node("source", src).
+  ///   node("target", trg).
+  ///   attribute("caption", caption).
+  ///   run();
   ///\endcode
   ///
 …
   /// graph) during the reading, but instead the label map of the items
   /// are given as a parameter of these functions. An
   /// application of these function is multipass reading, which is
   /// important if two \e \@arcs sections must be read from the
   /// file. In this example the first phase would read the node set and one
+  /// application of these functions is multipass reading, which is
+  /// important if two \c \@arcs sections must be read from the
+  /// file. In this case the first phase would read the node set and one
   /// of the arc sets, while the second phase would read the second arc
   /// set into an \e ArcSet class (\c SmartArcSet or \c ListArcSet).
   /// The previously read label node map should be passed to the \c
   /// useNodes() functions. Another application of multipass reading when
   /// paths are given as a node map or an arc map. It is impossible read this in
+  /// paths are given as a node map or an arc map. It is impossible to read this in
   /// a single pass, because the arcs are not constructed when the node
   /// maps are read.
 …
     /// Use previously constructed node set, and specify the node
     /// label map and a functor which converts the label map values to
     /// std::string.
+    /// \c std::string.
     template <typename Map, typename Converter>
     DigraphReader& useNodes(const Map& map,
 …
     /// Use previously constructed arc set, and specify the arc
     /// label map and a functor which converts the label map values to
     /// std::string.
+    /// \c std::string.
     template <typename Map, typename Converter>
     DigraphReader& useArcs(const Map& map,
 …
     ///
     /// Omit the reading of the node section. This implies that each node
     /// map reading rule will be abanoned, and the nodes of the graph
+    /// map reading rule will be abandoned, and the nodes of the graph
     /// will not be constructed, which usually cause that the arc set
+    /// could not be read due to lack of node name
+    /// resolving. Therefore, the \c skipArcs() should be used too, or
+    /// the useNodes() member function should be used to specify the
+    /// label of the nodes.
+    /// could not be read due to lack of node name resolving.
+    /// Therefore \c skipArcs() function should also be used, or
+    /// \c useNodes() should be used to specify the label of the nodes.
     DigraphReader& skipNodes() {
       LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
 …
     ///
     /// Omit the reading of the arc section. This implies that each arc
     /// map reading rule will be abanoned, and the arcs of the graph
+    /// map reading rule will be abandoned, and the arcs of the graph
     /// will not be constructed.
     DigraphReader& skipArcs() {
 …
   };
+  /// \brief Return a \ref DigraphReader class
+  ///
+  /// This function just returns a \ref DigraphReader class.
   /// \relates DigraphReader
   template <typename Digraph>
 …
+  }
+  /// \brief Return a \ref DigraphReader class
+  ///
+  /// This function just returns a \ref DigraphReader class.
   /// \relates DigraphReader
   template <typename Digraph>
 …
+  }
+  /// \brief Return a \ref DigraphReader class
+  ///
+  /// This function just returns a \ref DigraphReader class.
   /// \relates DigraphReader
   template <typename Digraph>
 …
   /// \ingroup lemon_io
   ///
   /// \brief LGF reader for undirected graphs
+  /// \brief \ref lgf-format "LGF" reader for undirected graphs
   ///
   /// This utility reads an \ref lgf-format "LGF" file.
+  ///
+  /// It can be used almost the same way as \c DigraphReader.
+  /// The only difference is that this class can handle edges and
+  /// edge maps as well as arcs and arc maps.
+  ///
+  /// The columns in the \c \@edges (or \c \@arcs) section are the
+  /// edge maps. However, if there are two maps with the same name
+  /// prefixed with \c '+' and \c '-', then these can be read into an
+  /// arc map.  Similarly, an attribute can be read into an arc, if
+  /// it's value is an edge label prefixed with \c '+' or \c '-'.
   template <typename _Graph>
   class GraphReader {
 …
     /// \brief Constructor
     ///
     /// Construct a undirected graph reader, which reads from the given
+    /// Construct an undirected graph reader, which reads from the given
     /// input stream.
     GraphReader(std::istream& is, Graph& graph)
 …
     /// \brief Constructor
     ///
     /// Construct a undirected graph reader, which reads from the given
+    /// Construct an undirected graph reader, which reads from the given
     /// file.
     GraphReader(const std::string& fn, Graph& graph)
 …
     /// \brief Constructor
     ///
     /// Construct a undirected graph reader, which reads from the given
+    /// Construct an undirected graph reader, which reads from the given
     /// file.
     GraphReader(const char* fn, Graph& graph)
 …
     /// \brief Set \c \@nodes section to be read
     ///
     /// Set \c \@nodes section to be read
+    /// Set \c \@nodes section to be read.
     GraphReader& nodes(const std::string& caption) {
       _nodes_caption = caption;
 …
     /// \brief Set \c \@edges section to be read
     ///
     /// Set \c \@edges section to be read
+    /// Set \c \@edges section to be read.
     GraphReader& edges(const std::string& caption) {
       _edges_caption = caption;
 …
     /// \brief Set \c \@attributes section to be read
     ///
     /// Set \c \@attributes section to be read
+    /// Set \c \@attributes section to be read.
     GraphReader& attributes(const std::string& caption) {
       _attributes_caption = caption;
 …
     /// Use previously constructed node set, and specify the node
     /// label map and a functor which converts the label map values to
     /// std::string.
+    /// \c std::string.
     template <typename Map, typename Converter>
     GraphReader& useNodes(const Map& map,
 …
     /// Use previously constructed edge set, and specify the edge
     /// label map and a functor which converts the label map values to
     /// std::string.
+    /// \c std::string.
     template <typename Map, typename Converter>
     GraphReader& useEdges(const Map& map,
 …
+    }
     /// \brief Skips the reading of node section
+    /// \brief Skip the reading of node section
     ///
     /// Omit the reading of the node section. This implies that each node
     /// map reading rule will be abanoned, and the nodes of the graph
+    /// map reading rule will be abandoned, and the nodes of the graph
     /// will not be constructed, which usually cause that the edge set
     /// could not be read due to lack of node name
     /// resolving. Therefore, the \c skipEdges() should be used too, or
     /// the useNodes() member function should be used to specify the
     /// label of the nodes.
+    /// could not be read due to lack of node name resolving.
+    /// Therefore \c skipEdges() function should also be used, or
+    /// \c useNodes() should be used to specify the label of the nodes.
     GraphReader& skipNodes() {
       LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
 …
+    }
     /// \brief Skips the reading of edge section
+    /// \brief Skip the reading of edge section
     ///
     /// Omit the reading of the edge section. This implies that each edge
     /// map reading rule will be abanoned, and the edges of the graph
+    /// map reading rule will be abandoned, and the edges of the graph
     /// will not be constructed.
     GraphReader& skipEdges() {
 …
   };
+  /// \brief Return a \ref GraphReader class
+  ///
+  /// This function just returns a \ref GraphReader class.
   /// \relates GraphReader
   template <typename Graph>
 …
+  }
+  /// \brief Return a \ref GraphReader class
+  ///
+  /// This function just returns a \ref GraphReader class.
   /// \relates GraphReader
   template <typename Graph>
 …
+  }
+  /// \brief Return a \ref GraphReader class
+  ///
+  /// This function just returns a \ref GraphReader class.
   /// \relates GraphReader
   template <typename Graph>
 …
   SectionReader sectionReader(const char* fn);
+  /// \ingroup lemon_io
+  ///
   /// \brief Section reader class
   ///
   /// In the \e LGF file extra sections can be placed, which contain
   /// any data in arbitrary format. Such sections can be read with
   /// this class. A reading rule can be added with two different
   /// functions, with the \c sectionLines() function a functor can
   /// process the section line-by-line. While with the \c
+  /// In the \ref lgf-format "LGF" file extra sections can be placed,
+  /// which contain any data in arbitrary format. Such sections can be
+  /// read with this class. A reading rule can be added to the class
+  /// with two different functions. With the \c sectionLines() function a
+  /// functor can process the section line-by-line, while with the \c
   /// sectionStream() member the section can be read from an input
   /// stream.
 …
     ///\endcode
     ///
     /// The functor is implemented as an struct:
+    /// The functor is implemented as a struct:
     ///\code
     ///  struct NumberSection {
 …
     template <typename Functor>
     SectionReader& sectionLines(const std::string& type, Functor functor) {
       LEMON_ASSERT(!type.empty(), "Type is not empty.");
+      LEMON_ASSERT(!type.empty(), "Type is empty.");
       LEMON_ASSERT(_sections.find(type) == _sections.end(),
                    "Multiple reading of section.");
 …
     ///
     /// The first parameter is the type of the section, the second is
     /// a functor, which takes an \c std::istream& and an int&
+    /// a functor, which takes an \c std::istream& and an \c int&
     /// parameter, the latter regard to the line number of stream. The
     /// functor can read the input while the section go on, and the
 …
     template <typename Functor>
     SectionReader& sectionStream(const std::string& type, Functor functor) {
       LEMON_ASSERT(!type.empty(), "Type is not empty.");
+      LEMON_ASSERT(!type.empty(), "Type is empty.");
       LEMON_ASSERT(_sections.find(type) == _sections.end(),
                    "Multiple reading of section.");
 …
     /// \brief Start the batch processing
     ///
     /// This function starts the batch processing
+    /// This function starts the batch processing.
     void run() {
 …
   };
+  /// \brief Return a \ref SectionReader class
+  ///
+  /// This function just returns a \ref SectionReader class.
   /// \relates SectionReader
   inline SectionReader sectionReader(std::istream& is) {
 …
+  }
+  /// \brief Return a \ref SectionReader class
+  ///
+  /// This function just returns a \ref SectionReader class.
   /// \relates SectionReader
   inline SectionReader sectionReader(const std::string& fn) {
 …
+  }
+  /// \brief Return a \ref SectionReader class
+  ///
+  /// This function just returns a \ref SectionReader class.
   /// \relates SectionReader
   inline SectionReader sectionReader(const char* fn) {
 …
   /// reading the graph.
   ///
+  ///\code LgfContents contents("graph.lgf");
+  ///\code
+  /// LgfContents contents("graph.lgf");
   /// contents.run();
   ///
   /// // does it contain any node section and arc section
+  /// // Does it contain any node section and arc section?
   /// if (contents.nodeSectionNum() == 0 || contents.arcSectionNum()) {
   ///   std::cerr << "Failure, cannot find graph" << std::endl;
+  ///   std::cerr << "Failure, cannot find graph." << std::endl;
   ///   return -1;
   /// }
   /// std::cout << "The name of the default node section : "
+  /// std::cout << "The name of the default node section: "
   ///           << contents.nodeSection(0) << std::endl;
   /// std::cout << "The number of the arc maps : "
+  /// std::cout << "The number of the arc maps: "
   ///           << contents.arcMaps(0).size() << std::endl;
   /// std::cout << "The name of second arc map : "
+  /// std::cout << "The name of second arc map: "
   ///           << contents.arcMaps(0)[1] << std::endl;
   ///\endcode
 …
+    }
     /// \brief Returns the section name at the given position.
     ///
     /// Returns the section name at the given position.
+    /// \brief Returns the node section name at the given position.
+    ///
+    /// Returns the node section name at the given position.
     const std::string& nodeSection(int i) const {
       return _node_sections[i];
 …
+    }
     /// \brief Returns the section name at the given position.
     ///
     /// Returns the section name at the given position.
+    /// \brief Returns the arc/edge section name at the given position.
+    ///
+    /// Returns the arc/edge section name at the given position.
     /// \note It is synonym of \c edgeSection().
     const std::string& arcSection(int i) const {
 …
+    }
     /// \brief Returns the section name at the given position.
     ///
     /// Returns the section name at the given position.
+    /// \brief Returns the attribute section name at the given position.
+    ///
+    /// Returns the attribute section name at the given position.
     const std::string& attributeSectionNames(int i) const {
       return _attribute_sections[i];
 …
     /// @{
     /// \brief Start the reading
     ///
     /// This function starts the reading
+    /// \brief Starts the reading
+    ///
+    /// This function starts the reading.
     void run() {

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changes in lemon/lgf_reader.h [190:1e6af6f0843c:201:9757e3d9bfeb] in lemon-1.2

Legend:

lemon/lgf_reader.h

Download in other formats: