lemon-1.2: comparison lemon/adaptors.h

equal deleted inserted replaced

-:b8e2dc23063f
+:523748220451
 #ifndef LEMON_ADAPTORS_H
 #define LEMON_ADAPTORS_H
 /// \ingroup graph_adaptors
 /// \file
-/// \brief Several graph adaptors
+/// \brief Adaptor classes for digraphs and graphs
 ///
 /// This file contains several useful adaptors for digraphs and graphs.
 #include <lemon/core.h>
 #include <lemon/maps.h>
 Node target(const Arc& a) const { return _digraph->target(a); }
 typedef NodeNumTagIndicator<Digraph> NodeNumTag;
 int nodeNum() const { return _digraph->nodeNum(); }
-typedef EdgeNumTagIndicator<Digraph> EdgeNumTag;
+typedef ArcNumTagIndicator<Digraph> ArcNumTag;
 int arcNum() const { return _digraph->arcNum(); }
-typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+typedef FindArcTagIndicator<Digraph> FindArcTag;
-Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) {
+Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const {
 return _digraph->findArc(u, v, prev);
 }
 Node addNode() { return _digraph->addNode(); }
 Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }
-void erase(const Node& n) const { _digraph->erase(n); }
+void erase(const Node& n) { _digraph->erase(n); }
-void erase(const Arc& a) const { _digraph->erase(a); }
+void erase(const Arc& a) { _digraph->erase(a); }
-void clear() const { _digraph->clear(); }
+void clear() { _digraph->clear(); }
 int id(const Node& n) const { return _digraph->id(n); }
 int id(const Arc& a) const { return _digraph->id(a); }
 Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }
 Node target(const Arc& a) const { return _graph->target(a); }
 typedef NodeNumTagIndicator<Graph> NodeNumTag;
 int nodeNum() const { return _graph->nodeNum(); }
+typedef ArcNumTagIndicator<Graph> ArcNumTag;
+int arcNum() const { return _graph->arcNum(); }
 typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
-int arcNum() const { return _graph->arcNum(); }
 int edgeNum() const { return _graph->edgeNum(); }
+typedef FindArcTagIndicator<Graph> FindArcTag;
+Arc findArc(const Node& u, const Node& v,
+const Arc& prev = INVALID) const {
+return _graph->findArc(u, v, prev);
+}
 typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) {
+Edge findEdge(const Node& u, const Node& v,
-return _graph->findArc(u, v, prev);
+const Edge& prev = INVALID) const {
-}
-Edge findEdge(const Node& u, const Node& v, const Edge& prev = INVALID) {
 return _graph->findEdge(u, v, prev);
 }
 Node addNode() { return _graph->addNode(); }
 Edge addEdge(const Node& u, const Node& v) { return _graph->addEdge(u, v); }
 Node source(const Arc& a) const { return Parent::target(a); }
 Node target(const Arc& a) const { return Parent::source(a); }
 Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); }
-typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+typedef FindArcTagIndicator<Digraph> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
-const Arc& prev = INVALID) {
+const Arc& prev = INVALID) const {
 return Parent::findArc(v, u, prev);
 }
 };
 /// \ingroup graph_adaptors
 ///
-/// \brief A digraph adaptor which reverses the orientation of the arcs.
+/// \brief Adaptor class for reversing the orientation of the arcs in
-///
+/// a digraph.
-/// ReverseDigraph reverses the arcs in the adapted digraph. The
+///
-/// SubDigraph is conform to the \ref concepts::Digraph
+/// ReverseDigraph can be used for reversing the arcs in a digraph.
-/// "Digraph concept".
+/// It conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
-/// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+/// The adapted digraph can also be modified through this adaptor
-/// "Digraph concept". The type can be specified to be const.
+/// by adding or removing nodes or arcs, unless the \c GR template
-template<typename _Digraph>
+/// parameter is set to be \c const.
+///
+/// \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 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
 ///
-/// Creates a reverse digraph adaptor for the given digraph
+/// Creates a reverse digraph adaptor for the given digraph.
 explicit ReverseDigraph(Digraph& digraph) {
 Parent::setDigraph(digraph);
 }
 };
-/// \brief Just gives back a reverse digraph adaptor
+/// \brief Returns a read-only ReverseDigraph adaptor
 ///
-/// Just gives back a reverse digraph adaptor
+/// This function just returns a read-only \ref ReverseDigraph adaptor.
-template<typename Digraph>
+/// \ingroup graph_adaptors
-ReverseDigraph<const Digraph> reverseDigraph(const Digraph& digraph) {
+/// \relates ReverseDigraph
-return ReverseDigraph<const Digraph>(digraph);
+template<typename GR>
+ReverseDigraph<const GR> reverseDigraph(const GR& digraph) {
+return ReverseDigraph<const GR>(digraph);
 }
 template <typename _Digraph, typename _NodeFilterMap,
 typename _ArcFilterMap, bool _checked = true>
 class SubDigraphBase : public DigraphAdaptorBase<_Digraph> {
 public:
 while (i != INVALID && (!(*_arc_filter)[i]
 || !(*_node_filter)[Parent::target(i)]))
 Parent::nextOut(i);
 }
-void hide(const Node& n) const { _node_filter->set(n, false); }
+void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-void hide(const Arc& a) const { _arc_filter->set(a, false); }
+void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
-void unHide(const Node& n) const { _node_filter->set(n, true); }
+bool status(const Node& n) const { return (*_node_filter)[n]; }
-void unHide(const Arc& a) const { _arc_filter->set(a, true); }
+bool status(const Arc& a) const { return (*_arc_filter)[a]; }
-bool hidden(const Node& n) const { return !(*_node_filter)[n]; }
-bool hidden(const Arc& a) const { return !(*_arc_filter)[a]; }
 typedef False NodeNumTag;
-typedef False EdgeNumTag;
+typedef False ArcNumTag;
-typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+typedef FindArcTagIndicator<Digraph> FindArcTag;
 Arc findArc(const Node& source, const Node& target,
-const Arc& prev = INVALID) {
+const Arc& prev = INVALID) const {
 if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
 return INVALID;
 }
 Arc arc = Parent::findArc(source, target, prev);
 while (arc != INVALID && !(*_arc_filter)[arc]) {
 void nextOut(Arc& i) const {
 Parent::nextOut(i);
 while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i);
 }
-void hide(const Node& n) const { _node_filter->set(n, false); }
+void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-void hide(const Arc& e) const { _arc_filter->set(e, false); }
+void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
-void unHide(const Node& n) const { _node_filter->set(n, true); }
+bool status(const Node& n) const { return (*_node_filter)[n]; }
-void unHide(const Arc& e) const { _arc_filter->set(e, true); }
+bool status(const Arc& a) const { return (*_arc_filter)[a]; }
-bool hidden(const Node& n) const { return !(*_node_filter)[n]; }
-bool hidden(const Arc& e) const { return !(*_arc_filter)[e]; }
 typedef False NodeNumTag;
-typedef False EdgeNumTag;
+typedef False ArcNumTag;
-typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+typedef FindArcTagIndicator<Digraph> FindArcTag;
 Arc findArc(const Node& source, const Node& target,
-const Arc& prev = INVALID) {
+const Arc& prev = INVALID) const {
 if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
 return INVALID;
 }
 Arc arc = Parent::findArc(source, target, prev);
 while (arc != INVALID && !(*_arc_filter)[arc]) {
 };
 /// \ingroup graph_adaptors
 ///
-/// \brief An adaptor for hiding nodes and arcs in a digraph
+/// \brief Adaptor class for hiding nodes and arcs in a digraph
 ///
-/// SubDigraph hides nodes and arcs in a digraph. A bool node map
+/// SubDigraph can be used for hiding nodes and arcs in a digraph.
-/// and a bool arc map must be specified, which define the filters
+/// A \c bool node map and a \c bool arc map must be specified, which
-/// for nodes and arcs. Just the nodes and arcs with true value are
+/// define the filters for nodes and arcs.
-/// shown in the subdigraph. The SubDigraph is conform to the \ref
+/// Only the nodes and arcs with \c true filter value are
-/// concepts::Digraph "Digraph concept". If the \c _checked parameter
+/// shown in the subdigraph. The arcs that are incident to hidden
-/// is true, then the arcs incident to filtered nodes are also
+/// nodes are also filtered out.
-/// filtered out.
+/// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
-/// \tparam _Digraph It must be conform to the \ref
+/// The adapted digraph can also be modified through this adaptor
-/// concepts::Digraph "Digraph concept". The type can be specified
+/// by adding or removing nodes or arcs, unless the \c GR template
-/// to const.
+/// parameter is set to be \c const.
-/// \tparam _NodeFilterMap A bool valued node map of the the adapted digraph.
+///
-/// \tparam _ArcFilterMap A bool valued arc map of the the adapted digraph.
+/// \tparam GR The type of the adapted digraph.
-/// \tparam _checked If the parameter is false then the arc filtering
+/// It must conform to the \ref concepts::Digraph "Digraph" concept.
-/// is not checked with respect to node filter. Otherwise, each arc
+/// It can also be specified to be \c const.
-/// is automatically filtered, which is incident to a filtered node.
+/// \tparam NF The type of the node filter map.
+/// It must be a \c bool (or convertible) node map of the
+/// adapted digraph. The default type is
+/// \ref concepts::Digraph::NodeMap "GR::NodeMap<bool>".
+/// \tparam AF The type of the arc filter map.
+/// It must be \c bool (or convertible) arc map of the
+/// 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.
 ///
 /// \see FilterNodes
 /// \see FilterArcs
-template<typename _Digraph,
+#ifdef DOXYGEN
-typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+template<typename GR, typename NF, typename AF>
-typename _ArcFilterMap = typename _Digraph::template ArcMap<bool>,
+class SubDigraph {
-bool _checked = true>
+#else
-class SubDigraph
+template<typename GR,
-: public DigraphAdaptorExtender<
+typename NF = typename GR::template NodeMap<bool>,
-SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, _checked> > {
+typename AF = typename GR::template ArcMap<bool> >
-public:
+class SubDigraph :
-typedef _Digraph Digraph;
+public DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> > {
-typedef _NodeFilterMap NodeFilterMap;
+#endif
-typedef _ArcFilterMap ArcFilterMap;
+public:
+/// The type of the adapted digraph.
-typedef DigraphAdaptorExtender<
+typedef GR Digraph;
-SubDigraphBase<Digraph, NodeFilterMap, ArcFilterMap, _checked> >
+/// The type of the node filter map.
-Parent;
+typedef NF NodeFilterMap;
+/// The type of the arc filter map.
+typedef AF ArcFilterMap;
+typedef DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> >
+Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 protected:
 SubDigraph() { }
 public:
 /// \brief Constructor
 ///
-/// Creates a subdigraph for the given digraph with
+/// Creates a subdigraph for the given digraph with the
-/// given node and arc map filters.
+/// given node and arc filter maps.
 SubDigraph(Digraph& digraph, NodeFilterMap& node_filter,
 ArcFilterMap& arc_filter) {
 setDigraph(digraph);
 setNodeFilterMap(node_filter);
 setArcFilterMap(arc_filter);
 }
-/// \brief Hides the node of the graph
+/// \brief Sets the status of the given node
 ///
-/// This function hides \c n in the digraph, i.e. the iteration
+/// This function sets the status of the given node.
-/// jumps over it. This is done by simply setting the value of \c n
+/// It is done by simply setting the assigned value of \c n
-/// to be false in the corresponding node-map.
+/// to \c v in the node filter map.
-void hide(const Node& n) const { Parent::hide(n); }
+void status(const Node& n, bool v) const { Parent::status(n, v); }
-/// \brief Hides the arc of the graph
+/// \brief Sets the status of the given arc
 ///
-/// This function hides \c a in the digraph, i.e. the iteration
+/// This function sets the status of the given arc.
-/// jumps over it. This is done by simply setting the value of \c a
+/// It is done by simply setting the assigned value of \c a
-/// to be false in the corresponding arc-map.
+/// to \c v in the arc filter map.
-void hide(const Arc& a) const { Parent::hide(a); }
+void status(const Arc& a, bool v) const { Parent::status(a, v); }
-/// \brief Unhides the node of the graph
+/// \brief Returns the status of the given node
 ///
-/// The value of \c n is set to be true in the node-map which stores
+/// This function returns the status of the given node.
-/// hide information. If \c n was hidden previuosly, then it is shown
+/// It is \c true if the given node is enabled (i.e. not hidden).
-/// again
+bool status(const Node& n) const { return Parent::status(n); }
-void unHide(const Node& n) const { Parent::unHide(n); }
+/// \brief Returns the status of the given arc
-/// \brief Unhides the arc of the graph
+///
-///
+/// This function returns the status of the given arc.
-/// The value of \c a is set to be true in the arc-map which stores
+/// It is \c true if the given arc is enabled (i.e. not hidden).
-/// hide information. If \c a was hidden previuosly, then it is shown
+bool status(const Arc& a) const { return Parent::status(a); }
-/// again
-void unHide(const Arc& a) const { Parent::unHide(a); }
+/// \brief Disables the given node
+///
-/// \brief Returns true if \c n is hidden.
+/// This function disables the given node in the subdigraph,
-///
+/// so the iteration jumps over it.
-/// Returns true if \c n is hidden.
+/// It is the same as \ref status() "status(n, false)".
-///
+void disable(const Node& n) const { Parent::status(n, false); }
-bool hidden(const Node& n) const { return Parent::hidden(n); }
+/// \brief Disables the given arc
-/// \brief Returns true if \c a is hidden.
+///
-///
+/// This function disables the given arc in the subdigraph,
-/// Returns true if \c a is hidden.
+/// so the iteration jumps over it.
-///
+/// It is the same as \ref status() "status(a, false)".
-bool hidden(const Arc& a) const { return Parent::hidden(a); }
+void disable(const Arc& a) const { Parent::status(a, false); }
+/// \brief Enables the given node
+///
+/// This function enables the given node in the subdigraph.
+/// It is the same as \ref status() "status(n, true)".
+void enable(const Node& n) const { Parent::status(n, true); }
+/// \brief Enables the given arc
+///
+/// This function enables the given arc in the subdigraph.
+/// It is the same as \ref status() "status(a, true)".
+void enable(const Arc& a) const { Parent::status(a, true); }
 };
-/// \brief Just gives back a subdigraph
+/// \brief Returns a read-only SubDigraph adaptor
 ///
-/// Just gives back a subdigraph
+/// This function just returns a read-only \ref SubDigraph adaptor.
-template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
+/// \ingroup graph_adaptors
-SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>
+/// \relates SubDigraph
-subDigraph(const Digraph& digraph, NodeFilterMap& nfm, ArcFilterMap& afm) {
+template<typename GR, typename NF, typename AF>
-return SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>
+SubDigraph<const GR, NF, AF>
-(digraph, nfm, afm);
+subDigraph(const GR& digraph,
+NF& node_filter_map, AF& arc_filter_map) {
+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,
+template <typename _Graph, typename _NodeFilterMap,
-typename EdgeFilterMap, bool _checked = true>
+typename _EdgeFilterMap, bool _checked = true>
 class SubGraphBase : public GraphAdaptorBase<_Graph> {
 public:
 typedef _Graph Graph;
+typedef _NodeFilterMap NodeFilterMap;
+typedef _EdgeFilterMap EdgeFilterMap;
 typedef SubGraphBase Adaptor;
 typedef GraphAdaptorBase<_Graph> Parent;
 protected:
 NodeFilterMap* _node_filter_map;
 || !(*_node_filter_map)[Parent::u(i)]
 || !(*_node_filter_map)[Parent::v(i)]))
 Parent::nextInc(i, d);
 }
-void hide(const Node& n) const { _node_filter_map->set(n, false); }
+void status(const Node& n, bool v) const { _node_filter_map->set(n, v); }
-void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
+void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); }
-void unHide(const Node& n) const { _node_filter_map->set(n, true); }
+bool status(const Node& n) const { return (*_node_filter_map)[n]; }
-void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
+bool status(const Edge& e) const { return (*_edge_filter_map)[e]; }
-bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
-bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
 typedef False NodeNumTag;
+typedef False ArcNumTag;
 typedef False EdgeNumTag;
-typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+typedef FindArcTagIndicator<Graph> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
-const Arc& prev = INVALID) {
+const Arc& prev = INVALID) const {
 if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
 return INVALID;
 }
 Arc arc = Parent::findArc(u, v, prev);
 while (arc != INVALID && !(*_edge_filter_map)[arc]) {
 arc = Parent::findArc(u, v, arc);
 }
 return arc;
 }
+typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
 Edge findEdge(const Node& u, const Node& v,
-const Edge& prev = INVALID) {
+const Edge& prev = INVALID) const {
 if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
 return INVALID;
 }
 Edge edge = Parent::findEdge(u, v, prev);
 while (edge != INVALID && !(*_edge_filter_map)[edge]) {
 }
 };
 };
-template <typename _Graph, typename NodeFilterMap, typename EdgeFilterMap>
+template <typename _Graph, typename _NodeFilterMap, typename _EdgeFilterMap>
-class SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap, false>
+class SubGraphBase<_Graph, _NodeFilterMap, _EdgeFilterMap, false>
 : public GraphAdaptorBase<_Graph> {
 public:
 typedef _Graph Graph;
+typedef _NodeFilterMap NodeFilterMap;
+typedef _EdgeFilterMap EdgeFilterMap;
 typedef SubGraphBase Adaptor;
 typedef GraphAdaptorBase<_Graph> Parent;
 protected:
 NodeFilterMap* _node_filter_map;
 EdgeFilterMap* _edge_filter_map;
 void nextInc(Edge& i, bool& d) const {
 Parent::nextInc(i, d);
 while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d);
 }
-void hide(const Node& n) const { _node_filter_map->set(n, false); }
+void status(const Node& n, bool v) const { _node_filter_map->set(n, v); }
-void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
+void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); }
-void unHide(const Node& n) const { _node_filter_map->set(n, true); }
+bool status(const Node& n) const { return (*_node_filter_map)[n]; }
-void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
+bool status(const Edge& e) const { return (*_edge_filter_map)[e]; }
-bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
-bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
 typedef False NodeNumTag;
+typedef False ArcNumTag;
 typedef False EdgeNumTag;
-typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+typedef FindArcTagIndicator<Graph> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
-const Arc& prev = INVALID) {
+const Arc& prev = INVALID) const {
 Arc arc = Parent::findArc(u, v, prev);
 while (arc != INVALID && !(*_edge_filter_map)[arc]) {
 arc = Parent::findArc(u, v, arc);
 }
 return arc;
 }
+typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
 Edge findEdge(const Node& u, const Node& v,
-const Edge& prev = INVALID) {
+const Edge& prev = INVALID) const {
 Edge edge = Parent::findEdge(u, v, prev);
 while (edge != INVALID && !(*_edge_filter_map)[edge]) {
 edge = Parent::findEdge(u, v, edge);
 }
 return edge;
 };
 /// \ingroup graph_adaptors
 ///
-/// \brief A graph adaptor for hiding nodes and edges in an
+/// \brief Adaptor class for hiding nodes and edges in an undirected
-/// undirected graph.
+/// graph.
 ///
-/// SubGraph hides nodes and edges in a graph. A bool node map and a
+/// SubGraph can be used for hiding nodes and edges in a graph.
-/// bool edge map must be specified, which define the filters for
+/// A \c bool node map and a \c bool edge map must be specified, which
-/// nodes and edges. Just the nodes and edges with true value are
+/// define the filters for nodes and edges.
-/// shown in the subgraph. The SubGraph is conform to the \ref
+/// Only the nodes and edges with \c true filter value are
-/// concepts::Graph "Graph concept". If the \c _checked parameter is
+/// shown in the subgraph. The edges that are incident to hidden
-/// true, then the edges incident to filtered nodes are also
+/// nodes are also filtered out.
-/// filtered out.
+/// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
 ///
-/// \tparam _Graph It must be conform to the \ref
+/// The adapted graph can also be modified through this adaptor
-/// concepts::Graph "Graph concept". The type can be specified
+/// by adding or removing nodes or edges, unless the \c GR template
-/// to const.
+/// parameter is set to be \c const.
-/// \tparam _NodeFilterMap A bool valued node map of the the adapted graph.
+///
-/// \tparam _EdgeFilterMap A bool valued edge map of the the adapted graph.
+/// \tparam GR The type of the adapted graph.
-/// \tparam _checked If the parameter is false then the edge filtering
+/// It must conform to the \ref concepts::Graph "Graph" concept.
-/// is not checked with respect to node filter. Otherwise, each edge
+/// It can also be specified to be \c const.
-/// is automatically filtered, which is incident to a filtered node.
+/// \tparam NF The type of the node filter map.
+/// It must be a \c bool (or convertible) node map of the
+/// adapted graph. The default type is
+/// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
+/// \tparam EF The type of the edge filter map.
+/// It must be a \c bool (or convertible) edge map of the
+/// 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.
 ///
 /// \see FilterNodes
 /// \see FilterEdges
-template<typename _Graph, typename NodeFilterMap,
+#ifdef DOXYGEN
-typename EdgeFilterMap, bool _checked = true>
+template<typename GR, typename NF, typename EF>
-class SubGraph
+class SubGraph {
-: public GraphAdaptorExtender<
+#else
-SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap, _checked> > {
+template<typename GR,
-public:
+typename NF = typename GR::template NodeMap<bool>,
-typedef _Graph Graph;
+typename EF = typename GR::template EdgeMap<bool> >
-typedef GraphAdaptorExtender<
+class SubGraph :
-SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
+public GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > {
+#endif
+public:
+/// The type of the adapted graph.
+typedef GR Graph;
+/// The type of the node filter map.
+typedef NF NodeFilterMap;
+/// The type of the edge filter map.
+typedef EF EdgeFilterMap;
+typedef GraphAdaptorExtender< SubGraphBase<GR, NF, EF, true> >
+Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Edge Edge;
 protected:
 SubGraph() { }
 public:
 /// \brief Constructor
 ///
-/// Creates a subgraph for the given graph with given node and
+/// Creates a subgraph for the given graph with the given node
-/// edge map filters.
+/// and edge filter maps.
-SubGraph(Graph& _graph, NodeFilterMap& node_filter_map,
+SubGraph(Graph& graph, NodeFilterMap& node_filter_map,
 EdgeFilterMap& edge_filter_map) {
-setGraph(_graph);
+setGraph(graph);
 setNodeFilterMap(node_filter_map);
 setEdgeFilterMap(edge_filter_map);
 }
-/// \brief Hides the node of the graph
+/// \brief Sets the status of the given node
 ///
-/// This function hides \c n in the graph, i.e. the iteration
+/// This function sets the status of the given node.
-/// jumps over it. This is done by simply setting the value of \c n
+/// It is done by simply setting the assigned value of \c n
-/// to be false in the corresponding node-map.
+/// to \c v in the node filter map.
-void hide(const Node& n) const { Parent::hide(n); }
+void status(const Node& n, bool v) const { Parent::status(n, v); }
-/// \brief Hides the edge of the graph
+/// \brief Sets the status of the given edge
 ///
-/// This function hides \c e in the graph, i.e. the iteration
+/// This function sets the status of the given edge.
-/// jumps over it. This is done by simply setting the value of \c e
+/// It is done by simply setting the assigned value of \c e
-/// to be false in the corresponding edge-map.
+/// to \c v in the edge filter map.
-void hide(const Edge& e) const { Parent::hide(e); }
+void status(const Edge& e, bool v) const { Parent::status(e, v); }
-/// \brief Unhides the node of the graph
+/// \brief Returns the status of the given node
 ///
-/// The value of \c n is set to be true in the node-map which stores
+/// This function returns the status of the given node.
-/// hide information. If \c n was hidden previuosly, then it is shown
+/// It is \c true if the given node is enabled (i.e. not hidden).
-/// again
+bool status(const Node& n) const { return Parent::status(n); }
-void unHide(const Node& n) const { Parent::unHide(n); }
+/// \brief Returns the status of the given edge
-/// \brief Unhides the edge of the graph
+///
-///
+/// This function returns the status of the given edge.
-/// The value of \c e is set to be true in the edge-map which stores
+/// It is \c true if the given edge is enabled (i.e. not hidden).
-/// hide information. If \c e was hidden previuosly, then it is shown
+bool status(const Edge& e) const { return Parent::status(e); }
-/// again
-void unHide(const Edge& e) const { Parent::unHide(e); }
+/// \brief Disables the given node
+///
-/// \brief Returns true if \c n is hidden.
+/// This function disables the given node in the subdigraph,
-///
+/// so the iteration jumps over it.
-/// Returns true if \c n is hidden.
+/// It is the same as \ref status() "status(n, false)".
-///
+void disable(const Node& n) const { Parent::status(n, false); }
-bool hidden(const Node& n) const { return Parent::hidden(n); }
+/// \brief Disables the given edge
-/// \brief Returns true if \c e is hidden.
+///
-///
+/// This function disables the given edge in the subgraph,
-/// Returns true if \c e is hidden.
+/// so the iteration jumps over it.
-///
+/// It is the same as \ref status() "status(e, false)".
-bool hidden(const Edge& e) const { return Parent::hidden(e); }
+void disable(const Edge& e) const { Parent::status(e, false); }
+/// \brief Enables the given node
+///
+/// This function enables the given node in the subdigraph.
+/// It is the same as \ref status() "status(n, true)".
+void enable(const Node& n) const { Parent::status(n, true); }
+/// \brief Enables the given edge
+///
+/// This function enables the given edge in the subgraph.
+/// It is the same as \ref status() "status(e, true)".
+void enable(const Edge& e) const { Parent::status(e, true); }
 };
-/// \brief Just gives back a subgraph
+/// \brief Returns a read-only SubGraph adaptor
 ///
-/// Just gives back a subgraph
+/// This function just returns a read-only \ref SubGraph adaptor.
-template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
+/// \ingroup graph_adaptors
-SubGraph<const Graph, NodeFilterMap, ArcFilterMap>
+/// \relates SubGraph
-subGraph(const Graph& graph, NodeFilterMap& nfm, ArcFilterMap& efm) {
+template<typename GR, typename NF, typename EF>
-return SubGraph<const Graph, NodeFilterMap, ArcFilterMap>(graph, nfm, efm);
+SubGraph<const GR, NF, EF>
+subGraph(const GR& graph,
+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
 ///
-/// \brief An adaptor for hiding nodes from a digraph or a graph.
+/// \brief Adaptor class for hiding nodes in a digraph or a graph.
 ///
-/// FilterNodes adaptor hides nodes in a graph or a digraph. A bool
+/// FilterNodes adaptor can be used for hiding nodes in a digraph or a
-/// node map must be specified, which defines the filters for
+/// graph. A \c bool node map must be specified, which defines the filter
-/// nodes. Just the unfiltered nodes and the arcs or edges incident
+/// for the nodes. Only the nodes with \c true filter value and the
-/// to unfiltered nodes are shown in the subdigraph or subgraph. The
+/// arcs/edges incident to nodes both with \c true filter value are shown
-/// FilterNodes is conform to the \ref concepts::Digraph
+/// in the subgraph. This adaptor conforms to the \ref concepts::Digraph
-/// "Digraph concept" or \ref concepts::Graph "Graph concept" depending
+/// "Digraph" concept or the \ref concepts::Graph "Graph" concept
-/// on the \c _Digraph template parameter. If the \c _checked
+/// depending on the \c GR template parameter.
-/// parameter is true, then the arc or edges incident to filtered nodes
+///
-/// are also filtered out.
+/// The adapted (di)graph can also be modified through this adaptor
-///
+/// by adding or removing nodes or arcs/edges, unless the \c GR template
-/// \tparam _Digraph It must be conform to the \ref
+/// parameter is set to be \c const.
-/// concepts::Digraph "Digraph concept" or \ref concepts::Graph
+///
-/// "Graph concept". The type can be specified to be const.
+/// \tparam GR The type of the adapted digraph or graph.
-/// \tparam _NodeFilterMap A bool valued node map of the the adapted graph.
+/// It must conform to the \ref concepts::Digraph "Digraph" concept
-/// \tparam _checked If the parameter is false then the arc or edge
+/// or the \ref concepts::Graph "Graph" concept.
-/// filtering is not checked with respect to node filter. In this
+/// It can also be specified to be \c const.
-/// case just isolated nodes can be filtered out from the
+/// \tparam NF The type of the node filter map.
-/// graph.
+/// It must be a \c bool (or convertible) node map of the
+/// adapted (di)graph. The default type is
+/// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
+///
+/// \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 _Digraph,
+template<typename GR, typename NF>
-typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+class FilterNodes {
-bool _checked = true>
 #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;
 public:
 /// \brief Constructor
 ///
-/// Creates an adaptor for the given digraph or graph with
+/// Creates a subgraph for the given digraph or graph with the
 /// given node filter map.
-FilterNodes(Digraph& _digraph, NodeFilterMap& node_filter) :
+FilterNodes(GR& graph, NodeFilterMap& node_filter) :
-Parent(), const_true_map(true) {
+Parent(), const_true_map(true)
-Parent::setDigraph(_digraph);
+{
+Parent::setDigraph(graph);
 Parent::setNodeFilterMap(node_filter);
 Parent::setArcFilterMap(const_true_map);
 }
-/// \brief Hides the node of the graph
+/// \brief Sets the status of the given node
 ///
-/// This function hides \c n in the digraph or graph, i.e. the iteration
+/// This function sets the status of the given node.
-/// jumps over it. This is done by simply setting the value of \c n
+/// It is done by simply setting the assigned value of \c n
-/// to be false in the corresponding node map.
+/// to \c v in the node filter map.
-void hide(const Node& n) const { Parent::hide(n); }
+void status(const Node& n, bool v) const { Parent::status(n, v); }
-/// \brief Unhides the node of the graph
+/// \brief Returns the status of the given node
 ///
-/// The value of \c n is set to be true in the node-map which stores
+/// This function returns the status of the given node.
-/// hide information. If \c n was hidden previuosly, then it is shown
+/// It is \c true if the given node is enabled (i.e. not hidden).
-/// again
+bool status(const Node& n) const { return Parent::status(n); }
-void unHide(const Node& n) const { Parent::unHide(n); }
+/// \brief Disables the given node
-/// \brief Returns true if \c n is hidden.
+///
-///
+/// This function disables the given node, so the iteration
-/// Returns true if \c n is hidden.
+/// jumps over it.
-///
+/// It is the same as \ref status() "status(n, false)".
-bool hidden(const Node& n) const { return Parent::hidden(n); }
+void disable(const Node& n) const { Parent::status(n, false); }
+/// \brief Enables the given node
+///
+/// This function enables the given node.
+/// 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;
 Parent::setGraph(_graph);
 Parent::setNodeFilterMap(node_filter_map);
 Parent::setEdgeFilterMap(const_true_map);
 }
-void hide(const Node& n) const { Parent::hide(n); }
+void status(const Node& n, bool v) const { Parent::status(n, v); }
-void unHide(const Node& n) const { Parent::unHide(n); }
+bool status(const Node& n) const { return Parent::status(n); }
-bool hidden(const Node& n) const { return Parent::hidden(n); }
+void disable(const Node& n) const { Parent::status(n, false); }
+void enable(const Node& n) const { Parent::status(n, true); }
 };
-/// \brief Just gives back a FilterNodes adaptor
+/// \brief Returns a read-only FilterNodes adaptor
 ///
-/// Just gives back a FilterNodes adaptor
+/// This function just returns a read-only \ref FilterNodes adaptor.
-template<typename Digraph, typename NodeFilterMap>
+/// \ingroup graph_adaptors
-FilterNodes<const Digraph, NodeFilterMap>
+/// \relates FilterNodes
-filterNodes(const Digraph& digraph, NodeFilterMap& nfm) {
+template<typename GR, typename NF>
-return FilterNodes<const Digraph, NodeFilterMap>(digraph, nfm);
+FilterNodes<const GR, NF>
+filterNodes(const GR& graph, NF& node_filter_map) {
+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 An adaptor for hiding arcs from a digraph.
+/// \brief Adaptor class for hiding arcs in a digraph.
 ///
-/// FilterArcs adaptor hides arcs in a digraph. A bool arc map must
+/// FilterArcs adaptor can be used for hiding arcs in a digraph.
-/// be specified, which defines the filters for arcs. Just the
+/// A \c bool arc map must be specified, which defines the filter for
-/// unfiltered arcs are shown in the subdigraph. The FilterArcs is
+/// the arcs. Only the arcs with \c true filter value are shown in the
-/// conform to the \ref concepts::Digraph "Digraph concept".
+/// subdigraph. This adaptor conforms to the \ref concepts::Digraph
-///
+/// "Digraph" concept.
-/// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+///
-/// "Digraph concept". The type can be specified to be const.
+/// The adapted digraph can also be modified through this adaptor
-/// \tparam _ArcFilterMap A bool valued arc map of the the adapted
+/// by adding or removing nodes or arcs, unless the \c GR template
-/// graph.
+/// parameter is set to be \c const.
-template<typename _Digraph, typename _ArcFilterMap>
+///
+/// \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 AF The type of the arc filter map.
+/// It must be a \c bool (or convertible) arc map of the
+/// 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 GR,
+typename AF>
+class FilterArcs {
+#else
+template<typename GR,
+typename AF = typename GR::template ArcMap<bool> >
 class FilterArcs :
-public SubDigraph<_Digraph, ConstMap<typename _Digraph::Node, bool>,
+public DigraphAdaptorExtender<
-_ArcFilterMap, false> {
+SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> > {
-public:
+#endif
-typedef _Digraph Digraph;
+public:
-typedef _ArcFilterMap ArcFilterMap;
+/// The type of the adapted digraph.
+typedef GR Digraph;
-typedef SubDigraph<Digraph, ConstMap<typename Digraph::Node, bool>,
+/// The type of the arc filter map.
-ArcFilterMap, false> Parent;
+typedef AF ArcFilterMap;
+typedef DigraphAdaptorExtender<
+SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> >
+Parent;
 typedef typename Parent::Arc Arc;
 protected:
 ConstMap<typename Digraph::Node, bool> const_true_map;
 public:
 /// \brief Constructor
 ///
-/// Creates a FilterArcs adaptor for the given graph with
+/// Creates a subdigraph for the given digraph with the given arc
-/// given arc map filter.
+/// filter map.
 FilterArcs(Digraph& digraph, ArcFilterMap& arc_filter)
 : Parent(), const_true_map(true) {
 Parent::setDigraph(digraph);
 Parent::setNodeFilterMap(const_true_map);
 Parent::setArcFilterMap(arc_filter);
 }
-/// \brief Hides the arc of the graph
+/// \brief Sets the status of the given arc
 ///
-/// This function hides \c a in the graph, i.e. the iteration
+/// This function sets the status of the given arc.
-/// jumps over it. This is done by simply setting the value of \c a
+/// It is done by simply setting the assigned value of \c a
-/// to be false in the corresponding arc map.
+/// to \c v in the arc filter map.
-void hide(const Arc& a) const { Parent::hide(a); }
+void status(const Arc& a, bool v) const { Parent::status(a, v); }
-/// \brief Unhides the arc of the graph
+/// \brief Returns the status of the given arc
 ///
-/// The value of \c a is set to be true in the arc-map which stores
+/// This function returns the status of the given arc.
-/// hide information. If \c a was hidden previuosly, then it is shown
+/// It is \c true if the given arc is enabled (i.e. not hidden).
-/// again
+bool status(const Arc& a) const { return Parent::status(a); }
-void unHide(const Arc& a) const { Parent::unHide(a); }
+/// \brief Disables the given arc
-/// \brief Returns true if \c a is hidden.
+///
-///
+/// This function disables the given arc in the subdigraph,
-/// Returns true if \c a is hidden.
+/// so the iteration jumps over it.
-///
+/// It is the same as \ref status() "status(a, false)".
-bool hidden(const Arc& a) const { return Parent::hidden(a); }
+void disable(const Arc& a) const { Parent::status(a, false); }
+/// \brief Enables the given arc
+///
+/// This function enables the given arc in the subdigraph.
+/// It is the same as \ref status() "status(a, true)".
+void enable(const Arc& a) const { Parent::status(a, true); }
 };
-/// \brief Just gives back an FilterArcs adaptor
+/// \brief Returns a read-only FilterArcs adaptor
 ///
-/// Just gives back an FilterArcs adaptor
+/// This function just returns a read-only \ref FilterArcs adaptor.
-template<typename Digraph, typename ArcFilterMap>
+/// \ingroup graph_adaptors
-FilterArcs<const Digraph, ArcFilterMap>
+/// \relates FilterArcs
-filterArcs(const Digraph& digraph, ArcFilterMap& afm) {
+template<typename GR, typename AF>
-return FilterArcs<const Digraph, ArcFilterMap>(digraph, afm);
+FilterArcs<const GR, AF>
+filterArcs(const GR& digraph, AF& arc_filter_map) {
+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 An adaptor for hiding edges from a graph.
+/// \brief Adaptor class for hiding edges in a graph.
 ///
-/// FilterEdges adaptor hides edges in a digraph. A bool edge map must
+/// FilterEdges adaptor can be used for hiding edges in a graph.
-/// be specified, which defines the filters for edges. Just the
+/// A \c bool edge map must be specified, which defines the filter for
-/// unfiltered edges are shown in the subdigraph. The FilterEdges is
+/// the edges. Only the edges with \c true filter value are shown in the
-/// conform to the \ref concepts::Graph "Graph concept".
+/// subgraph. This adaptor conforms to the \ref concepts::Graph
-///
+/// "Graph" concept.
-/// \tparam _Graph It must be conform to the \ref concepts::Graph
+///
-/// "Graph concept". The type can be specified to be const.
+/// The adapted graph can also be modified through this adaptor
-/// \tparam _EdgeFilterMap A bool valued edge map of the the adapted
+/// by adding or removing nodes or edges, unless the \c GR template
-/// graph.
+/// parameter is set to be \c const.
-template<typename _Graph, typename _EdgeFilterMap>
+///
+/// \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 EF The type of the edge filter map.
+/// It must be a \c bool (or convertible) edge map of the
+/// 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 GR,
+typename EF>
+class FilterEdges {
+#else
+template<typename GR,
+typename EF = typename GR::template EdgeMap<bool> >
 class FilterEdges :
-public SubGraph<_Graph, ConstMap<typename _Graph::Node,bool>,
+public GraphAdaptorExtender<
-_EdgeFilterMap, false> {
+SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> > {
-public:
+#endif
-typedef _Graph Graph;
+public:
-typedef _EdgeFilterMap EdgeFilterMap;
+/// The type of the adapted graph.
-typedef SubGraph<Graph, ConstMap<typename Graph::Node,bool>,
+typedef GR Graph;
-EdgeFilterMap, false> Parent;
+/// The type of the edge filter map.
+typedef EF EdgeFilterMap;
+typedef GraphAdaptorExtender<
+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);
 public:
 /// \brief Constructor
 ///
-/// Creates a FilterEdges adaptor for the given graph with
+/// Creates a subgraph for the given graph with the given edge
-/// given edge map filters.
+/// filter map.
-FilterEdges(Graph& _graph, EdgeFilterMap& edge_filter_map) :
+FilterEdges(Graph& graph, EdgeFilterMap& edge_filter_map) :
 Parent(), const_true_map(true) {
-Parent::setGraph(_graph);
+Parent::setGraph(graph);
 Parent::setNodeFilterMap(const_true_map);
 Parent::setEdgeFilterMap(edge_filter_map);
 }
-/// \brief Hides the edge of the graph
+/// \brief Sets the status of the given edge
 ///
-/// This function hides \c e in the graph, i.e. the iteration
+/// This function sets the status of the given edge.
-/// jumps over it. This is done by simply setting the value of \c e
+/// It is done by simply setting the assigned value of \c e
-/// to be false in the corresponding edge-map.
+/// to \c v in the edge filter map.
-void hide(const Edge& e) const { Parent::hide(e); }
+void status(const Edge& e, bool v) const { Parent::status(e, v); }
-/// \brief Unhides the edge of the graph
+/// \brief Returns the status of the given edge
 ///
-/// The value of \c e is set to be true in the edge-map which stores
+/// This function returns the status of the given edge.
-/// hide information. If \c e was hidden previuosly, then it is shown
+/// It is \c true if the given edge is enabled (i.e. not hidden).
-/// again
+bool status(const Edge& e) const { return Parent::status(e); }
-void unHide(const Edge& e) const { Parent::unHide(e); }
+/// \brief Disables the given edge
-/// \brief Returns true if \c e is hidden.
+///
-///
+/// This function disables the given edge in the subgraph,
-/// Returns true if \c e is hidden.
+/// so the iteration jumps over it.
-///
+/// It is the same as \ref status() "status(e, false)".
-bool hidden(const Edge& e) const { return Parent::hidden(e); }
+void disable(const Edge& e) const { Parent::status(e, false); }
+/// \brief Enables the given edge
+///
+/// This function enables the given edge in the subgraph.
+/// It is the same as \ref status() "status(e, true)".
+void enable(const Edge& e) const { Parent::status(e, true); }
 };
-/// \brief Just gives back a FilterEdges adaptor
+/// \brief Returns a read-only FilterEdges adaptor
 ///
-/// Just gives back a FilterEdges adaptor
+/// This function just returns a read-only \ref FilterEdges adaptor.
-template<typename Graph, typename EdgeFilterMap>
+/// \ingroup graph_adaptors
-FilterEdges<const Graph, EdgeFilterMap>
+/// \relates FilterEdges
-filterEdges(const Graph& graph, EdgeFilterMap& efm) {
+template<typename GR, typename EF>
-return FilterEdges<const Graph, EdgeFilterMap>(graph, efm);
+FilterEdges<const GR, EF>
+filterEdges(const GR& graph, EF& edge_filter_map) {
+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 {
 public:
 typedef _Digraph Digraph;
 return _forward < other._forward ||
 (_forward == other._forward &&
 static_cast<const Edge&>(*this) < static_cast<const Edge&>(other));
 }
 };
 void first(Node& n) const {
 _digraph->first(n);
 }
 void erase(const Edge& i) { _digraph->erase(i); }
 void clear() { _digraph->clear(); }
 typedef NodeNumTagIndicator<Digraph> NodeNumTag;
-int nodeNum() const { return 2 * _digraph->arcNum(); }
+int nodeNum() const { return _digraph->nodeNum(); }
-typedef EdgeNumTagIndicator<Digraph> EdgeNumTag;
+typedef ArcNumTagIndicator<Digraph> ArcNumTag;
 int arcNum() const { return 2 * _digraph->arcNum(); }
+typedef ArcNumTag EdgeNumTag;
 int edgeNum() const { return _digraph->arcNum(); }
-typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+typedef FindArcTagIndicator<Digraph> FindArcTag;
 Arc findArc(Node s, Node t, Arc p = INVALID) const {
 if (p == INVALID) {
 Edge arc = _digraph->findArc(s, t);
 if (arc != INVALID) return direct(arc, true);
 arc = _digraph->findArc(t, s);
 if (arc != INVALID) return direct(arc, false);
 }
 return INVALID;
 }
+typedef FindArcTag FindEdgeTag;
 Edge findEdge(Node s, Node t, Edge p = INVALID) const {
 if (s != t) {
 if (p == INVALID) {
 Edge arc = _digraph->findArc(s, t);
 if (arc != INVALID) return arc;
 arc = _digraph->findArc(t, s);
 if (arc != INVALID) return arc;
-} else if (_digraph->s(p) == s) {
+} else if (_digraph->source(p) == s) {
 Edge arc = _digraph->findArc(s, t, p);
 if (arc != INVALID) return arc;
 arc = _digraph->findArc(t, s);
 if (arc != INVALID) return arc;
 } else {
 typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag;
 typedef _Value Value;
 typedef Arc Key;
+typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReturnValue;
+typedef typename MapTraits<MapImpl>::ReturnValue ReturnValue;
+typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReference;
+typedef typename MapTraits<MapImpl>::ReturnValue Reference;
 ArcMapBase(const Adaptor& adaptor) :
 _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
 ArcMapBase(const Adaptor& adaptor, const Value& v)
 } else {
 _backward.set(a, v);
 }
 }
-typename MapTraits<MapImpl>::ConstReturnValue
+ConstReturnValue operator[](const Arc& a) const {
-operator[](const Arc& a) const {
 if (direction(a)) {
 return _forward[a];
 } else {
 return _backward[a];
 }
 }
-typename MapTraits<MapImpl>::ReturnValue
+ReturnValue operator[](const Arc& a) {
-operator[](const Arc& a) {
 if (direction(a)) {
 return _forward[a];
 } else {
 return _backward[a];
 }
 {
 public:
 typedef _Value Value;
 typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent;
-ArcMap(const Adaptor& adaptor)
+explicit ArcMap(const Adaptor& adaptor)
 : Parent(adaptor) {}
 ArcMap(const Adaptor& adaptor, const Value& value)
 : Parent(adaptor, value) {}
 };
 typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
+typedef typename ItemSetTraits<Digraph, Edge>::ItemNotifier EdgeNotifier;
+EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
 protected:
 UndirectorBase() : _digraph(0) {}
 Digraph* _digraph;
 };
 /// \ingroup graph_adaptors
 ///
-/// \brief Undirect the graph
+/// \brief Adaptor class for viewing a digraph as an undirected graph.
 ///
-/// This adaptor makes an undirected graph from a directed
+/// Undirector adaptor can be used for viewing a digraph as an undirected
-/// graph. All arcs of the underlying digraph will be showed in the
+/// graph. All arcs of the underlying digraph are showed in the
-/// adaptor as an edge. The Orienter adaptor is conform to the \ref
+/// adaptor as an edge (and also as a pair of arcs, of course).
-/// concepts::Graph "Graph concept".
+/// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
 ///
-/// \tparam _Digraph It must be conform to the \ref
+/// The adapted digraph can also be modified through this adaptor
-/// concepts::Digraph "Digraph concept". The type can be specified
+/// by adding or removing nodes or edges, unless the \c GR template
-/// to const.
+/// parameter is set to be \c const.
-template<typename _Digraph>
+///
-class Undirector
+/// \tparam GR The type of the adapted digraph.
-: public GraphAdaptorExtender<UndirectorBase<_Digraph> > {
+/// It must conform to the \ref concepts::Digraph "Digraph" concept.
-public:
+/// It can also be specified to be \c const.
-typedef _Digraph Digraph;
+///
-typedef GraphAdaptorExtender<UndirectorBase<Digraph> > Parent;
+/// \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 GR>
+#ifdef DOXYGEN
+class Undirector {
+#else
+class Undirector :
+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 a undirected graph from the given digraph
+/// Creates an undirected graph from the given digraph.
-Undirector(_Digraph& digraph) {
+Undirector(Digraph& digraph) {
 setDigraph(digraph);
 }
-/// \brief ArcMap combined from two original ArcMap
+/// \brief Arc map combined from two original arc maps
 ///
-/// This class adapts two original digraph ArcMap to
+/// This map adaptor class adapts two arc maps of the underlying
-/// get an arc map on the undirected graph.
+/// digraph to get an arc map of the undirected graph.
-template <typename _ForwardMap, typename _BackwardMap>
+/// Its value type is inherited from the first arc map type
+/// (\c %ForwardMap).
+template <typename ForwardMap, typename BackwardMap>
 class CombinedArcMap {
 public:
-typedef _ForwardMap ForwardMap;
+/// The key type of the map
-typedef _BackwardMap BackwardMap;
+typedef typename Parent::Arc Key;
+/// The value type of the map
+typedef typename ForwardMap::Value Value;
 typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag;
-typedef typename ForwardMap::Value Value;
+typedef typename MapTraits<ForwardMap>::ReturnValue ReturnValue;
-typedef typename Parent::Arc Key;
+typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReturnValue;
+typedef typename MapTraits<ForwardMap>::ReturnValue Reference;
-/// \brief Constructor
+typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReference;
-///
 /// Constructor
 CombinedArcMap(ForwardMap& forward, BackwardMap& backward)
 : _forward(&forward), _backward(&backward) {}
+/// Sets the value associated with the given key.
-/// \brief Sets the value associated with a key.
-///
-/// Sets the value associated with a key.
 void set(const Key& e, const Value& a) {
 if (Parent::direction(e)) {
 _forward->set(e, a);
 } else {
 _backward->set(e, a);
 }
 }
-/// \brief Returns the value associated with a key.
+/// Returns the value associated with the given key.
-///
+ConstReturnValue operator[](const Key& e) const {
-/// Returns the value associated with a key.
-typename MapTraits<ForwardMap>::ConstReturnValue
-operator[](const Key& e) const {
 if (Parent::direction(e)) {
 return (*_forward)[e];
 } else {
 return (*_backward)[e];
 }
 }
-/// \brief Returns the value associated with a key.
+/// Returns a reference to the value associated with the given key.
-///
+ReturnValue operator[](const Key& e) {
-/// Returns the value associated with a key.
-typename MapTraits<ForwardMap>::ReturnValue
-operator[](const Key& e) {
 if (Parent::direction(e)) {
 return (*_forward)[e];
 } else {
 return (*_backward)[e];
 }
 ForwardMap* _forward;
 BackwardMap* _backward;
 };
-/// \brief Just gives back a combined arc map
+/// \brief Returns a combined arc map
 ///
-/// Just gives back a combined arc map
+/// This function just returns a combined arc map.
 template <typename ForwardMap, typename BackwardMap>
 static CombinedArcMap<ForwardMap, BackwardMap>
 combinedArcMap(ForwardMap& forward, BackwardMap& backward) {
 return CombinedArcMap<ForwardMap, BackwardMap>(forward, backward);
 }
 const BackwardMap>(forward, backward);
 }
 };
-/// \brief Just gives back an undirected view of the given digraph
+/// \brief Returns a read-only Undirector adaptor
 ///
-/// Just gives back an undirected view of the given digraph
+/// This function just returns a read-only \ref Undirector adaptor.
-template<typename Digraph>
+/// \ingroup graph_adaptors
-Undirector<const Digraph>
+/// \relates Undirector
-undirector(const Digraph& digraph) {
+template<typename GR>
-return Undirector<const Digraph>(digraph);
+Undirector<const GR> undirector(const GR& digraph) {
+return Undirector<const GR>(digraph);
 }
 template <typename _Graph, typename _DirectionMap>
 class OrienterBase {
 public:
 }
 void first(Node& i) const { _graph->first(i); }
 void first(Arc& i) const { _graph->first(i); }
 void firstIn(Arc& i, const Node& n) const {
-bool d;
+bool d = true;
 _graph->firstInc(i, d, n);
 while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
 }
 void firstOut(Arc& i, const Node& n ) const {
-bool d;
+bool d = true;
 _graph->firstInc(i, d, n);
 while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
 }
 void next(Node& i) const { _graph->next(i); }
 }
 typedef NodeNumTagIndicator<Graph> NodeNumTag;
 int nodeNum() const { return _graph->nodeNum(); }
-typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
+typedef EdgeNumTagIndicator<Graph> ArcNumTag;
 int arcNum() const { return _graph->edgeNum(); }
-typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+typedef FindEdgeTagIndicator<Graph> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
-const Arc& prev = INVALID) {
+const Arc& prev = INVALID) const {
-Arc arc = prev;
+Arc arc = _graph->findEdge(u, v, prev);
-bool d = arc == INVALID ? true : (*_direction)[arc];
+while (arc != INVALID && source(arc) != u) {
-if (d) {
 arc = _graph->findEdge(u, v, arc);
-while (arc != INVALID && !(*_direction)[arc]) {
-_graph->findEdge(u, v, arc);
-}
-if (arc != INVALID) return arc;
-}
-_graph->findEdge(v, u, arc);
-while (arc != INVALID && (*_direction)[arc]) {
-_graph->findEdge(u, v, arc);
 }
 return arc;
 }
 Node addNode() {
 return Node(_graph->addNode());
 }
 Arc addArc(const Node& u, const Node& v) {
-Arc arc = _graph->addArc(u, v);
+Arc arc = _graph->addEdge(u, v);
-_direction->set(arc, _graph->source(arc) == u);
+_direction->set(arc, _graph->u(arc) == u);
 return arc;
 }
 void erase(const Node& i) { _graph->erase(i); }
 void erase(const Arc& i) { _graph->erase(i); }
 };
 /// \ingroup graph_adaptors
 ///
-/// \brief Orients the edges of the graph to get a digraph
+/// \brief Adaptor class for orienting the edges of a graph to get a digraph
 ///
-/// This adaptor orients each edge in the undirected graph. The
+/// Orienter adaptor can be used for orienting the edges of a graph to
-/// direction of the arcs stored in an edge node map.  The arcs can
+/// get a digraph. A \c bool edge map of the underlying graph must be
-/// be easily reverted by the \c reverseArc() member function in the
+/// specified, which define the direction of the arcs in the adaptor.
-/// adaptor. The Orienter adaptor is conform to the \ref
+/// The arcs can be easily reversed by the \c reverseArc() member function
-/// concepts::Digraph "Digraph concept".
+/// of the adaptor.
-///
+/// This class conforms to the \ref concepts::Digraph "Digraph" concept.
-/// \tparam _Graph It must be conform to the \ref concepts::Graph
+///
-/// "Graph concept". The type can be specified to be const.
+/// The adapted graph can also be modified through this adaptor
-/// \tparam _DirectionMap A bool valued edge map of the the adapted
+/// by adding or removing nodes or arcs, unless the \c GR template
-/// graph.
+/// parameter is set to be \c const.
 ///
-/// \sa orienter
+/// \tparam GR The type of the adapted graph.
-template<typename _Graph,
+/// It must conform to the \ref concepts::Graph "Graph" concept.
-typename DirectionMap = typename _Graph::template EdgeMap<bool> >
+/// It can also be specified to be \c const.
+/// \tparam DM The type of the direction map.
+/// It must be a \c bool (or convertible) edge map of the
+/// 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 GR,
+typename DM>
+class Orienter {
+#else
+template<typename GR,
+typename DM = typename GR::template EdgeMap<bool> >
 class Orienter :
-public DigraphAdaptorExtender<OrienterBase<_Graph, DirectionMap> > {
+public DigraphAdaptorExtender<OrienterBase<GR, DM> > {
-public:
+#endif
-typedef _Graph Graph;
+public:
-typedef DigraphAdaptorExtender<
-OrienterBase<_Graph, DirectionMap> > Parent;
+/// The type of the adapted graph.
+typedef GR Graph;
+/// The type of the direction edge map.
+typedef DM DirectionMap;
+typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent;
 typedef typename Parent::Arc Arc;
 protected:
 Orienter() { }
 public:
-/// \brief Constructor of the adaptor
+/// \brief Constructor
 ///
-/// Constructor of the adaptor
+/// Constructor of the adaptor.
 Orienter(Graph& graph, DirectionMap& direction) {
 setGraph(graph);
 setDirectionMap(direction);
 }
-/// \brief Reverse arc
+/// \brief Reverses the given arc
 ///
-/// It reverse the given arc. It simply negate the direction in the map.
+/// This function reverses the given arc.
+/// It is done by simply negate the assigned value of \c a
+/// in the direction map.
 void reverseArc(const Arc& a) {
 Parent::reverseArc(a);
 }
 };
-/// \brief Just gives back a Orienter
+/// \brief Returns a read-only Orienter adaptor
 ///
-/// Just gives back a Orienter
+/// This function just returns a read-only \ref Orienter adaptor.
-template<typename Graph, typename DirectionMap>
+/// \ingroup graph_adaptors
-Orienter<const Graph, DirectionMap>
+/// \relates Orienter
-orienter(const Graph& graph, DirectionMap& dm) {
+template<typename GR, typename DM>
-return Orienter<const Graph, DirectionMap>(graph, dm);
+Orienter<const GR, DM>
+orienter(const GR& graph, DM& direction_map) {
+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:
 }
 /// \ingroup graph_adaptors
 ///
-/// \brief An adaptor for composing the residual graph for directed
+/// \brief Adaptor class for composing the residual digraph for directed
 /// flow and circulation problems.
 ///
-/// An adaptor for composing the residual graph for directed flow and
+/// Residual can be used for composing the \e residual digraph for directed
-/// circulation problems.  Let \f$ G=(V, A) \f$ be a directed graph
+/// flow and circulation problems. Let \f$ G=(V, A) \f$ be a directed graph
-/// and let \f$ F \f$ be a number type. Let moreover \f$ f,c:A\to F \f$,
+/// and let \f$ F \f$ be a number type. Let \f$ flow, cap: A\to F \f$ be
-/// be functions on the arc-set.
+/// functions on the arcs.
-///
+/// This adaptor implements a digraph structure with node set \f$ V \f$
-/// Then Residual implements the digraph structure with
+/// and arc set \f$ A_{forward}\cup A_{backward} \f$,
-/// node-set \f$ V \f$ and arc-set \f$ A_{forward}\cup A_{backward} \f$,
+/// where \f$ A_{forward}=\{uv : uv\in A, flow(uv)<cap(uv)\} \f$ and
-/// where \f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$ and
+/// \f$ A_{backward}=\{vu : uv\in A, flow(uv)>0\} \f$, i.e. the so
-/// \f$ A_{backward}=\{vu : uv\in A, f(uv)>0\} \f$, i.e. the so
+/// called residual digraph.
-/// called residual graph.  When we take the union
+/// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken,
-/// \f$ A_{forward}\cup A_{backward} \f$, multiplicities are counted,
+/// multiplicities are counted, i.e. the adaptor has exactly
-/// i.e.  if an arc is in both \f$ A_{forward} \f$ and
+/// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel
-/// \f$ A_{backward} \f$, then in the adaptor it appears in both
+/// arcs).
-/// orientation.
+/// This class conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
-/// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+/// \tparam GR The type of the adapted digraph.
-/// "Digraph concept". The type is implicitly const.
+/// It must conform to the \ref concepts::Digraph "Digraph" concept.
-/// \tparam _CapacityMap An arc map of some numeric type, it defines
+/// It is implicitly \c const.
-/// the capacities in the flow problem. The map is implicitly const.
+/// \tparam CM The type of the capacity map.
-/// \tparam _FlowMap An arc map of some numeric type, it defines
+/// It must be an arc map of some numerical type, which defines
-/// the capacities in the flow problem.
+/// the capacities in the flow problem. It is implicitly \c const.
-/// \tparam _Tolerance Handler for inexact computation.
+/// The default type is
-template<typename _Digraph,
+/// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-typename _CapacityMap = typename _Digraph::template ArcMap<int>,
+/// \tparam FM The type of the flow map.
-typename _FlowMap = _CapacityMap,
+/// It must be an arc map of some numerical type, which defines
-typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+/// the flow values in the flow problem. The default type is \c CM.
+/// \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 GR, typename CM, typename FM, typename TL>
+class Residual
+#else
+template<typename GR,
+typename CM = typename GR::template ArcMap<int>,
+typename FM = CM,
+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,
+#endif
-_FlowMap, _Tolerance> > >
 {
 public:
-typedef _Digraph Digraph;
+/// The type of the underlying digraph.
-typedef _CapacityMap CapacityMap;
+typedef GR Digraph;
-typedef _FlowMap FlowMap;
+/// The type of the capacity map.
-typedef _Tolerance Tolerance;
+typedef CM CapacityMap;
+/// The type of the flow map.
+typedef FM FlowMap;
+/// 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;
 BackwardFilter _backward_filter;
 ArcFilter _arc_filter;
 public:
-/// \brief Constructor of the residual digraph.
+/// \brief Constructor
 ///
-/// Constructor of the residual graph. The parameters are the digraph,
+/// Constructor of the residual digraph adaptor. The parameters are the
-/// the flow map, the capacity map and a tolerance object.
+/// digraph, the capacity map, the flow map, and a tolerance object.
 Residual(const Digraph& digraph, const CapacityMap& capacity,
 FlowMap& flow, const Tolerance& tolerance = Tolerance())
 : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph),
 _forward_filter(capacity, flow, tolerance),
 _backward_filter(capacity, flow, tolerance),
 Parent::setArcFilterMap(_arc_filter);
 }
 typedef typename Parent::Arc Arc;
-/// \brief Gives back the residual capacity of the arc.
+/// \brief Returns the residual capacity of the given arc.
 ///
-/// Gives back the residual capacity of the arc.
+/// Returns the residual capacity of the given arc.
 Value residualCapacity(const Arc& a) const {
 if (Undirected::direction(a)) {
 return (*_capacity)[a] - (*_flow)[a];
 } else {
 return (*_flow)[a];
 }
 }
-/// \brief Augment on the given arc in the residual graph.
+/// \brief Augments on the given arc in the residual digraph.
 ///
-/// Augment on the given arc in the residual graph. It increase
+/// Augments on the given arc in the residual digraph. It increases
-/// or decrease the flow on the original arc depend on the direction
+/// or decreases the flow value on the original arc according to the
-/// of the residual arc.
+/// direction of the residual arc.
 void augment(const Arc& a, const Value& v) const {
 if (Undirected::direction(a)) {
 _flow->set(a, (*_flow)[a] + v);
 } else {
 _flow->set(a, (*_flow)[a] - v);
 }
 }
-/// \brief Returns the direction of the arc.
+/// \brief Returns \c true if the given residual arc is a forward arc.
 ///
-/// Returns true when the arc is same oriented as the original arc.
+/// Returns \c true if the given residual arc has the same orientation
+/// as the original arc, i.e. it is a so called forward arc.
 static bool forward(const Arc& a) {
 return Undirected::direction(a);
 }
-/// \brief Returns the direction of the arc.
+/// \brief Returns \c true if the given residual arc is a backward arc.
 ///
-/// Returns true when the arc is opposite oriented as the original arc.
+/// Returns \c true if the given residual arc has the opposite orientation
+/// than the original arc, i.e. it is a so called backward arc.
 static bool backward(const Arc& a) {
 return !Undirected::direction(a);
 }
-/// \brief Gives back the forward oriented residual arc.
+/// \brief Returns the forward oriented residual arc.
 ///
-/// Gives back the forward oriented residual arc.
+/// Returns the forward oriented residual arc related to the given
+/// arc of the underlying digraph.
 static Arc forward(const typename Digraph::Arc& a) {
 return Undirected::direct(a, true);
 }
-/// \brief Gives back the backward oriented residual arc.
+/// \brief Returns the backward oriented residual arc.
 ///
-/// Gives back the backward oriented residual arc.
+/// Returns the backward oriented residual arc related to the given
+/// arc of the underlying digraph.
 static Arc backward(const typename Digraph::Arc& a) {
 return Undirected::direct(a, false);
 }
 /// \brief Residual capacity map.
 ///
-/// In generic residual graph the residual capacity can be obtained
+/// This map adaptor class can be used for obtaining the residual
-/// as a map.
+/// capacities as an arc map of the residual digraph.
+/// Its value type is inherited from the capacity map.
 class ResidualCapacity {
 protected:
 const Adaptor* _adaptor;
 public:
-/// The Key type
+/// The key type of the map
 typedef Arc Key;
-/// The Value type
+/// The value type of the map
-typedef typename _CapacityMap::Value Value;
+typedef typename CapacityMap::Value Value;
 /// Constructor
 ResidualCapacity(const Adaptor& adaptor) : _adaptor(&adaptor) {}
-/// \e
+/// Returns the value associated with the given residual arc
 Value operator[](const Arc& a) const {
 return _adaptor->residualCapacity(a);
 }
 };
+/// \brief Returns a residual capacity map
+///
+/// This function just returns a residual capacity map.
+ResidualCapacity residualCapacity() const {
+return ResidualCapacity(*this);
+}
 };
+/// \brief Returns a (read-only) Residual adaptor
+///
+/// This function just returns a (read-only) \ref Residual adaptor.
+/// \ingroup graph_adaptors
+/// \relates Residual
+template<typename GR, typename CM, typename FM>
+Residual<GR, CM, FM> residual(const GR& digraph,
+const CM& capacity_map,
+FM& flow_map) {
+return Residual<GR, CM, FM> (digraph, capacity_map, flow_map);
+}
 template <typename _Digraph>
 class SplitNodesBase {
 public:
 static Arc arc(const DigraphArc& e) {
 return Arc(e);
 }
 typedef True NodeNumTag;
 int nodeNum() const {
 return  2 * countNodes(*_digraph);
 }
-typedef True EdgeNumTag;
+typedef True ArcNumTag;
 int arcNum() const {
 return countArcs(*_digraph) + countNodes(*_digraph);
 }
-typedef True FindEdgeTag;
+typedef True FindArcTag;
 Arc findArc(const Node& u, const Node& v,
 const Arc& prev = INVALID) const {
-if (inNode(u)) {
+if (inNode(u) && outNode(v)) {
-if (outNode(v)) {
+if (static_cast<const DigraphNode&>(u) ==
-if (static_cast<const DigraphNode&>(u) ==
+static_cast<const DigraphNode&>(v) && prev == INVALID) {
-static_cast<const DigraphNode&>(v) && prev == INVALID) {
+return Arc(u);
-return Arc(u);
-}
 }
-} else {
+}
-if (inNode(v)) {
+else if (outNode(u) && inNode(v)) {
 return Arc(::lemon::findArc(*_digraph, u, v, prev));
-}
 }
 return INVALID;
 }
 private:
 : public MapTraits<typename Parent::template NodeMap<_Value> > {
 typedef typename Parent::template NodeMap<_Value> NodeImpl;
 public:
 typedef Node Key;
 typedef _Value Value;
+typedef typename MapTraits<NodeImpl>::ReferenceMapTag ReferenceMapTag;
+typedef typename MapTraits<NodeImpl>::ReturnValue ReturnValue;
+typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReturnValue;
+typedef typename MapTraits<NodeImpl>::ReturnValue Reference;
+typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReference;
 NodeMapBase(const Adaptor& adaptor)
 : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {}
 NodeMapBase(const Adaptor& adaptor, const Value& value)
 : _in_map(*adaptor._digraph, value),
 void set(const Node& key, const Value& val) {
 if (Adaptor::inNode(key)) { _in_map.set(key, val); }
 else {_out_map.set(key, val); }
 }
-typename MapTraits<NodeImpl>::ReturnValue
+ReturnValue operator[](const Node& key) {
-operator[](const Node& key) {
 if (Adaptor::inNode(key)) { return _in_map[key]; }
 else { return _out_map[key]; }
 }
-typename MapTraits<NodeImpl>::ConstReturnValue
+ConstReturnValue operator[](const Node& key) const {
-operator[](const Node& key) const {
 if (Adaptor::inNode(key)) { return _in_map[key]; }
 else { return _out_map[key]; }
 }
 private:
 typedef typename Parent::template ArcMap<_Value> ArcImpl;
 typedef typename Parent::template NodeMap<_Value> NodeImpl;
 public:
 typedef Arc Key;
 typedef _Value Value;
+typedef typename MapTraits<ArcImpl>::ReferenceMapTag ReferenceMapTag;
+typedef typename MapTraits<ArcImpl>::ReturnValue ReturnValue;
+typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReturnValue;
+typedef typename MapTraits<ArcImpl>::ReturnValue Reference;
+typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReference;
 ArcMapBase(const Adaptor& adaptor)
 : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {}
 ArcMapBase(const Adaptor& adaptor, const Value& value)
 : _arc_map(*adaptor._digraph, value),
 } else {
 _node_map.set(key._item.second(), val);
 }
 }
-typename MapTraits<ArcImpl>::ReturnValue
+ReturnValue operator[](const Arc& key) {
-operator[](const Arc& key) {
 if (Adaptor::origArc(key)) {
 return _arc_map[key._item.first()];
 } else {
 return _node_map[key._item.second()];
 }
 }
-typename MapTraits<ArcImpl>::ConstReturnValue
+ConstReturnValue operator[](const Arc& key) const {
-operator[](const Arc& key) const {
 if (Adaptor::origArc(key)) {
 return _arc_map[key._item.first()];
 } else {
 return _node_map[key._item.second()];
 }
 };
 /// \ingroup graph_adaptors
 ///
-/// \brief Split the nodes of a directed graph
+/// \brief Adaptor class for splitting the nodes of a digraph.
 ///
-/// The SplitNodes adaptor splits each node into an in-node and an
+/// SplitNodes adaptor can be used for splitting each node into an
-/// out-node. Formaly, the adaptor replaces each \f$ u \f$ node in
+/// \e in-node and an \e out-node in a digraph. Formaly, the adaptor
-/// the digraph with two nodes(namely node \f$ u_{in} \f$ and node
+/// replaces each node \f$ u \f$ in the digraph with two nodes,
-/// \f$ u_{out} \f$). If there is a \f$ (v, u) \f$ arc in the
+/// namely node \f$ u_{in} \f$ and node \f$ u_{out} \f$.
-/// original digraph the new target of the arc will be \f$ u_{in} \f$
+/// If there is a \f$ (v, u) \f$ arc in the original digraph, then the
-/// and similarly the source of the original \f$ (u, v) \f$ arc
+/// new target of the arc will be \f$ u_{in} \f$ and similarly the
-/// will be \f$ u_{out} \f$.  The adaptor will add for each node in
+/// source of each original \f$ (u, v) \f$ arc will be \f$ u_{out} \f$.
-/// the original digraph an additional arc which connects
+/// The adaptor adds an additional \e bind \e arc from \f$ u_{in} \f$
-/// \f$ (u_{in}, u_{out}) \f$.
+/// to \f$ u_{out} \f$ for each node \f$ u \f$ of the original digraph.
 ///
-/// The aim of this class is to run algorithm with node costs if the
+/// The aim of this class is running an algorithm with respect to node
-/// algorithm can use directly just arc costs. In this case we should use
+/// costs or capacities if the algorithm considers only arc costs or
-/// a \c SplitNodes and set the node cost of the graph to the
+/// capacities directly.
-/// bind arc in the adapted graph.
+/// 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
-/// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+/// in the adaptor.
-/// "Digraph concept". The type can be specified to be const.
+///
-template <typename _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 GR>
+#ifdef DOXYGEN
+class SplitNodes {
+#else
 class SplitNodes
-: public DigraphAdaptorExtender<SplitNodesBase<_Digraph> > {
+: public DigraphAdaptorExtender<SplitNodesBase<const GR> > {
-public:
+#endif
-typedef _Digraph Digraph;
+public:
-typedef DigraphAdaptorExtender<SplitNodesBase<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;
 typedef typename Parent::Arc Arc;
-/// \brief Constructor of the adaptor.
+/// \brief Constructor
 ///
 /// Constructor of the adaptor.
-SplitNodes(Digraph& g) {
+SplitNodes(const Digraph& g) {
 Parent::setDigraph(g);
 }
-/// \brief Returns true when the node is in-node.
+/// \brief Returns \c true if the given node is an in-node.
 ///
-/// Returns true when the node is in-node.
+/// Returns \c true if the given node is an in-node.
 static bool inNode(const Node& n) {
 return Parent::inNode(n);
 }
-/// \brief Returns true when the node is out-node.
+/// \brief Returns \c true if the given node is an out-node.
 ///
-/// Returns true when the node is out-node.
+/// Returns \c true if the given node is an out-node.
 static bool outNode(const Node& n) {
 return Parent::outNode(n);
 }
-/// \brief Returns true when the arc is arc in the original digraph.
+/// \brief Returns \c true if the given arc is an original arc.
 ///
-/// Returns true when the arc is arc in the original digraph.
+/// Returns \c true if the given arc is one of the arcs in the
+/// original digraph.
 static bool origArc(const Arc& a) {
 return Parent::origArc(a);
 }
-/// \brief Returns true when the arc binds an in-node and an out-node.
+/// \brief Returns \c true if the given arc is a bind arc.
 ///
-/// Returns true when the arc binds an in-node and an out-node.
+/// Returns \c true if the given arc is a bind arc, i.e. it connects
+/// an in-node and an out-node.
 static bool bindArc(const Arc& a) {
 return Parent::bindArc(a);
 }
-/// \brief Gives back the in-node created from the \c node.
+/// \brief Returns the in-node created from the given original node.
 ///
-/// Gives back the in-node created from the \c node.
+/// Returns the in-node created from the given original node.
 static Node inNode(const DigraphNode& n) {
 return Parent::inNode(n);
 }
-/// \brief Gives back the out-node created from the \c node.
+/// \brief Returns the out-node created from the given original node.
 ///
-/// Gives back the out-node created from the \c node.
+/// Returns the out-node created from the given original node.
 static Node outNode(const DigraphNode& n) {
 return Parent::outNode(n);
 }
-/// \brief Gives back the arc binds the two part of the node.
+/// \brief Returns the bind arc that corresponds to the given
-///
+/// original node.
-/// Gives back the arc binds the two part of the node.
+///
+/// Returns the bind arc in the adaptor that corresponds to the given
+/// original node, i.e. the arc connecting the in-node and out-node
+/// of \c n.
 static Arc arc(const DigraphNode& n) {
 return Parent::arc(n);
 }
-/// \brief Gives back the arc of the original arc.
+/// \brief Returns the arc that corresponds to the given original arc.
 ///
-/// Gives back the arc of the original arc.
+/// Returns the arc in the adaptor that corresponds to the given
+/// original arc.
 static Arc arc(const DigraphArc& a) {
 return Parent::arc(a);
 }
-/// \brief NodeMap combined from two original NodeMap
+/// \brief Node map combined from two original node maps
 ///
-/// This class adapt two of the original digraph NodeMap to
+/// This map adaptor class adapts two node maps of the original digraph
-/// get a node map on the adapted digraph.
+/// to get a node map of the split digraph.
+/// Its value type is inherited from the first node map type
+/// (\c InNodeMap).
 template <typename InNodeMap, typename OutNodeMap>
 class CombinedNodeMap {
 public:
+/// The key type of the map
 typedef Node Key;
+/// The value type of the map
 typedef typename InNodeMap::Value Value;
-/// \brief Constructor
+typedef typename MapTraits<InNodeMap>::ReferenceMapTag ReferenceMapTag;
-///
+typedef typename MapTraits<InNodeMap>::ReturnValue ReturnValue;
-/// Constructor.
+typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReturnValue;
+typedef typename MapTraits<InNodeMap>::ReturnValue Reference;
+typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReference;
+/// Constructor
 CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
 : _in_map(in_map), _out_map(out_map) {}
-/// \brief The subscript operator.
+/// Returns the value associated with the given key.
-///
+Value operator[](const Key& key) const {
-/// The subscript operator.
+if (Parent::inNode(key)) {
+return _in_map[key];
+} else {
+return _out_map[key];
+}
+}
+/// Returns a reference to the value associated with the given key.
 Value& operator[](const Key& key) {
 if (Parent::inNode(key)) {
 return _in_map[key];
 } else {
 return _out_map[key];
 }
 }
-/// \brief The const subscript operator.
+/// Sets the value associated with the given key.
-///
-/// The const subscript operator.
-Value operator[](const Key& key) const {
-if (Parent::inNode(key)) {
-return _in_map[key];
-} else {
-return _out_map[key];
-}
-}
-/// \brief The setter function of the map.
-///
-/// The setter function of the map.
 void set(const Key& key, const Value& value) {
 if (Parent::inNode(key)) {
 _in_map.set(key, value);
 } else {
 _out_map.set(key, value);
 OutNodeMap& _out_map;
 };
-/// \brief Just gives back a combined node map
+/// \brief Returns a combined node map
 ///
-/// Just gives back a combined node map
+/// This function just returns a combined node map.
 template <typename InNodeMap, typename OutNodeMap>
 static CombinedNodeMap<InNodeMap, OutNodeMap>
 combinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) {
 return CombinedNodeMap<InNodeMap, OutNodeMap>(in_map, out_map);
 }
 combinedNodeMap(const InNodeMap& in_map, const OutNodeMap& out_map) {
 return CombinedNodeMap<const InNodeMap,
 const OutNodeMap>(in_map, out_map);
 }
-/// \brief ArcMap combined from an original ArcMap and a NodeMap
+/// \brief Arc map combined from an arc map and a node map of the
-///
+/// original digraph.
-/// This class adapt an original ArcMap and a NodeMap to get an
+///
-/// arc map on the adapted digraph
+/// This map adaptor class adapts an arc map and a node map of the
-template <typename DigraphArcMap, typename DigraphNodeMap>
+/// original digraph to get an arc map of the split digraph.
+/// Its value type is inherited from the original arc map type
+/// (\c ArcMap).
+template <typename ArcMap, typename NodeMap>
 class CombinedArcMap {
 public:
+/// The key type of the map
 typedef Arc Key;
-typedef typename DigraphArcMap::Value Value;
+/// The value type of the map
+typedef typename ArcMap::Value Value;
-/// \brief Constructor
-///
+typedef typename MapTraits<ArcMap>::ReferenceMapTag ReferenceMapTag;
-/// Constructor.
+typedef typename MapTraits<ArcMap>::ReturnValue ReturnValue;
-CombinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map)
+typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReturnValue;
+typedef typename MapTraits<ArcMap>::ReturnValue Reference;
+typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReference;
+/// Constructor
+CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
 : _arc_map(arc_map), _node_map(node_map) {}
-/// \brief The subscript operator.
+/// Returns the value associated with the given key.
-///
+Value operator[](const Key& arc) const {
-/// The subscript operator.
+if (Parent::origArc(arc)) {
+return _arc_map[arc];
+} else {
+return _node_map[arc];
+}
+}
+/// Returns a reference to the value associated with the given key.
+Value& operator[](const Key& arc) {
+if (Parent::origArc(arc)) {
+return _arc_map[arc];
+} else {
+return _node_map[arc];
+}
+}
+/// Sets the value associated with the given key.
 void set(const Arc& arc, const Value& val) {
 if (Parent::origArc(arc)) {
 _arc_map.set(arc, val);
 } else {
 _node_map.set(arc, val);
 }
 }
-/// \brief The const subscript operator.
-///
-/// The const subscript operator.
-Value operator[](const Key& arc) const {
-if (Parent::origArc(arc)) {
-return _arc_map[arc];
-} else {
-return _node_map[arc];
-}
-}
-/// \brief The const subscript operator.
-///
-/// The const subscript operator.
-Value& operator[](const Key& arc) {
-if (Parent::origArc(arc)) {
-return _arc_map[arc];
-} else {
-return _node_map[arc];
-}
-}
 private:
-DigraphArcMap& _arc_map;
+ArcMap& _arc_map;
-DigraphNodeMap& _node_map;
+NodeMap& _node_map;
 };
-/// \brief Just gives back a combined arc map
+/// \brief Returns a combined arc map
 ///
-/// Just gives back 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 Just gives back a node splitter
+/// \brief Returns a (read-only) SplitNodes adaptor
 ///
-/// Just gives back a node splitter
+/// This function just returns a (read-only) \ref SplitNodes adaptor.
-template<typename Digraph>
+/// \ingroup graph_adaptors
-SplitNodes<Digraph>
+/// \relates SplitNodes
-splitNodes(const Digraph& digraph) {
+template<typename GR>
-return SplitNodes<Digraph>(digraph);
+SplitNodes<GR>
+splitNodes(const GR& digraph) {
+return SplitNodes<GR>(digraph);
 }
 } //namespace lemon
 #endif //LEMON_ADAPTORS_H

changeset 460	76ec7bd57026
parent 440	88ed40ad0d4f
parent 454	f599fa651202
child 464	acfb0f24d178