1.1 --- a/lemon/graph_writer.h	Thu Feb 02 17:09:09 2006 +0000
     1.2 +++ b/lemon/graph_writer.h	Thu Feb 02 17:43:24 2006 +0000
     1.3 @@ -47,9 +47,9 @@
     1.4    /// write commands as \c NodeMap or \c EdgeMap writing and labeled Node and
     1.5    /// Edge writing.
     1.6    ///
     1.7 -  /// \code
     1.8 +  ///\code
     1.9    /// GraphWriter<ListGraph> writer(std::cout, graph);
    1.10 -  /// \endcode
    1.11 +  ///\endcode
    1.12    ///
    1.13    /// The \c writeNodeMap() function declares a \c NodeMap writing 
    1.14    /// command in the \c GraphWriter. You should give as parameter 
    1.15 @@ -57,43 +57,43 @@
    1.16    /// command with name "label" should write a unique map because it 
    1.17    /// is regarded as label map (such a map is essential if the graph has edges).
    1.18    ///
    1.19 -  /// \code
    1.20 +  ///\code
    1.21    /// IdMap<ListGraph, Node> nodeLabelMap;
    1.22    /// writer.writeNodeMap("label", nodeLabelMap);
    1.23    ///
    1.24    /// writer.writeNodeMap("coords", coords);
    1.25    /// writer.writeNodeMap("color", colorMap);
    1.26 -  /// \endcode
    1.27 +  ///\endcode
    1.28    ///
    1.29    /// With the \c writeEdgeMap() member function you can give an edge map
    1.30    /// writing command similar to the NodeMaps.
    1.31    ///
    1.32 -  /// \code
    1.33 +  ///\code
    1.34    /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 
    1.35    ///   edgeDescMap(graph);
    1.36    /// writer.writeEdgeMap("descriptor", edgeDescMap);
    1.37    ///
    1.38    /// writer.writeEdgeMap("weight", weightMap);
    1.39    /// writer.writeEdgeMap("label", labelMap);
    1.40 -  /// \endcode
    1.41 +  ///\endcode
    1.42    ///
    1.43    /// With \c writeNode() and \c writeEdge() functions you can 
    1.44    /// point out Nodes and Edges in the graph. For example, you can 
    1.45    /// write out the source and target of a maximum flow instance.
    1.46    ///
    1.47 -  /// \code
    1.48 +  ///\code
    1.49    /// writer.writeNode("source", sourceNode);
    1.50    /// writer.writeNode("target", targetNode);
    1.51    ///
    1.52    /// writer.writeEdge("observed", edge);
    1.53 -  /// \endcode
    1.54 +  ///\endcode
    1.55    ///
    1.56    /// After you give all write commands you must call the \c run() member
    1.57    /// function, which executes all the writing commands.
    1.58    ///
    1.59 -  /// \code
    1.60 +  ///\code
    1.61    /// writer.run();
    1.62 -  /// \endcode
    1.63 +  ///\endcode
    1.64    ///
    1.65    /// \see DefaultWriterTraits
    1.66    /// \see QuotedStringWriter
    1.67 @@ -320,9 +320,9 @@
    1.68    /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap 
    1.69    /// writing and labeled Node, Edge or UEdge writing.
    1.70    ///
    1.71 -  /// \code
    1.72 +  ///\code
    1.73    /// UGraphWriter<ListUGraph> writer(std::cout, graph);
    1.74 -  /// \endcode
    1.75 +  ///\endcode
    1.76    ///
    1.77    /// The \c writeNodeMap() function declares a \c NodeMap writing 
    1.78    /// command in the \c UGraphWriter. You should give as parameter 
    1.79 @@ -330,51 +330,51 @@
    1.80    /// command with name "label" should write a unique map because it 
    1.81    /// is regarded as label map.
    1.82    ///
    1.83 -  /// \code
    1.84 +  ///\code
    1.85    /// IdMap<ListUGraph, Node> nodeLabelMap;
    1.86    /// writer.writeNodeMap("label", nodeLabelMap);
    1.87    ///
    1.88    /// writer.writeNodeMap("coords", coords);
    1.89    /// writer.writeNodeMap("color", colorMap);
    1.90 -  /// \endcode
    1.91 +  ///\endcode
    1.92    ///
    1.93    /// With the \c writeUEdgeMap() member function you can give an 
    1.94    /// undirected edge map writing command similar to the NodeMaps.
    1.95    ///
    1.96 -  /// \code
    1.97 +  ///\code
    1.98    /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 
    1.99    ///   edgeDescMap(graph);
   1.100    /// writer.writeUEdgeMap("descriptor", edgeDescMap);
   1.101    ///
   1.102    /// writer.writeUEdgeMap("weight", weightMap);
   1.103    /// writer.writeUEdgeMap("label", labelMap);
   1.104 -  /// \endcode
   1.105 +  ///\endcode
   1.106    /// 
   1.107    /// The EdgeMap handling is just a syntactical sugar. It writes
   1.108    /// two undirected edge map with '+' and '-' prefix in the name.
   1.109    ///
   1.110 -  /// \code
   1.111 +  ///\code
   1.112    /// writer.writeEdgeMap("capacity", capacityMap);
   1.113 -  /// \endcode
   1.114 +  ///\endcode
   1.115    ///
   1.116    ///
   1.117    /// With \c writeNode() and \c writeUEdge() functions you can 
   1.118    /// designate nodes and undirected edges in the graph. For example, you can 
   1.119    /// write out the source and target of the graph.
   1.120    ///
   1.121 -  /// \code
   1.122 +  ///\code
   1.123    /// writer.writeNode("source", sourceNode);
   1.124    /// writer.writeNode("target", targetNode);
   1.125    ///
   1.126    /// writer.writeUEdge("observed", uEdge);
   1.127 -  /// \endcode
   1.128 +  ///\endcode
   1.129    ///
   1.130    /// After you give all write commands you must call the \c run() member
   1.131    /// function, which executes all the writing commands.
   1.132    ///
   1.133 -  /// \code
   1.134 +  ///\code
   1.135    /// writer.run();
   1.136 -  /// \endcode
   1.137 +  ///\endcode
   1.138    ///
   1.139    /// \see DefaultWriterTraits
   1.140    /// \see QuotedStringWriter