lemon-1.2: comparison lemon/adaptors.h

equal deleted inserted replaced

-:a4d574cf91de
+:7e36fe9eb75e
 ///
 /// ReverseDigraph can be used for reversing the arcs in a digraph.
 /// It conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
 /// The adapted digraph can also be modified through this adaptor
-/// by adding or removing nodes or arcs, unless the \c _Digraph template
+/// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Digraph The type of the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It can also be specified to be \c const.
 ///
 /// \note The \c Node and \c Arc types of this adaptor and the adapted
 /// digraph are convertible to each other.
-template<typename _Digraph>
+template<typename GR>
+#ifdef DOXYGEN
+class ReverseDigraph {
+#else
 class ReverseDigraph :
-public DigraphAdaptorExtender<ReverseDigraphBase<_Digraph> > {
+public DigraphAdaptorExtender<ReverseDigraphBase<GR> > {
-public:
+#endif
-typedef _Digraph Digraph;
+public:
-typedef DigraphAdaptorExtender<
+/// The type of the adapted digraph.
-ReverseDigraphBase<_Digraph> > Parent;
+typedef GR Digraph;
+typedef DigraphAdaptorExtender<ReverseDigraphBase<GR> > Parent;
 protected:
 ReverseDigraph() { }
 public:
 /// \brief Constructor
 /// \brief Returns a read-only ReverseDigraph adaptor
 ///
 /// This function just returns a read-only \ref ReverseDigraph adaptor.
 /// \ingroup graph_adaptors
 /// \relates ReverseDigraph
-template<typename Digraph>
+template<typename GR>
-ReverseDigraph<const Digraph> reverseDigraph(const Digraph& digraph) {
+ReverseDigraph<const GR> reverseDigraph(const GR& digraph) {
-return ReverseDigraph<const Digraph>(digraph);
+return ReverseDigraph<const GR>(digraph);
 }
 template <typename _Digraph, typename _NodeFilterMap,
 typename _ArcFilterMap, bool _checked = true>
 ///
 /// SubDigraph can be used for hiding nodes and arcs in a digraph.
 /// A \c bool node map and a \c bool arc map must be specified, which
 /// define the filters for nodes and arcs.
 /// Only the nodes and arcs with \c true filter value are
-/// shown in the subdigraph. This adaptor conforms to the \ref
+/// shown in the subdigraph. The arcs that are incident to hidden
-/// concepts::Digraph "Digraph" concept. If the \c _checked parameter
+/// nodes are also filtered out.
-/// is \c true, then the arcs incident to hidden nodes are also
+/// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept.
-/// filtered out.
 ///
 /// The adapted digraph can also be modified through this adaptor
-/// by adding or removing nodes or arcs, unless the \c _Digraph template
+/// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Digraph The type of the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It can also be specified to be \c const.
-/// \tparam _NodeFilterMap A \c bool (or convertible) node map of the
+/// \tparam NF The type of the node filter map.
-/// adapted digraph. The default map type is
+/// It must be a \c bool (or convertible) node map of the
-/// \ref concepts::Digraph::NodeMap "_Digraph::NodeMap<bool>".
+/// adapted digraph. The default type is
-/// \tparam _ArcFilterMap A \c bool (or convertible) arc map of the
+/// \ref concepts::Digraph::NodeMap "GR::NodeMap<bool>".
-/// adapted digraph. The default map type is
+/// \tparam AF The type of the arc filter map.
-/// \ref concepts::Digraph::ArcMap "_Digraph::ArcMap<bool>".
+/// It must be \c bool (or convertible) arc map of the
-/// \tparam _checked If this parameter is set to \c false, then the arc
+/// adapted digraph. The default type is
-/// filtering is not checked with respect to the node filter.
+/// \ref concepts::Digraph::ArcMap "GR::ArcMap<bool>".
-/// Otherwise, each arc that is incident to a hidden node is automatically
-/// filtered out. This is the default option.
 ///
 /// \note The \c Node and \c Arc types of this adaptor and the adapted
 /// digraph are convertible to each other.
 ///
 /// \see FilterNodes
 /// \see FilterArcs
 #ifdef DOXYGEN
-template<typename _Digraph,
+template<typename GR, typename NF, typename AF>
-typename _NodeFilterMap,
+class SubDigraph {
-typename _ArcFilterMap,
-bool _checked>
 #else
-template<typename _Digraph,
+template<typename GR,
-typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+typename NF = typename GR::template NodeMap<bool>,
-typename _ArcFilterMap = typename _Digraph::template ArcMap<bool>,
+typename AF = typename GR::template ArcMap<bool> >
-bool _checked = true>
+class SubDigraph :
+public DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> > {
 #endif
-class SubDigraph
-: public DigraphAdaptorExtender<
-SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, _checked> > {
 public:
 /// The type of the adapted digraph.
-typedef _Digraph Digraph;
+typedef GR Digraph;
 /// The type of the node filter map.
-typedef _NodeFilterMap NodeFilterMap;
+typedef NF NodeFilterMap;
 /// The type of the arc filter map.
-typedef _ArcFilterMap ArcFilterMap;
+typedef AF ArcFilterMap;
-typedef DigraphAdaptorExtender<
+typedef DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> >
-SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, _checked> >
+Parent;
-Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 protected:
 /// \brief Returns a read-only SubDigraph adaptor
 ///
 /// This function just returns a read-only \ref SubDigraph adaptor.
 /// \ingroup graph_adaptors
 /// \relates SubDigraph
-template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename AF>
-SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>
+SubDigraph<const GR, NF, AF>
-subDigraph(const Digraph& digraph, NodeFilterMap& nfm, ArcFilterMap& afm) {
+subDigraph(const GR& digraph,
-return SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>
+NF& node_filter_map, AF& arc_filter_map) {
-(digraph, nfm, afm);
+return SubDigraph<const GR, NF, AF>
+(digraph, node_filter_map, arc_filter_map);
 }
-template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename AF>
-SubDigraph<const Digraph, const NodeFilterMap, ArcFilterMap>
+SubDigraph<const GR, const NF, AF>
-subDigraph(const Digraph& digraph,
+subDigraph(const GR& digraph,
-const NodeFilterMap& nfm, ArcFilterMap& afm) {
+const NF& node_filter_map, AF& arc_filter_map) {
-return SubDigraph<const Digraph, const NodeFilterMap, ArcFilterMap>
+return SubDigraph<const GR, const NF, AF>
-(digraph, nfm, afm);
+(digraph, node_filter_map, arc_filter_map);
 }
-template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename AF>
-SubDigraph<const Digraph, NodeFilterMap, const ArcFilterMap>
+SubDigraph<const GR, NF, const AF>
-subDigraph(const Digraph& digraph,
+subDigraph(const GR& digraph,
-NodeFilterMap& nfm, const ArcFilterMap& afm) {
+NF& node_filter_map, const AF& arc_filter_map) {
-return SubDigraph<const Digraph, NodeFilterMap, const ArcFilterMap>
+return SubDigraph<const GR, NF, const AF>
-(digraph, nfm, afm);
+(digraph, node_filter_map, arc_filter_map);
 }
-template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename AF>
-SubDigraph<const Digraph, const NodeFilterMap, const ArcFilterMap>
+SubDigraph<const GR, const NF, const AF>
-subDigraph(const Digraph& digraph,
+subDigraph(const GR& digraph,
-const NodeFilterMap& nfm, const ArcFilterMap& afm) {
+const NF& node_filter_map, const AF& arc_filter_map) {
-return SubDigraph<const Digraph, const NodeFilterMap,
+return SubDigraph<const GR, const NF, const AF>
-const ArcFilterMap>(digraph, nfm, afm);
+(digraph, node_filter_map, arc_filter_map);
 }
 template <typename _Graph, typename _NodeFilterMap,
 typename _EdgeFilterMap, bool _checked = true>
 ///
 /// SubGraph can be used for hiding nodes and edges in a graph.
 /// A \c bool node map and a \c bool edge map must be specified, which
 /// define the filters for nodes and edges.
 /// Only the nodes and edges with \c true filter value are
-/// shown in the subgraph. This adaptor conforms to the \ref
+/// shown in the subgraph. The edges that are incident to hidden
-/// concepts::Graph "Graph" concept. If the \c _checked parameter is
+/// nodes are also filtered out.
-/// \c true, then the edges incident to hidden nodes are also
+/// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
-/// filtered out.
 ///
 /// The adapted graph can also be modified through this adaptor
-/// by adding or removing nodes or edges, unless the \c _Graph template
+/// by adding or removing nodes or edges, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Graph The type of the adapted graph.
+/// \tparam GR The type of the adapted graph.
 /// It must conform to the \ref concepts::Graph "Graph" concept.
 /// It can also be specified to be \c const.
-/// \tparam _NodeFilterMap A \c bool (or convertible) node map of the
+/// \tparam NF The type of the node filter map.
-/// adapted graph. The default map type is
+/// It must be a \c bool (or convertible) node map of the
-/// \ref concepts::Graph::NodeMap "_Graph::NodeMap<bool>".
+/// adapted graph. The default type is
-/// \tparam _EdgeFilterMap A \c bool (or convertible) edge map of the
+/// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
-/// adapted graph. The default map type is
+/// \tparam EF The type of the edge filter map.
-/// \ref concepts::Graph::EdgeMap "_Graph::EdgeMap<bool>".
+/// It must be a \c bool (or convertible) edge map of the
-/// \tparam _checked If this parameter is set to \c false, then the edge
+/// adapted graph. The default type is
-/// filtering is not checked with respect to the node filter.
+/// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
-/// Otherwise, each edge that is incident to a hidden node is automatically
-/// filtered out. This is the default option.
 ///
 /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
 /// adapted graph are convertible to each other.
 ///
 /// \see FilterNodes
 /// \see FilterEdges
 #ifdef DOXYGEN
-template<typename _Graph,
+template<typename GR, typename NF, typename EF>
-typename _NodeFilterMap,
+class SubGraph {
-typename _EdgeFilterMap,
-bool _checked>
 #else
-template<typename _Graph,
+template<typename GR,
-typename _NodeFilterMap = typename _Graph::template NodeMap<bool>,
+typename NF = typename GR::template NodeMap<bool>,
-typename _EdgeFilterMap = typename _Graph::template EdgeMap<bool>,
+typename EF = typename GR::template EdgeMap<bool> >
-bool _checked = true>
+class SubGraph :
+public GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > {
 #endif
-class SubGraph
-: public GraphAdaptorExtender<
-SubGraphBase<_Graph, _NodeFilterMap, _EdgeFilterMap, _checked> > {
 public:
 /// The type of the adapted graph.
-typedef _Graph Graph;
+typedef GR Graph;
 /// The type of the node filter map.
-typedef _NodeFilterMap NodeFilterMap;
+typedef NF NodeFilterMap;
 /// The type of the edge filter map.
-typedef _EdgeFilterMap EdgeFilterMap;
+typedef EF EdgeFilterMap;
-typedef GraphAdaptorExtender<
+typedef GraphAdaptorExtender< SubGraphBase<GR, NF, EF, true> >
-SubGraphBase<_Graph, _NodeFilterMap, _EdgeFilterMap, _checked> > Parent;
+Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Edge Edge;
 protected:
 /// \brief Returns a read-only SubGraph adaptor
 ///
 /// This function just returns a read-only \ref SubGraph adaptor.
 /// \ingroup graph_adaptors
 /// \relates SubGraph
-template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename EF>
-SubGraph<const Graph, NodeFilterMap, ArcFilterMap>
+SubGraph<const GR, NF, EF>
-subGraph(const Graph& graph, NodeFilterMap& nfm, ArcFilterMap& efm) {
+subGraph(const GR& graph,
-return SubGraph<const Graph, NodeFilterMap, ArcFilterMap>(graph, nfm, efm);
+NF& node_filter_map, EF& edge_filter_map) {
+return SubGraph<const GR, NF, EF>
+(graph, node_filter_map, edge_filter_map);
 }
-template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename EF>
-SubGraph<const Graph, const NodeFilterMap, ArcFilterMap>
+SubGraph<const GR, const NF, EF>
-subGraph(const Graph& graph,
+subGraph(const GR& graph,
-const NodeFilterMap& nfm, ArcFilterMap& efm) {
+const NF& node_filter_map, EF& edge_filter_map) {
-return SubGraph<const Graph, const NodeFilterMap, ArcFilterMap>
+return SubGraph<const GR, const NF, EF>
-(graph, nfm, efm);
+(graph, node_filter_map, edge_filter_map);
 }
-template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename EF>
-SubGraph<const Graph, NodeFilterMap, const ArcFilterMap>
+SubGraph<const GR, NF, const EF>
-subGraph(const Graph& graph,
+subGraph(const GR& graph,
-NodeFilterMap& nfm, const ArcFilterMap& efm) {
+NF& node_filter_map, const EF& edge_filter_map) {
-return SubGraph<const Graph, NodeFilterMap, const ArcFilterMap>
+return SubGraph<const GR, NF, const EF>
-(graph, nfm, efm);
+(graph, node_filter_map, edge_filter_map);
 }
-template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
+template<typename GR, typename NF, typename EF>
-SubGraph<const Graph, const NodeFilterMap, const ArcFilterMap>
+SubGraph<const GR, const NF, const EF>
-subGraph(const Graph& graph,
+subGraph(const GR& graph,
-const NodeFilterMap& nfm, const ArcFilterMap& efm) {
+const NF& node_filter_map, const EF& edge_filter_map) {
-return SubGraph<const Graph, const NodeFilterMap, const ArcFilterMap>
+return SubGraph<const GR, const NF, const EF>
-(graph, nfm, efm);
+(graph, node_filter_map, edge_filter_map);
 }
 /// \ingroup graph_adaptors
 ///
 /// graph. A \c bool node map must be specified, which defines the filter
 /// for the nodes. Only the nodes with \c true filter value and the
 /// arcs/edges incident to nodes both with \c true filter value are shown
 /// in the subgraph. This adaptor conforms to the \ref concepts::Digraph
 /// "Digraph" concept or the \ref concepts::Graph "Graph" concept
-/// depending on the \c _Graph template parameter.
+/// depending on the \c GR template parameter.
 ///
 /// The adapted (di)graph can also be modified through this adaptor
-/// by adding or removing nodes or arcs/edges, unless the \c _Graph template
+/// by adding or removing nodes or arcs/edges, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Graph The type of the adapted digraph or graph.
+/// \tparam GR The type of the adapted digraph or graph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept
 /// or the \ref concepts::Graph "Graph" concept.
 /// It can also be specified to be \c const.
-/// \tparam _NodeFilterMap A \c bool (or convertible) node map of the
+/// \tparam NF The type of the node filter map.
-/// adapted (di)graph. The default map type is
+/// It must be a \c bool (or convertible) node map of the
-/// \ref concepts::Graph::NodeMap "_Graph::NodeMap<bool>".
+/// adapted (di)graph. The default type is
-/// \tparam _checked If this parameter is set to \c false then the arc/edge
+/// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
-/// filtering is not checked with respect to the node filter. In this
-/// case only isolated nodes can be filtered out from the graph.
-/// Otherwise, each arc/edge that is incident to a hidden node is
-/// automatically filtered out. This is the default option.
 ///
 /// \note The \c Node and <tt>Arc/Edge</tt> types of this adaptor and the
 /// adapted (di)graph are convertible to each other.
 #ifdef DOXYGEN
-template<typename _Graph,
+template<typename GR, typename NF>
-typename _NodeFilterMap,
+class FilterNodes {
-bool _checked>
 #else
-template<typename _Digraph,
+template<typename GR,
-typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+typename NF = typename GR::template NodeMap<bool>,
-bool _checked = true,
 typename Enable = void>
+class FilterNodes :
+public DigraphAdaptorExtender<
+SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, bool>, true> > {
 #endif
-class FilterNodes
+public:
-: public SubDigraph<_Digraph, _NodeFilterMap,
-ConstMap<typename _Digraph::Arc, bool>, _checked> {
+typedef GR Digraph;
-public:
+typedef NF NodeFilterMap;
-typedef _Digraph Digraph;
+typedef DigraphAdaptorExtender<
-typedef _NodeFilterMap NodeFilterMap;
+SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, bool>, true> >
+Parent;
-typedef SubDigraph<Digraph, NodeFilterMap,
-ConstMap<typename Digraph::Arc, bool>, _checked>
-Parent;
 typedef typename Parent::Node Node;
 protected:
 ConstMap<typename Digraph::Arc, bool> const_true_map;
 /// \brief Constructor
 ///
 /// Creates a subgraph for the given digraph or graph with the
 /// given node filter map.
-#ifdef DOXYGEN
+FilterNodes(GR& graph, NodeFilterMap& node_filter) :
-FilterNodes(_Graph& graph, _NodeFilterMap& node_filter) :
+Parent(), const_true_map(true)
-#else
+{
-FilterNodes(Digraph& graph, NodeFilterMap& node_filter) :
-#endif
-Parent(), const_true_map(true) {
 Parent::setDigraph(graph);
 Parent::setNodeFilterMap(node_filter);
 Parent::setArcFilterMap(const_true_map);
 }
 /// It is the same as \ref status() "status(n, true)".
 void enable(const Node& n) const { Parent::status(n, true); }
 };
-template<typename _Graph, typename _NodeFilterMap, bool _checked>
+template<typename GR, typename NF>
-class FilterNodes<_Graph, _NodeFilterMap, _checked,
+class FilterNodes<GR, NF,
-typename enable_if<UndirectedTagIndicator<_Graph> >::type>
+typename enable_if<UndirectedTagIndicator<GR> >::type> :
-: public SubGraph<_Graph, _NodeFilterMap,
+public GraphAdaptorExtender<
-ConstMap<typename _Graph::Edge, bool>, _checked> {
+SubGraphBase<GR, NF, ConstMap<typename GR::Edge, bool>, true> > {
-public:
-typedef _Graph Graph;
+public:
-typedef _NodeFilterMap NodeFilterMap;
+typedef GR Graph;
-typedef SubGraph<Graph, NodeFilterMap,
+typedef NF NodeFilterMap;
-ConstMap<typename Graph::Edge, bool> > Parent;
+typedef GraphAdaptorExtender<
+SubGraphBase<GR, NF, ConstMap<typename GR::Edge, bool>, true> >
+Parent;
 typedef typename Parent::Node Node;
 protected:
 ConstMap<typename Graph::Edge, bool> const_true_map;
 /// \brief Returns a read-only FilterNodes adaptor
 ///
 /// This function just returns a read-only \ref FilterNodes adaptor.
 /// \ingroup graph_adaptors
 /// \relates FilterNodes
-template<typename Digraph, typename NodeFilterMap>
+template<typename GR, typename NF>
-FilterNodes<const Digraph, NodeFilterMap>
+FilterNodes<const GR, NF>
-filterNodes(const Digraph& digraph, NodeFilterMap& nfm) {
+filterNodes(const GR& graph, NF& node_filter_map) {
-return FilterNodes<const Digraph, NodeFilterMap>(digraph, nfm);
+return FilterNodes<const GR, NF>(graph, node_filter_map);
 }
-template<typename Digraph, typename NodeFilterMap>
+template<typename GR, typename NF>
-FilterNodes<const Digraph, const NodeFilterMap>
+FilterNodes<const GR, const NF>
-filterNodes(const Digraph& digraph, const NodeFilterMap& nfm) {
+filterNodes(const GR& graph, const NF& node_filter_map) {
-return FilterNodes<const Digraph, const NodeFilterMap>(digraph, nfm);
+return FilterNodes<const GR, const NF>(graph, node_filter_map);
 }
 /// \ingroup graph_adaptors
 ///
 /// \brief Adaptor class for hiding arcs in a digraph.
 /// the arcs. Only the arcs with \c true filter value are shown in the
 /// subdigraph. This adaptor conforms to the \ref concepts::Digraph
 /// "Digraph" concept.
 ///
 /// The adapted digraph can also be modified through this adaptor
-/// by adding or removing nodes or arcs, unless the \c _Digraph template
+/// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Digraph The type of the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It can also be specified to be \c const.
-/// \tparam _ArcFilterMap A \c bool (or convertible) arc map of the
+/// \tparam AF The type of the arc filter map.
-/// adapted digraph. The default map type is
+/// It must be a \c bool (or convertible) arc map of the
-/// \ref concepts::Digraph::ArcMap "_Digraph::ArcMap<bool>".
+/// adapted digraph. The default type is
+/// \ref concepts::Digraph::ArcMap "GR::ArcMap<bool>".
 ///
 /// \note The \c Node and \c Arc types of this adaptor and the adapted
 /// digraph are convertible to each other.
 #ifdef DOXYGEN
-template<typename _Digraph,
+template<typename GR,
-typename _ArcFilterMap>
+typename AF>
+class FilterArcs {
 #else
-template<typename _Digraph,
+template<typename GR,
-typename _ArcFilterMap = typename _Digraph::template ArcMap<bool> >
+typename AF = typename GR::template ArcMap<bool> >
+class FilterArcs :
+public DigraphAdaptorExtender<
+SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> > {
 #endif
-class FilterArcs :
+public:
-public SubDigraph<_Digraph, ConstMap<typename _Digraph::Node, bool>,
+/// The type of the adapted digraph.
-_ArcFilterMap, false> {
+typedef GR Digraph;
-public:
+/// The type of the arc filter map.
+typedef AF ArcFilterMap;
-typedef _Digraph Digraph;
-typedef _ArcFilterMap ArcFilterMap;
+typedef DigraphAdaptorExtender<
+SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> >
-typedef SubDigraph<Digraph, ConstMap<typename Digraph::Node, bool>,
+Parent;
-ArcFilterMap, false> Parent;
 typedef typename Parent::Arc Arc;
 protected:
 ConstMap<typename Digraph::Node, bool> const_true_map;
 /// \brief Returns a read-only FilterArcs adaptor
 ///
 /// This function just returns a read-only \ref FilterArcs adaptor.
 /// \ingroup graph_adaptors
 /// \relates FilterArcs
-template<typename Digraph, typename ArcFilterMap>
+template<typename GR, typename AF>
-FilterArcs<const Digraph, ArcFilterMap>
+FilterArcs<const GR, AF>
-filterArcs(const Digraph& digraph, ArcFilterMap& afm) {
+filterArcs(const GR& digraph, AF& arc_filter_map) {
-return FilterArcs<const Digraph, ArcFilterMap>(digraph, afm);
+return FilterArcs<const GR, AF>(digraph, arc_filter_map);
 }
-template<typename Digraph, typename ArcFilterMap>
+template<typename GR, typename AF>
-FilterArcs<const Digraph, const ArcFilterMap>
+FilterArcs<const GR, const AF>
-filterArcs(const Digraph& digraph, const ArcFilterMap& afm) {
+filterArcs(const GR& digraph, const AF& arc_filter_map) {
-return FilterArcs<const Digraph, const ArcFilterMap>(digraph, afm);
+return FilterArcs<const GR, const AF>(digraph, arc_filter_map);
 }
 /// \ingroup graph_adaptors
 ///
 /// \brief Adaptor class for hiding edges in a graph.
 /// the edges. Only the edges with \c true filter value are shown in the
 /// subgraph. This adaptor conforms to the \ref concepts::Graph
 /// "Graph" concept.
 ///
 /// The adapted graph can also be modified through this adaptor
-/// by adding or removing nodes or edges, unless the \c _Graph template
+/// by adding or removing nodes or edges, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Graph The type of the adapted graph.
+/// \tparam GR The type of the adapted graph.
 /// It must conform to the \ref concepts::Graph "Graph" concept.
 /// It can also be specified to be \c const.
-/// \tparam _EdgeFilterMap A \c bool (or convertible) edge map of the
+/// \tparam EF The type of the edge filter map.
-/// adapted graph. The default map type is
+/// It must be a \c bool (or convertible) edge map of the
-/// \ref concepts::Graph::EdgeMap "_Graph::EdgeMap<bool>".
+/// adapted graph. The default type is
+/// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
 ///
 /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
 /// adapted graph are convertible to each other.
 #ifdef DOXYGEN
-template<typename _Graph,
+template<typename GR,
-typename _EdgeFilterMap>
+typename EF>
+class FilterEdges {
 #else
-template<typename _Graph,
+template<typename GR,
-typename _EdgeFilterMap = typename _Graph::template EdgeMap<bool> >
+typename EF = typename GR::template EdgeMap<bool> >
+class FilterEdges :
+public GraphAdaptorExtender<
+SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> > {
 #endif
-class FilterEdges :
+public:
-public SubGraph<_Graph, ConstMap<typename _Graph::Node,bool>,
+/// The type of the adapted graph.
-_EdgeFilterMap, false> {
+typedef GR Graph;
-public:
+/// The type of the edge filter map.
-typedef _Graph Graph;
+typedef EF EdgeFilterMap;
-typedef _EdgeFilterMap EdgeFilterMap;
-typedef SubGraph<Graph, ConstMap<typename Graph::Node,bool>,
+typedef GraphAdaptorExtender<
-EdgeFilterMap, false> Parent;
+SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> >
+Parent;
 typedef typename Parent::Edge Edge;
 protected:
 ConstMap<typename Graph::Node, bool> const_true_map;
 FilterEdges() : const_true_map(true) {
 Parent::setNodeFilterMap(const_true_map);
 /// \brief Returns a read-only FilterEdges adaptor
 ///
 /// This function just returns a read-only \ref FilterEdges adaptor.
 /// \ingroup graph_adaptors
 /// \relates FilterEdges
-template<typename Graph, typename EdgeFilterMap>
+template<typename GR, typename EF>
-FilterEdges<const Graph, EdgeFilterMap>
+FilterEdges<const GR, EF>
-filterEdges(const Graph& graph, EdgeFilterMap& efm) {
+filterEdges(const GR& graph, EF& edge_filter_map) {
-return FilterEdges<const Graph, EdgeFilterMap>(graph, efm);
+return FilterEdges<const GR, EF>(graph, edge_filter_map);
 }
-template<typename Graph, typename EdgeFilterMap>
+template<typename GR, typename EF>
-FilterEdges<const Graph, const EdgeFilterMap>
+FilterEdges<const GR, const EF>
-filterEdges(const Graph& graph, const EdgeFilterMap& efm) {
+filterEdges(const GR& graph, const EF& edge_filter_map) {
-return FilterEdges<const Graph, const EdgeFilterMap>(graph, efm);
+return FilterEdges<const GR, const EF>(graph, edge_filter_map);
 }
 template <typename _Digraph>
 class UndirectorBase {
 /// graph. All arcs of the underlying digraph are showed in the
 /// adaptor as an edge (and also as a pair of arcs, of course).
 /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
 ///
 /// The adapted digraph can also be modified through this adaptor
-/// by adding or removing nodes or edges, unless the \c _Digraph template
+/// by adding or removing nodes or edges, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Digraph The type of the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It can also be specified to be \c const.
 ///
 /// \note The \c Node type of this adaptor and the adapted digraph are
 /// convertible to each other, moreover the \c Edge type of the adaptor
 /// and the \c Arc type of the adapted digraph are also convertible to
 /// each other.
 /// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type
 /// of the adapted digraph.)
-template<typename _Digraph>
+template<typename GR>
-class Undirector
+#ifdef DOXYGEN
-: public GraphAdaptorExtender<UndirectorBase<_Digraph> > {
+class Undirector {
-public:
+#else
-typedef _Digraph Digraph;
+class Undirector :
-typedef GraphAdaptorExtender<UndirectorBase<Digraph> > Parent;
+public GraphAdaptorExtender<UndirectorBase<GR> > {
+#endif
+public:
+/// The type of the adapted digraph.
+typedef GR Digraph;
+typedef GraphAdaptorExtender<UndirectorBase<GR> > Parent;
 protected:
 Undirector() { }
 public:
 /// \brief Constructor
 ///
 /// Creates an undirected graph from the given digraph.
-Undirector(_Digraph& digraph) {
+Undirector(Digraph& digraph) {
 setDigraph(digraph);
 }
 /// \brief Arc map combined from two original arc maps
 ///
 /// This map adaptor class adapts two arc maps of the underlying
 /// digraph to get an arc map of the undirected graph.
 /// Its value type is inherited from the first arc map type
 /// (\c %ForwardMap).
-template <typename _ForwardMap, typename _BackwardMap>
+template <typename ForwardMap, typename BackwardMap>
 class CombinedArcMap {
 public:
-typedef _ForwardMap ForwardMap;
-typedef _BackwardMap BackwardMap;
-typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag;
 /// The key type of the map
 typedef typename Parent::Arc Key;
 /// The value type of the map
 typedef typename ForwardMap::Value Value;
+typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag;
 typedef typename MapTraits<ForwardMap>::ReturnValue ReturnValue;
 typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReturnValue;
 typedef typename MapTraits<ForwardMap>::ReturnValue Reference;
 typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReference;
 /// \brief Returns a read-only Undirector adaptor
 ///
 /// This function just returns a read-only \ref Undirector adaptor.
 /// \ingroup graph_adaptors
 /// \relates Undirector
-template<typename Digraph>
+template<typename GR>
-Undirector<const Digraph>
+Undirector<const GR> undirector(const GR& digraph) {
-undirector(const Digraph& digraph) {
+return Undirector<const GR>(digraph);
-return Undirector<const Digraph>(digraph);
 }
 template <typename _Graph, typename _DirectionMap>
 class OrienterBase {
 /// The arcs can be easily reversed by the \c reverseArc() member function
 /// of the adaptor.
 /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
 /// The adapted graph can also be modified through this adaptor
-/// by adding or removing nodes or arcs, unless the \c _Graph template
+/// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam _Graph The type of the adapted graph.
+/// \tparam GR The type of the adapted graph.
 /// It must conform to the \ref concepts::Graph "Graph" concept.
 /// It can also be specified to be \c const.
-/// \tparam _DirectionMap A \c bool (or convertible) edge map of the
+/// \tparam DM The type of the direction map.
-/// adapted graph. The default map type is
+/// It must be a \c bool (or convertible) edge map of the
-/// \ref concepts::Graph::EdgeMap "_Graph::EdgeMap<bool>".
+/// adapted graph. The default type is
+/// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
 ///
 /// \note The \c Node type of this adaptor and the adapted graph are
 /// convertible to each other, moreover the \c Arc type of the adaptor
 /// and the \c Edge type of the adapted graph are also convertible to
 /// each other.
 #ifdef DOXYGEN
-template<typename _Graph,
+template<typename GR,
-typename _DirectionMap>
+typename DM>
+class Orienter {
 #else
-template<typename _Graph,
+template<typename GR,
-typename _DirectionMap = typename _Graph::template EdgeMap<bool> >
+typename DM = typename GR::template EdgeMap<bool> >
+class Orienter :
+public DigraphAdaptorExtender<OrienterBase<GR, DM> > {
 #endif
-class Orienter :
-public DigraphAdaptorExtender<OrienterBase<_Graph, _DirectionMap> > {
 public:
 /// The type of the adapted graph.
-typedef _Graph Graph;
+typedef GR Graph;
 /// The type of the direction edge map.
-typedef _DirectionMap DirectionMap;
+typedef DM DirectionMap;
-typedef DigraphAdaptorExtender<
+typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent;
-OrienterBase<_Graph, _DirectionMap> > Parent;
 typedef typename Parent::Arc Arc;
 protected:
 Orienter() { }
 public:
 /// \brief Returns a read-only Orienter adaptor
 ///
 /// This function just returns a read-only \ref Orienter adaptor.
 /// \ingroup graph_adaptors
 /// \relates Orienter
-template<typename Graph, typename DirectionMap>
+template<typename GR, typename DM>
-Orienter<const Graph, DirectionMap>
+Orienter<const GR, DM>
-orienter(const Graph& graph, DirectionMap& dm) {
+orienter(const GR& graph, DM& direction_map) {
-return Orienter<const Graph, DirectionMap>(graph, dm);
+return Orienter<const GR, DM>(graph, direction_map);
 }
-template<typename Graph, typename DirectionMap>
+template<typename GR, typename DM>
-Orienter<const Graph, const DirectionMap>
+Orienter<const GR, const DM>
-orienter(const Graph& graph, const DirectionMap& dm) {
+orienter(const GR& graph, const DM& direction_map) {
-return Orienter<const Graph, const DirectionMap>(graph, dm);
+return Orienter<const GR, const DM>(graph, direction_map);
 }
 namespace _adaptor_bits {
-template<typename _Digraph,
+template<typename Digraph,
-typename _CapacityMap = typename _Digraph::template ArcMap<int>,
+typename CapacityMap,
-typename _FlowMap = _CapacityMap,
+typename FlowMap,
-typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+typename Tolerance>
 class ResForwardFilter {
 public:
-typedef _Digraph Digraph;
-typedef _CapacityMap CapacityMap;
-typedef _FlowMap FlowMap;
-typedef _Tolerance Tolerance;
 typedef typename Digraph::Arc Key;
 typedef bool Value;
 private:
 bool operator[](const typename Digraph::Arc& a) const {
 return _tolerance.positive((*_capacity)[a] - (*_flow)[a]);
 }
 };
-template<typename _Digraph,
+template<typename Digraph,
-typename _CapacityMap = typename _Digraph::template ArcMap<int>,
+typename CapacityMap,
-typename _FlowMap = _CapacityMap,
+typename FlowMap,
-typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+typename Tolerance>
 class ResBackwardFilter {
 public:
-typedef _Digraph Digraph;
-typedef _CapacityMap CapacityMap;
-typedef _FlowMap FlowMap;
-typedef _Tolerance Tolerance;
 typedef typename Digraph::Arc Key;
 typedef bool Value;
 private:
 /// multiplicities are counted, i.e. the adaptor has exactly
 /// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel
 /// arcs).
 /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
-/// \tparam _Digraph The type of the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It is implicitly \c const.
-/// \tparam _CapacityMap An arc map of some numerical type, which defines
+/// \tparam CM The type of the capacity map.
+/// It must be an arc map of some numerical type, which defines
 /// the capacities in the flow problem. It is implicitly \c const.
-/// The default map type is
+/// The default type is
-/// \ref concepts::Digraph::ArcMap "_Digraph::ArcMap<int>".
+/// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-/// \tparam _FlowMap An arc map of some numerical type, which defines
+/// \tparam FM The type of the flow map.
-/// the flow values in the flow problem.
+/// It must be an arc map of some numerical type, which defines
-/// The default map type is \c _CapacityMap.
+/// the flow values in the flow problem. The default type is \c CM.
-/// \tparam _Tolerance Tolerance type for handling inexact computation.
+/// \tparam TL The tolerance type for handling inexact computation.
 /// The default tolerance type depends on the value type of the
 /// capacity map.
 ///
 /// \note This adaptor is implemented using Undirector and FilterArcs
 /// adaptors.
 ///
 /// \note The \c Node type of this adaptor and the adapted digraph are
 /// convertible to each other, moreover the \c Arc type of the adaptor
 /// is convertible to the \c Arc type of the adapted digraph.
 #ifdef DOXYGEN
-template<typename _Digraph,
+template<typename GR, typename CM, typename FM, typename TL>
-typename _CapacityMap,
-typename _FlowMap,
-typename _Tolerance>
 class Residual
 #else
-template<typename _Digraph,
+template<typename GR,
-typename _CapacityMap = typename _Digraph::template ArcMap<int>,
+typename CM = typename GR::template ArcMap<int>,
-typename _FlowMap = _CapacityMap,
+typename FM = CM,
-typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+typename TL = Tolerance<typename CM::Value> >
 class Residual :
 public FilterArcs<
-Undirector<const _Digraph>,
+Undirector<const GR>,
-typename Undirector<const _Digraph>::template CombinedArcMap<
+typename Undirector<const GR>::template CombinedArcMap<
-_adaptor_bits::ResForwardFilter<const _Digraph, _CapacityMap,
+_adaptor_bits::ResForwardFilter<const GR, CM, FM, TL>,
-_FlowMap, _Tolerance>,
+_adaptor_bits::ResBackwardFilter<const GR, CM, FM, TL> > >
-_adaptor_bits::ResBackwardFilter<const _Digraph, _CapacityMap,
-_FlowMap, _Tolerance> > >
 #endif
 {
 public:
 /// The type of the underlying digraph.
-typedef _Digraph Digraph;
+typedef GR Digraph;
 /// The type of the capacity map.
-typedef _CapacityMap CapacityMap;
+typedef CM CapacityMap;
 /// The type of the flow map.
-typedef _FlowMap FlowMap;
+typedef FM FlowMap;
-typedef _Tolerance Tolerance;
+/// The tolerance type.
+typedef TL Tolerance;
 typedef typename CapacityMap::Value Value;
 typedef Residual Adaptor;
 protected:
 typedef _adaptor_bits::ResBackwardFilter<const Digraph, CapacityMap,
 FlowMap, Tolerance> BackwardFilter;
 typedef typename Undirected::
 template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter;
 typedef FilterArcs<Undirected, ArcFilter> Parent;
 const CapacityMap* _capacity;
 FlowMap* _flow;
 const Adaptor* _adaptor;
 public:
 /// The key type of the map
 typedef Arc Key;
 /// The value type of the map
-typedef typename _CapacityMap::Value Value;
+typedef typename CapacityMap::Value Value;
 /// Constructor
 ResidualCapacity(const Adaptor& adaptor) : _adaptor(&adaptor) {}
 /// Returns the value associated with the given residual arc
 /// \brief Returns a (read-only) Residual adaptor
 ///
 /// This function just returns a (read-only) \ref Residual adaptor.
 /// \ingroup graph_adaptors
 /// \relates Residual
-template<typename Digraph, typename CapacityMap, typename FlowMap>
+template<typename GR, typename CM, typename FM>
-Residual<Digraph, CapacityMap, FlowMap>
+Residual<GR, CM, FM> residual(const GR& digraph,
-residual(const Digraph& digraph,
+const CM& capacity_map,
-const CapacityMap& capacity,
+FM& flow_map) {
-FlowMap& flow)
+return Residual<GR, CM, FM> (digraph, capacity_map, flow_map);
-{
-return Residual<Digraph, CapacityMap, FlowMap> (digraph, capacity, flow);
 }
 template <typename _Digraph>
 class SplitNodesBase {
 /// capacities directly.
 /// In this case you can use \c SplitNodes adaptor, and set the node
 /// costs/capacities of the original digraph to the \e bind \e arcs
 /// in the adaptor.
 ///
-/// \tparam _Digraph The type of the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It is implicitly \c const.
 ///
 /// \note The \c Node type of this adaptor is converible to the \c Node
 /// type of the adapted digraph.
-template <typename _Digraph>
+template <typename GR>
+#ifdef DOXYGEN
+class SplitNodes {
+#else
 class SplitNodes
-: public DigraphAdaptorExtender<SplitNodesBase<const _Digraph> > {
+: public DigraphAdaptorExtender<SplitNodesBase<const GR> > {
-public:
+#endif
-typedef _Digraph Digraph;
+public:
-typedef DigraphAdaptorExtender<SplitNodesBase<const Digraph> > Parent;
+typedef GR Digraph;
+typedef DigraphAdaptorExtender<SplitNodesBase<const GR> > Parent;
 typedef typename Digraph::Node DigraphNode;
 typedef typename Digraph::Arc DigraphArc;
 typedef typename Parent::Node Node;
 /// original digraph.
 ///
 /// This map adaptor class adapts an arc map and a node map of the
 /// original digraph to get an arc map of the split digraph.
 /// Its value type is inherited from the original arc map type
-/// (\c DigraphArcMap).
+/// (\c ArcMap).
-template <typename DigraphArcMap, typename DigraphNodeMap>
+template <typename ArcMap, typename NodeMap>
 class CombinedArcMap {
 public:
 /// The key type of the map
 typedef Arc Key;
 /// The value type of the map
-typedef typename DigraphArcMap::Value Value;
+typedef typename ArcMap::Value Value;
-typedef typename MapTraits<DigraphArcMap>::ReferenceMapTag
+typedef typename MapTraits<ArcMap>::ReferenceMapTag ReferenceMapTag;
-ReferenceMapTag;
+typedef typename MapTraits<ArcMap>::ReturnValue ReturnValue;
-typedef typename MapTraits<DigraphArcMap>::ReturnValue
+typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReturnValue;
-ReturnValue;
+typedef typename MapTraits<ArcMap>::ReturnValue Reference;
-typedef typename MapTraits<DigraphArcMap>::ConstReturnValue
+typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReference;
-ConstReturnValue;
-typedef typename MapTraits<DigraphArcMap>::ReturnValue
-Reference;
-typedef typename MapTraits<DigraphArcMap>::ConstReturnValue
-ConstReference;
 /// Constructor
-CombinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map)
+CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
 : _arc_map(arc_map), _node_map(node_map) {}
 /// Returns the value associated with the given key.
 Value operator[](const Key& arc) const {
 if (Parent::origArc(arc)) {
 _node_map.set(arc, val);
 }
 }
 private:
-DigraphArcMap& _arc_map;
+ArcMap& _arc_map;
-DigraphNodeMap& _node_map;
+NodeMap& _node_map;
 };
 /// \brief Returns a combined arc map
 ///
 /// This function just returns a combined arc map.
-template <typename DigraphArcMap, typename DigraphNodeMap>
+template <typename ArcMap, typename NodeMap>
-static CombinedArcMap<DigraphArcMap, DigraphNodeMap>
+static CombinedArcMap<ArcMap, NodeMap>
-combinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map) {
+combinedArcMap(ArcMap& arc_map, NodeMap& node_map) {
-return CombinedArcMap<DigraphArcMap, DigraphNodeMap>(arc_map, node_map);
+return CombinedArcMap<ArcMap, NodeMap>(arc_map, node_map);
 }
-template <typename DigraphArcMap, typename DigraphNodeMap>
+template <typename ArcMap, typename NodeMap>
-static CombinedArcMap<const DigraphArcMap, DigraphNodeMap>
+static CombinedArcMap<const ArcMap, NodeMap>
-combinedArcMap(const DigraphArcMap& arc_map, DigraphNodeMap& node_map) {
+combinedArcMap(const ArcMap& arc_map, NodeMap& node_map) {
-return CombinedArcMap<const DigraphArcMap,
+return CombinedArcMap<const ArcMap, NodeMap>(arc_map, node_map);
-DigraphNodeMap>(arc_map, node_map);
+}
-}
+template <typename ArcMap, typename NodeMap>
-template <typename DigraphArcMap, typename DigraphNodeMap>
+static CombinedArcMap<ArcMap, const NodeMap>
-static CombinedArcMap<DigraphArcMap, const DigraphNodeMap>
+combinedArcMap(ArcMap& arc_map, const NodeMap& node_map) {
-combinedArcMap(DigraphArcMap& arc_map, const DigraphNodeMap& node_map) {
+return CombinedArcMap<ArcMap, const NodeMap>(arc_map, node_map);
-return CombinedArcMap<DigraphArcMap,
+}
-const DigraphNodeMap>(arc_map, node_map);
-}
+template <typename ArcMap, typename NodeMap>
+static CombinedArcMap<const ArcMap, const NodeMap>
-template <typename DigraphArcMap, typename DigraphNodeMap>
+combinedArcMap(const ArcMap& arc_map, const NodeMap& node_map) {
-static CombinedArcMap<const DigraphArcMap, const DigraphNodeMap>
+return CombinedArcMap<const ArcMap, const NodeMap>(arc_map, node_map);
-combinedArcMap(const DigraphArcMap& arc_map,
-const DigraphNodeMap& node_map) {
-return CombinedArcMap<const DigraphArcMap,
-const DigraphNodeMap>(arc_map, node_map);
 }
 };
 /// \brief Returns a (read-only) SplitNodes adaptor
 ///
 /// This function just returns a (read-only) \ref SplitNodes adaptor.
 /// \ingroup graph_adaptors
 /// \relates SplitNodes
-template<typename Digraph>
+template<typename GR>
-SplitNodes<Digraph>
+SplitNodes<GR>
-splitNodes(const Digraph& digraph) {
+splitNodes(const GR& digraph) {
-return SplitNodes<Digraph>(digraph);
+return SplitNodes<GR>(digraph);
 }
 } //namespace lemon
 #endif //LEMON_ADAPTORS_H

changeset 453	c246659c8b19
parent 452	aea2dc0518ce
child 454	f599fa651202