lemon-main: comparison lemon/adaptors.h

equal deleted inserted replaced

-:3a8698450852
+:36cf7a5067aa
 #include <algorithm>
 namespace lemon {
-template<typename _Digraph>
+#ifdef _MSC_VER
+#define LEMON_SCOPE_FIX(OUTER, NESTED) OUTER::NESTED
+#else
+#define LEMON_SCOPE_FIX(OUTER, NESTED) typename OUTER::template NESTED
+#endif
+template<typename DGR>
 class DigraphAdaptorBase {
 public:
-typedef _Digraph Digraph;
+typedef DGR Digraph;
 typedef DigraphAdaptorBase Adaptor;
-typedef Digraph ParentDigraph;
 protected:
-Digraph* _digraph;
+DGR* _digraph;
 DigraphAdaptorBase() : _digraph(0) { }
-void setDigraph(Digraph& digraph) { _digraph = &digraph; }
+void initialize(DGR& digraph) { _digraph = &digraph; }
 public:
-DigraphAdaptorBase(Digraph& digraph) : _digraph(&digraph) { }
+DigraphAdaptorBase(DGR& digraph) : _digraph(&digraph) { }
-typedef typename Digraph::Node Node;
+typedef typename DGR::Node Node;
-typedef typename Digraph::Arc Arc;
+typedef typename DGR::Arc Arc;
 void first(Node& i) const { _digraph->first(i); }
 void first(Arc& i) const { _digraph->first(i); }
 void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); }
 void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); }
 void nextOut(Arc& i) const { _digraph->nextOut(i); }
 Node source(const Arc& a) const { return _digraph->source(a); }
 Node target(const Arc& a) const { return _digraph->target(a); }
-typedef NodeNumTagIndicator<Digraph> NodeNumTag;
+typedef NodeNumTagIndicator<DGR> NodeNumTag;
 int nodeNum() const { return _digraph->nodeNum(); }
-typedef ArcNumTagIndicator<Digraph> ArcNumTag;
+typedef ArcNumTagIndicator<DGR> ArcNumTag;
 int arcNum() const { return _digraph->arcNum(); }
-typedef FindArcTagIndicator<Digraph> FindArcTag;
+typedef FindArcTagIndicator<DGR> FindArcTag;
 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 arcFromId(int ix) const { return _digraph->arcFromId(ix); }
 int maxNodeId() const { return _digraph->maxNodeId(); }
 int maxArcId() const { return _digraph->maxArcId(); }
-typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
-typedef typename ItemSetTraits<Digraph, Arc>::ItemNotifier ArcNotifier;
+typedef typename ItemSetTraits<DGR, Arc>::ItemNotifier ArcNotifier;
 ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); }
-template <typename _Value>
+template <typename V>
-class NodeMap : public Digraph::template NodeMap<_Value> {
+class NodeMap : public DGR::template NodeMap<V> {
 public:
-typedef typename Digraph::template NodeMap<_Value> Parent;
+typedef typename DGR::template NodeMap<V> Parent;
 explicit NodeMap(const Adaptor& adaptor)
 : Parent(*adaptor._digraph) {}
-NodeMap(const Adaptor& adaptor, const _Value& value)
+NodeMap(const Adaptor& adaptor, const V& value)
 : Parent(*adaptor._digraph, value) { }
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public Digraph::template ArcMap<_Value> {
+class ArcMap : public DGR::template ArcMap<V> {
 public:
-typedef typename Digraph::template ArcMap<_Value> Parent;
+typedef typename DGR::template ArcMap<V> Parent;
-explicit ArcMap(const Adaptor& adaptor)
+explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)
 : Parent(*adaptor._digraph) {}
-ArcMap(const Adaptor& adaptor, const _Value& value)
+ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)
 : Parent(*adaptor._digraph, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 };
 };
-template<typename _Graph>
+template<typename GR>
 class GraphAdaptorBase {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
-typedef Graph ParentGraph;
 protected:
-Graph* _graph;
+GR* _graph;
 GraphAdaptorBase() : _graph(0) {}
-void setGraph(Graph& graph) { _graph = &graph; }
+void initialize(GR& graph) { _graph = &graph; }
 public:
-GraphAdaptorBase(Graph& graph) : _graph(&graph) {}
+GraphAdaptorBase(GR& graph) : _graph(&graph) {}
-typedef typename Graph::Node Node;
+typedef typename GR::Node Node;
-typedef typename Graph::Arc Arc;
+typedef typename GR::Arc Arc;
-typedef typename Graph::Edge Edge;
+typedef typename GR::Edge Edge;
 void first(Node& i) const { _graph->first(i); }
 void first(Arc& i) const { _graph->first(i); }
 void first(Edge& i) const { _graph->first(i); }
 void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); }
 int maxNodeId() const { return _graph->maxNodeId(); }
 int maxArcId() const { return _graph->maxArcId(); }
 int maxEdgeId() const { return _graph->maxEdgeId(); }
-typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
-typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier;
+typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier;
 ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
-typedef typename ItemSetTraits<Graph, Edge>::ItemNotifier EdgeNotifier;
+typedef typename ItemSetTraits<GR, Edge>::ItemNotifier EdgeNotifier;
 EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); }
-template <typename _Value>
+template <typename V>
-class NodeMap : public Graph::template NodeMap<_Value> {
+class NodeMap : public GR::template NodeMap<V> {
 public:
-typedef typename Graph::template NodeMap<_Value> Parent;
+typedef typename GR::template NodeMap<V> Parent;
-explicit NodeMap(const GraphAdaptorBase<Graph>& adapter)
+explicit NodeMap(const GraphAdaptorBase<GR>& adapter)
 : Parent(*adapter._graph) {}
-NodeMap(const GraphAdaptorBase<Graph>& adapter, const _Value& value)
+NodeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
 : Parent(*adapter._graph, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public Graph::template ArcMap<_Value> {
+class ArcMap : public GR::template ArcMap<V> {
 public:
-typedef typename Graph::template ArcMap<_Value> Parent;
+typedef typename GR::template ArcMap<V> Parent;
-explicit ArcMap(const GraphAdaptorBase<Graph>& adapter)
+explicit ArcMap(const GraphAdaptorBase<GR>& adapter)
 : Parent(*adapter._graph) {}
-ArcMap(const GraphAdaptorBase<Graph>& adapter, const _Value& value)
+ArcMap(const GraphAdaptorBase<GR>& adapter, const V& value)
 : Parent(*adapter._graph, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class EdgeMap : public Graph::template EdgeMap<_Value> {
+class EdgeMap : public GR::template EdgeMap<V> {
 public:
-typedef typename Graph::template EdgeMap<_Value> Parent;
+typedef typename GR::template EdgeMap<V> Parent;
-explicit EdgeMap(const GraphAdaptorBase<Graph>& adapter)
+explicit EdgeMap(const GraphAdaptorBase<GR>& adapter)
 : Parent(*adapter._graph) {}
-EdgeMap(const GraphAdaptorBase<Graph>& adapter, const _Value& value)
+EdgeMap(const GraphAdaptorBase<GR>& adapter, const V& value)
 : Parent(*adapter._graph, value) {}
 private:
 EdgeMap& operator=(const EdgeMap& cmap) {
 return operator=<EdgeMap>(cmap);
 }
 };
 };
-template <typename _Digraph>
+template <typename DGR>
-class ReverseDigraphBase : public DigraphAdaptorBase<_Digraph> {
+class ReverseDigraphBase : public DigraphAdaptorBase<DGR> {
 public:
-typedef _Digraph Digraph;
+typedef DGR Digraph;
-typedef DigraphAdaptorBase<_Digraph> Parent;
+typedef DigraphAdaptorBase<DGR> Parent;
 protected:
 ReverseDigraphBase() : Parent() { }
 public:
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 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 FindArcTagIndicator<Digraph> FindArcTag;
+typedef FindArcTagIndicator<DGR> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
 const Arc& prev = INVALID) const {
 return Parent::findArc(v, u, prev);
 }
 ///
 /// The adapted digraph can also be modified through this adaptor
 /// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam GR The type of the adapted digraph.
+/// \tparam DGR 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>
+template<typename DGR>
 #ifdef DOXYGEN
 class ReverseDigraph {
 #else
 class ReverseDigraph :
-public DigraphAdaptorExtender<ReverseDigraphBase<GR> > {
+public DigraphAdaptorExtender<ReverseDigraphBase<DGR> > {
 #endif
 public:
 /// The type of the adapted digraph.
-typedef GR Digraph;
+typedef DGR Digraph;
-typedef DigraphAdaptorExtender<ReverseDigraphBase<GR> > Parent;
+typedef DigraphAdaptorExtender<ReverseDigraphBase<DGR> > Parent;
 protected:
 ReverseDigraph() { }
 public:
 /// \brief Constructor
 ///
 /// Creates a reverse digraph adaptor for the given digraph.
-explicit ReverseDigraph(Digraph& digraph) {
+explicit ReverseDigraph(DGR& digraph) {
-Parent::setDigraph(digraph);
+Parent::initialize(digraph);
 }
 };
 /// \brief Returns a read-only ReverseDigraph adaptor
 ///
 /// This function just returns a read-only \ref ReverseDigraph adaptor.
 /// \ingroup graph_adaptors
 /// \relates ReverseDigraph
-template<typename GR>
+template<typename DGR>
-ReverseDigraph<const GR> reverseDigraph(const GR& digraph) {
+ReverseDigraph<const DGR> reverseDigraph(const DGR& digraph) {
-return ReverseDigraph<const GR>(digraph);
+return ReverseDigraph<const DGR>(digraph);
 }
-template <typename _Digraph, typename _NodeFilterMap,
+template <typename DGR, typename NF, typename AF, bool ch = true>
-typename _ArcFilterMap, bool _checked = true>
+class SubDigraphBase : public DigraphAdaptorBase<DGR> {
-class SubDigraphBase : public DigraphAdaptorBase<_Digraph> {
+public:
-public:
+typedef DGR Digraph;
-typedef _Digraph Digraph;
+typedef NF NodeFilterMap;
-typedef _NodeFilterMap NodeFilterMap;
+typedef AF ArcFilterMap;
-typedef _ArcFilterMap ArcFilterMap;
 typedef SubDigraphBase Adaptor;
-typedef DigraphAdaptorBase<_Digraph> Parent;
+typedef DigraphAdaptorBase<DGR> Parent;
 protected:
-NodeFilterMap* _node_filter;
+NF* _node_filter;
-ArcFilterMap* _arc_filter;
+AF* _arc_filter;
 SubDigraphBase()
 : Parent(), _node_filter(0), _arc_filter(0) { }
-void setNodeFilterMap(NodeFilterMap& node_filter) {
+void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
+Parent::initialize(digraph);
 _node_filter = &node_filter;
-}
+_arc_filter = &arc_filter;
-void setArcFilterMap(ArcFilterMap& arc_filter) {
-_arc_filter = &arc_filter;
 }
 public:
 typedef typename Parent::Node Node;
 bool status(const Arc& a) const { return (*_arc_filter)[a]; }
 typedef False NodeNumTag;
 typedef False ArcNumTag;
-typedef FindArcTagIndicator<Digraph> FindArcTag;
+typedef FindArcTagIndicator<DGR> FindArcTag;
 Arc findArc(const Node& source, const Node& target,
 const Arc& prev = INVALID) const {
 if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
 return INVALID;
 }
 arc = Parent::findArc(source, target, arc);
 }
 return arc;
 }
-template <typename _Value>
+public:
-class NodeMap : public SubMapExtender<Adaptor,
-typename Parent::template NodeMap<_Value> > {
+template <typename V>
+class NodeMap
+: public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-template NodeMap<Value> > MapParent;
+	    LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
-NodeMap(const Adaptor& adaptor)
+NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-NodeMap(const Adaptor& adaptor, const Value& value)
+NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 template <typename CMap>
 NodeMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public SubMapExtender<Adaptor,
+class ArcMap
-typename Parent::template ArcMap<_Value> > {
+: public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-template ArcMap<Value> > MapParent;
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
-ArcMap(const Adaptor& adaptor)
+ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-ArcMap(const Adaptor& adaptor, const Value& value)
+ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 }
 template <typename CMap>
 ArcMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
 };
-template <typename _Digraph, typename _NodeFilterMap, typename _ArcFilterMap>
+template <typename DGR, typename NF, typename AF>
-class SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, false>
+class SubDigraphBase<DGR, NF, AF, false>
-: public DigraphAdaptorBase<_Digraph> {
+: public DigraphAdaptorBase<DGR> {
 public:
-typedef _Digraph Digraph;
+typedef DGR Digraph;
-typedef _NodeFilterMap NodeFilterMap;
+typedef NF NodeFilterMap;
-typedef _ArcFilterMap ArcFilterMap;
+typedef AF ArcFilterMap;
 typedef SubDigraphBase Adaptor;
 typedef DigraphAdaptorBase<Digraph> Parent;
 protected:
-NodeFilterMap* _node_filter;
+NF* _node_filter;
-ArcFilterMap* _arc_filter;
+AF* _arc_filter;
 SubDigraphBase()
 : Parent(), _node_filter(0), _arc_filter(0) { }
-void setNodeFilterMap(NodeFilterMap& node_filter) {
+void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
+Parent::initialize(digraph);
 _node_filter = &node_filter;
-}
+_arc_filter = &arc_filter;
-void setArcFilterMap(ArcFilterMap& arc_filter) {
-_arc_filter = &arc_filter;
 }
 public:
 typedef typename Parent::Node Node;
 bool status(const Arc& a) const { return (*_arc_filter)[a]; }
 typedef False NodeNumTag;
 typedef False ArcNumTag;
-typedef FindArcTagIndicator<Digraph> FindArcTag;
+typedef FindArcTagIndicator<DGR> FindArcTag;
 Arc findArc(const Node& source, const Node& target,
 const Arc& prev = INVALID) const {
 if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
 return INVALID;
 }
 arc = Parent::findArc(source, target, arc);
 }
 return arc;
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public SubMapExtender<Adaptor,
+class NodeMap
-typename Parent::template NodeMap<_Value> > {
+: public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
-template NodeMap<Value> > MapParent;
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
-NodeMap(const Adaptor& adaptor)
+NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-NodeMap(const Adaptor& adaptor, const Value& value)
+NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 template <typename CMap>
 NodeMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public SubMapExtender<Adaptor,
+class ArcMap
-typename Parent::template ArcMap<_Value> > {
+: public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
-template ArcMap<Value> > MapParent;
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
-ArcMap(const Adaptor& adaptor)
+ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-ArcMap(const Adaptor& adaptor, const Value& value)
+ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 }
 template <typename CMap>
 ArcMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
 };
 ///
 /// The adapted digraph can also be modified through this adaptor
 /// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam GR The type of the adapted digraph.
+/// \tparam DGR 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 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>".
+/// \ref concepts::Digraph::NodeMap "DGR::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>".
+/// \ref concepts::Digraph::ArcMap "DGR::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
 #ifdef DOXYGEN
-template<typename GR, typename NF, typename AF>
+template<typename DGR, typename NF, typename AF>
 class SubDigraph {
 #else
-template<typename GR,
+template<typename DGR,
-typename NF = typename GR::template NodeMap<bool>,
+typename NF = typename DGR::template NodeMap<bool>,
-typename AF = typename GR::template ArcMap<bool> >
+typename AF = typename DGR::template ArcMap<bool> >
 class SubDigraph :
-public DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> > {
+public DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> > {
 #endif
 public:
 /// The type of the adapted digraph.
-typedef GR Digraph;
+typedef DGR Digraph;
 /// The type of the node filter map.
 typedef NF NodeFilterMap;
 /// The type of the arc filter map.
 typedef AF ArcFilterMap;
-typedef DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> >
+typedef DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> >
 Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 /// \brief Constructor
 ///
 /// Creates a subdigraph for the given digraph with the
 /// given node and arc filter maps.
-SubDigraph(Digraph& digraph, NodeFilterMap& node_filter,
+SubDigraph(DGR& digraph, NF& node_filter, AF& arc_filter) {
-ArcFilterMap& arc_filter) {
+Parent::initialize(digraph, node_filter, arc_filter);
-setDigraph(digraph);
-setNodeFilterMap(node_filter);
-setArcFilterMap(arc_filter);
 }
 /// \brief Sets the status of the given node
 ///
 /// This function sets the status of the given node.
 /// \brief Returns a read-only SubDigraph adaptor
 ///
 /// This function just returns a read-only \ref SubDigraph adaptor.
 /// \ingroup graph_adaptors
 /// \relates SubDigraph
-template<typename GR, typename NF, typename AF>
+template<typename DGR, typename NF, typename AF>
-SubDigraph<const GR, NF, AF>
+SubDigraph<const DGR, NF, AF>
-subDigraph(const GR& digraph,
+subDigraph(const DGR& digraph,
-NF& node_filter_map, AF& arc_filter_map) {
+NF& node_filter, AF& arc_filter) {
-return SubDigraph<const GR, NF, AF>
+return SubDigraph<const DGR, NF, AF>
-(digraph, node_filter_map, arc_filter_map);
+(digraph, node_filter, arc_filter);
 }
-template<typename GR, typename NF, typename AF>
+template<typename DGR, typename NF, typename AF>
-SubDigraph<const GR, const NF, AF>
+SubDigraph<const DGR, const NF, AF>
-subDigraph(const GR& digraph,
+subDigraph(const DGR& digraph,
-const NF& node_filter_map, AF& arc_filter_map) {
+const NF& node_filter, AF& arc_filter) {
-return SubDigraph<const GR, const NF, AF>
+return SubDigraph<const DGR, const NF, AF>
-(digraph, node_filter_map, arc_filter_map);
+(digraph, node_filter, arc_filter);
 }
-template<typename GR, typename NF, typename AF>
+template<typename DGR, typename NF, typename AF>
-SubDigraph<const GR, NF, const AF>
+SubDigraph<const DGR, NF, const AF>
-subDigraph(const GR& digraph,
+subDigraph(const DGR& digraph,
-NF& node_filter_map, const AF& arc_filter_map) {
+NF& node_filter, const AF& arc_filter) {
-return SubDigraph<const GR, NF, const AF>
+return SubDigraph<const DGR, NF, const AF>
-(digraph, node_filter_map, arc_filter_map);
+(digraph, node_filter, arc_filter);
 }
-template<typename GR, typename NF, typename AF>
+template<typename DGR, typename NF, typename AF>
-SubDigraph<const GR, const NF, const AF>
+SubDigraph<const DGR, const NF, const AF>
-subDigraph(const GR& digraph,
+subDigraph(const DGR& digraph,
-const NF& node_filter_map, const AF& arc_filter_map) {
+const NF& node_filter, const AF& arc_filter) {
-return SubDigraph<const GR, const NF, const AF>
+return SubDigraph<const DGR, const NF, const AF>
-(digraph, node_filter_map, arc_filter_map);
+(digraph, node_filter, arc_filter);
 }
-template <typename _Graph, typename _NodeFilterMap,
+template <typename GR, typename NF, typename EF, bool ch = true>
-typename _EdgeFilterMap, bool _checked = true>
+class SubGraphBase : public GraphAdaptorBase<GR> {
-class SubGraphBase : public GraphAdaptorBase<_Graph> {
+public:
-public:
+typedef GR Graph;
-typedef _Graph Graph;
+typedef NF NodeFilterMap;
-typedef _NodeFilterMap NodeFilterMap;
+typedef EF EdgeFilterMap;
-typedef _EdgeFilterMap EdgeFilterMap;
 typedef SubGraphBase Adaptor;
-typedef GraphAdaptorBase<_Graph> Parent;
+typedef GraphAdaptorBase<GR> Parent;
 protected:
-NodeFilterMap* _node_filter_map;
+NF* _node_filter;
-EdgeFilterMap* _edge_filter_map;
+EF* _edge_filter;
 SubGraphBase()
-: Parent(), _node_filter_map(0), _edge_filter_map(0) { }
+: Parent(), _node_filter(0), _edge_filter(0) { }
-void setNodeFilterMap(NodeFilterMap& node_filter_map) {
+void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
-_node_filter_map=&node_filter_map;
+Parent::initialize(graph);
-}
+_node_filter = &node_filter;
-void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) {
+_edge_filter = &edge_filter;
-_edge_filter_map=&edge_filter_map;
 }
 public:
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 typedef typename Parent::Edge Edge;
 void first(Node& i) const {
 Parent::first(i);
-while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
 }
 void first(Arc& i) const {
 Parent::first(i);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::source(i)]
+|| !(*_node_filter)[Parent::source(i)]
-|| !(*_node_filter_map)[Parent::target(i)]))
+|| !(*_node_filter)[Parent::target(i)]))
 Parent::next(i);
 }
 void first(Edge& i) const {
 Parent::first(i);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::u(i)]
+|| !(*_node_filter)[Parent::u(i)]
-|| !(*_node_filter_map)[Parent::v(i)]))
+|| !(*_node_filter)[Parent::v(i)]))
 Parent::next(i);
 }
 void firstIn(Arc& i, const Node& n) const {
 Parent::firstIn(i, n);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::source(i)]))
+|| !(*_node_filter)[Parent::source(i)]))
 Parent::nextIn(i);
 }
 void firstOut(Arc& i, const Node& n) const {
 Parent::firstOut(i, n);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::target(i)]))
+|| !(*_node_filter)[Parent::target(i)]))
 Parent::nextOut(i);
 }
 void firstInc(Edge& i, bool& d, const Node& n) const {
 Parent::firstInc(i, d, n);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::u(i)]
+|| !(*_node_filter)[Parent::u(i)]
-|| !(*_node_filter_map)[Parent::v(i)]))
+|| !(*_node_filter)[Parent::v(i)]))
 Parent::nextInc(i, d);
 }
 void next(Node& i) const {
 Parent::next(i);
-while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
 }
 void next(Arc& i) const {
 Parent::next(i);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::source(i)]
+|| !(*_node_filter)[Parent::source(i)]
-|| !(*_node_filter_map)[Parent::target(i)]))
+|| !(*_node_filter)[Parent::target(i)]))
 Parent::next(i);
 }
 void next(Edge& i) const {
 Parent::next(i);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::u(i)]
+|| !(*_node_filter)[Parent::u(i)]
-|| !(*_node_filter_map)[Parent::v(i)]))
+|| !(*_node_filter)[Parent::v(i)]))
 Parent::next(i);
 }
 void nextIn(Arc& i) const {
 Parent::nextIn(i);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::source(i)]))
+|| !(*_node_filter)[Parent::source(i)]))
 Parent::nextIn(i);
 }
 void nextOut(Arc& i) const {
 Parent::nextOut(i);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::target(i)]))
+|| !(*_node_filter)[Parent::target(i)]))
 Parent::nextOut(i);
 }
 void nextInc(Edge& i, bool& d) const {
 Parent::nextInc(i, d);
-while (i!=INVALID && (!(*_edge_filter_map)[i]
+while (i!=INVALID && (!(*_edge_filter)[i]
-|| !(*_node_filter_map)[Parent::u(i)]
+|| !(*_node_filter)[Parent::u(i)]
-|| !(*_node_filter_map)[Parent::v(i)]))
+|| !(*_node_filter)[Parent::v(i)]))
 Parent::nextInc(i, d);
 }
-void status(const Node& n, bool v) const { _node_filter_map->set(n, v); }
+void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); }
+void status(const Edge& e, bool v) const { _edge_filter->set(e, v); }
-bool status(const Node& n) const { return (*_node_filter_map)[n]; }
+bool status(const Node& n) const { return (*_node_filter)[n]; }
-bool status(const Edge& e) const { return (*_edge_filter_map)[e]; }
+bool status(const Edge& e) const { return (*_edge_filter)[e]; }
 typedef False NodeNumTag;
 typedef False ArcNumTag;
 typedef False EdgeNumTag;
 typedef FindArcTagIndicator<Graph> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
 const Arc& prev = INVALID) const {
-if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
+if (!(*_node_filter)[u] || !(*_node_filter)[v]) {
 return INVALID;
 }
 Arc arc = Parent::findArc(u, v, prev);
-while (arc != INVALID && !(*_edge_filter_map)[arc]) {
+while (arc != INVALID && !(*_edge_filter)[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 {
-if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
+if (!(*_node_filter)[u] || !(*_node_filter)[v]) {
 return INVALID;
 }
 Edge edge = Parent::findEdge(u, v, prev);
-while (edge != INVALID && !(*_edge_filter_map)[edge]) {
+while (edge != INVALID && !(*_edge_filter)[edge]) {
 edge = Parent::findEdge(u, v, edge);
 }
 return edge;
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public SubMapExtender<Adaptor,
+class NodeMap
-typename Parent::template NodeMap<_Value> > {
+: public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-template NodeMap<Value> > MapParent;
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
-NodeMap(const Adaptor& adaptor)
+NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-NodeMap(const Adaptor& adaptor, const Value& value)
+NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 template <typename CMap>
 NodeMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public SubMapExtender<Adaptor,
+class ArcMap
-typename Parent::template ArcMap<_Value> > {
+: public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-template ArcMap<Value> > MapParent;
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
-ArcMap(const Adaptor& adaptor)
+ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-ArcMap(const Adaptor& adaptor, const Value& value)
+ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 }
 template <typename CMap>
 ArcMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class EdgeMap : public SubMapExtender<Adaptor,
+class EdgeMap
-typename Parent::template EdgeMap<_Value> > {
+: public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
-template EdgeMap<Value> > MapParent;
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
-EdgeMap(const Adaptor& adaptor)
+EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-EdgeMap(const Adaptor& adaptor, const Value& value)
+EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 EdgeMap& operator=(const EdgeMap& cmap) {
 return operator=<EdgeMap>(cmap);
 }
 template <typename CMap>
 EdgeMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
 };
-template <typename _Graph, typename _NodeFilterMap, typename _EdgeFilterMap>
+template <typename GR, typename NF, typename EF>
-class SubGraphBase<_Graph, _NodeFilterMap, _EdgeFilterMap, false>
+class SubGraphBase<GR, NF, EF, false>
-: public GraphAdaptorBase<_Graph> {
+: public GraphAdaptorBase<GR> {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
-typedef _NodeFilterMap NodeFilterMap;
+typedef NF NodeFilterMap;
-typedef _EdgeFilterMap EdgeFilterMap;
+typedef EF EdgeFilterMap;
 typedef SubGraphBase Adaptor;
-typedef GraphAdaptorBase<_Graph> Parent;
+typedef GraphAdaptorBase<GR> Parent;
 protected:
-NodeFilterMap* _node_filter_map;
+NF* _node_filter;
-EdgeFilterMap* _edge_filter_map;
+EF* _edge_filter;
-SubGraphBase() : Parent(),
+SubGraphBase()
-_node_filter_map(0), _edge_filter_map(0) { }
+	  : Parent(), _node_filter(0), _edge_filter(0) { }
-void setNodeFilterMap(NodeFilterMap& node_filter_map) {
+void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
-_node_filter_map=&node_filter_map;
+Parent::initialize(graph);
-}
+_node_filter = &node_filter;
-void setEdgeFilterMap(EdgeFilterMap& edge_filter_map) {
+_edge_filter = &edge_filter;
-_edge_filter_map=&edge_filter_map;
 }
 public:
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 typedef typename Parent::Edge Edge;
 void first(Node& i) const {
 Parent::first(i);
-while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
 }
 void first(Arc& i) const {
 Parent::first(i);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
 }
 void first(Edge& i) const {
 Parent::first(i);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
 }
 void firstIn(Arc& i, const Node& n) const {
 Parent::firstIn(i, n);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i);
 }
 void firstOut(Arc& i, const Node& n) const {
 Parent::firstOut(i, n);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i);
 }
 void firstInc(Edge& i, bool& d, const Node& n) const {
 Parent::firstInc(i, d, n);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d);
 }
 void next(Node& i) const {
 Parent::next(i);
-while (i!=INVALID && !(*_node_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i);
 }
 void next(Arc& i) const {
 Parent::next(i);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
 }
 void next(Edge& i) const {
 Parent::next(i);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::next(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i);
 }
 void nextIn(Arc& i) const {
 Parent::nextIn(i);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i);
 }
 void nextOut(Arc& i) const {
 Parent::nextOut(i);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i);
 }
 void nextInc(Edge& i, bool& d) const {
 Parent::nextInc(i, d);
-while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d);
+while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d);
 }
-void status(const Node& n, bool v) const { _node_filter_map->set(n, v); }
+void status(const Node& n, bool v) const { _node_filter->set(n, v); }
-void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); }
+void status(const Edge& e, bool v) const { _edge_filter->set(e, v); }
-bool status(const Node& n) const { return (*_node_filter_map)[n]; }
+bool status(const Node& n) const { return (*_node_filter)[n]; }
-bool status(const Edge& e) const { return (*_edge_filter_map)[e]; }
+bool status(const Edge& e) const { return (*_edge_filter)[e]; }
 typedef False NodeNumTag;
 typedef False ArcNumTag;
 typedef False EdgeNumTag;
 typedef FindArcTagIndicator<Graph> FindArcTag;
 Arc findArc(const Node& u, const Node& v,
 const Arc& prev = INVALID) const {
 Arc arc = Parent::findArc(u, v, prev);
-while (arc != INVALID && !(*_edge_filter_map)[arc]) {
+while (arc != INVALID && !(*_edge_filter)[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 edge = Parent::findEdge(u, v, prev);
-while (edge != INVALID && !(*_edge_filter_map)[edge]) {
+while (edge != INVALID && !(*_edge_filter)[edge]) {
 edge = Parent::findEdge(u, v, edge);
 }
 return edge;
 }
-template <typename _Value>
+template <typename V>
-class NodeMap : public SubMapExtender<Adaptor,
+class NodeMap
-typename Parent::template NodeMap<_Value> > {
+: public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-template NodeMap<Value> > MapParent;
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
-NodeMap(const Adaptor& adaptor)
+NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-NodeMap(const Adaptor& adaptor, const Value& value)
+NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 }
 template <typename CMap>
 NodeMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public SubMapExtender<Adaptor,
+class ArcMap
-typename Parent::template ArcMap<_Value> > {
+: public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-template ArcMap<Value> > MapParent;
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
-ArcMap(const Adaptor& adaptor)
+ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-ArcMap(const Adaptor& adaptor, const Value& value)
+ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 }
 template <typename CMap>
 ArcMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class EdgeMap : public SubMapExtender<Adaptor,
+class EdgeMap
-typename Parent::template EdgeMap<_Value> > {
+: public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, typename Parent::
+typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-template EdgeMap<Value> > MapParent;
+		  LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
-EdgeMap(const Adaptor& adaptor)
+EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
-: MapParent(adaptor) {}
+: Parent(adaptor) {}
-EdgeMap(const Adaptor& adaptor, const _Value& value)
+EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
-: MapParent(adaptor, value) {}
+: Parent(adaptor, value) {}
 private:
 EdgeMap& operator=(const EdgeMap& cmap) {
 return operator=<EdgeMap>(cmap);
 }
 template <typename CMap>
 EdgeMap& operator=(const CMap& cmap) {
-MapParent::operator=(cmap);
+Parent::operator=(cmap);
 return *this;
 }
 };
 };
 /// 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> >
+typedef GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> >
 Parent;
 typedef typename Parent::Node Node;
 typedef typename Parent::Edge Edge;
 /// \brief Constructor
 ///
 /// Creates a subgraph for the given graph with the given node
 /// and edge filter maps.
-SubGraph(Graph& graph, NodeFilterMap& node_filter_map,
+SubGraph(GR& graph, NF& node_filter, EF& edge_filter) {
-EdgeFilterMap& edge_filter_map) {
+initialize(graph, node_filter, edge_filter);
-setGraph(graph);
-setNodeFilterMap(node_filter_map);
-setEdgeFilterMap(edge_filter_map);
 }
 /// \brief Sets the status of the given node
 ///
 /// This function sets the status of the given node.
 /// This function just returns a read-only \ref SubGraph adaptor.
 /// \ingroup graph_adaptors
 /// \relates SubGraph
 template<typename GR, typename NF, typename EF>
 SubGraph<const GR, NF, EF>
-subGraph(const GR& graph,
+subGraph(const GR& graph, NF& node_filter, EF& edge_filter) {
-NF& node_filter_map, EF& edge_filter_map) {
 return SubGraph<const GR, NF, EF>
-(graph, node_filter_map, edge_filter_map);
+(graph, node_filter, edge_filter);
 }
 template<typename GR, typename NF, typename EF>
 SubGraph<const GR, const NF, EF>
-subGraph(const GR& graph,
+subGraph(const GR& graph, const NF& node_filter, EF& edge_filter) {
-const NF& node_filter_map, EF& edge_filter_map) {
 return SubGraph<const GR, const NF, EF>
-(graph, node_filter_map, edge_filter_map);
+(graph, node_filter, edge_filter);
 }
 template<typename GR, typename NF, typename EF>
 SubGraph<const GR, NF, const EF>
-subGraph(const GR& graph,
+subGraph(const GR& graph, NF& node_filter, const EF& edge_filter) {
-NF& node_filter_map, const EF& edge_filter_map) {
 return SubGraph<const GR, NF, const EF>
-(graph, node_filter_map, edge_filter_map);
+(graph, node_filter, edge_filter);
 }
 template<typename GR, typename NF, typename EF>
 SubGraph<const GR, const NF, const EF>
-subGraph(const GR& graph,
+subGraph(const GR& graph, const NF& node_filter, const EF& edge_filter) {
-const NF& node_filter_map, const EF& edge_filter_map) {
 return SubGraph<const GR, const NF, const EF>
-(graph, node_filter_map, edge_filter_map);
+(graph, node_filter, edge_filter);
 }
 /// \ingroup graph_adaptors
 ///
 template<typename GR,
 typename NF = typename GR::template NodeMap<bool>,
 typename Enable = void>
 class FilterNodes :
 public DigraphAdaptorExtender<
-SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, bool>, true> > {
+SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+true> > {
 #endif
 public:
 typedef GR Digraph;
 typedef NF NodeFilterMap;
 typedef DigraphAdaptorExtender<
-SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, bool>, true> >
+SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
-Parent;
+true> > Parent;
 typedef typename Parent::Node Node;
 protected:
-ConstMap<typename Digraph::Arc, bool> const_true_map;
+ConstMap<typename Digraph::Arc, Const<bool, true> > const_true_map;
-FilterNodes() : const_true_map(true) {
+FilterNodes() : const_true_map() {}
-Parent::setArcFilterMap(const_true_map);
-}
 public:
 /// \brief Constructor
 ///
 /// Creates a subgraph for the given digraph or graph with the
 /// given node filter map.
-FilterNodes(GR& graph, NodeFilterMap& node_filter) :
+FilterNodes(GR& graph, NF& node_filter)
-Parent(), const_true_map(true)
+: Parent(), const_true_map()
 {
-Parent::setDigraph(graph);
+Parent::initialize(graph, node_filter, const_true_map);
-Parent::setNodeFilterMap(node_filter);
-Parent::setArcFilterMap(const_true_map);
 }
 /// \brief Sets the status of the given node
 ///
 /// This function sets the status of the given node.
 template<typename GR, typename NF>
 class FilterNodes<GR, NF,
 typename enable_if<UndirectedTagIndicator<GR> >::type> :
 public GraphAdaptorExtender<
-SubGraphBase<GR, NF, ConstMap<typename GR::Edge, bool>, true> > {
+SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+true> > {
 public:
 typedef GR Graph;
 typedef NF NodeFilterMap;
 typedef GraphAdaptorExtender<
-SubGraphBase<GR, NF, ConstMap<typename GR::Edge, bool>, true> >
+SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
-Parent;
+true> > Parent;
 typedef typename Parent::Node Node;
 protected:
-ConstMap<typename Graph::Edge, bool> const_true_map;
+ConstMap<typename GR::Edge, Const<bool, true> > const_true_map;
-FilterNodes() : const_true_map(true) {
+FilterNodes() : const_true_map() {}
-Parent::setEdgeFilterMap(const_true_map);
-}
+public:
-public:
+FilterNodes(GR& graph, NodeFilterMap& node_filter) :
+Parent(), const_true_map() {
-FilterNodes(Graph& _graph, NodeFilterMap& node_filter_map) :
+Parent::initialize(graph, node_filter, const_true_map);
-Parent(), const_true_map(true) {
-Parent::setGraph(_graph);
-Parent::setNodeFilterMap(node_filter_map);
-Parent::setEdgeFilterMap(const_true_map);
 }
 void status(const Node& n, bool v) const { Parent::status(n, v); }
 bool status(const Node& n) const { return Parent::status(n); }
 void disable(const Node& n) const { Parent::status(n, false); }
 /// This function just returns a read-only \ref FilterNodes adaptor.
 /// \ingroup graph_adaptors
 /// \relates FilterNodes
 template<typename GR, typename NF>
 FilterNodes<const GR, NF>
-filterNodes(const GR& graph, NF& node_filter_map) {
+filterNodes(const GR& graph, NF& node_filter) {
-return FilterNodes<const GR, NF>(graph, node_filter_map);
+return FilterNodes<const GR, NF>(graph, node_filter);
 }
 template<typename GR, typename NF>
 FilterNodes<const GR, const NF>
-filterNodes(const GR& graph, const NF& node_filter_map) {
+filterNodes(const GR& graph, const NF& node_filter) {
-return FilterNodes<const GR, const NF>(graph, node_filter_map);
+return FilterNodes<const GR, const NF>(graph, node_filter);
 }
 /// \ingroup graph_adaptors
 ///
 /// \brief Adaptor class for hiding arcs in a digraph.
 ///
 /// The adapted digraph can also be modified through this adaptor
 /// by adding or removing nodes or arcs, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam GR The type of the adapted digraph.
+/// \tparam DGR 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>".
+/// \ref concepts::Digraph::ArcMap "DGR::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,
+template<typename DGR,
 typename AF>
 class FilterArcs {
 #else
-template<typename GR,
+template<typename DGR,
-typename AF = typename GR::template ArcMap<bool> >
+typename AF = typename DGR::template ArcMap<bool> >
 class FilterArcs :
 public DigraphAdaptorExtender<
-SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> > {
+SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+AF, false> > {
 #endif
 public:
 /// The type of the adapted digraph.
-typedef GR Digraph;
+typedef DGR Digraph;
 /// The type of the arc filter map.
 typedef AF ArcFilterMap;
 typedef DigraphAdaptorExtender<
-SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> >
+SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
-Parent;
+AF, false> > Parent;
 typedef typename Parent::Arc Arc;
 protected:
-ConstMap<typename Digraph::Node, bool> const_true_map;
+ConstMap<typename DGR::Node, Const<bool, true> > const_true_map;
-FilterArcs() : const_true_map(true) {
+FilterArcs() : const_true_map() {}
-Parent::setNodeFilterMap(const_true_map);
-}
 public:
 /// \brief Constructor
 ///
 /// Creates a subdigraph for the given digraph with the given arc
 /// filter map.
-FilterArcs(Digraph& digraph, ArcFilterMap& arc_filter)
+FilterArcs(DGR& digraph, ArcFilterMap& arc_filter)
-: Parent(), const_true_map(true) {
+: Parent(), const_true_map() {
-Parent::setDigraph(digraph);
+Parent::initialize(digraph, const_true_map, arc_filter);
-Parent::setNodeFilterMap(const_true_map);
-Parent::setArcFilterMap(arc_filter);
 }
 /// \brief Sets the status of the given arc
 ///
 /// This function sets the status of the given arc.
 /// \brief Returns a read-only FilterArcs adaptor
 ///
 /// This function just returns a read-only \ref FilterArcs adaptor.
 /// \ingroup graph_adaptors
 /// \relates FilterArcs
-template<typename GR, typename AF>
+template<typename DGR, typename AF>
-FilterArcs<const GR, AF>
+FilterArcs<const DGR, AF>
-filterArcs(const GR& digraph, AF& arc_filter_map) {
+filterArcs(const DGR& digraph, AF& arc_filter) {
-return FilterArcs<const GR, AF>(digraph, arc_filter_map);
+return FilterArcs<const DGR, AF>(digraph, arc_filter);
 }
-template<typename GR, typename AF>
+template<typename DGR, typename AF>
-FilterArcs<const GR, const AF>
+FilterArcs<const DGR, const AF>
-filterArcs(const GR& digraph, const AF& arc_filter_map) {
+filterArcs(const DGR& digraph, const AF& arc_filter) {
-return FilterArcs<const GR, const AF>(digraph, arc_filter_map);
+return FilterArcs<const DGR, const AF>(digraph, arc_filter);
 }
 /// \ingroup graph_adaptors
 ///
 /// \brief Adaptor class for hiding edges in a graph.
 #else
 template<typename GR,
 typename EF = typename GR::template EdgeMap<bool> >
 class FilterEdges :
 public GraphAdaptorExtender<
-SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> > {
+SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+EF, false> > {
 #endif
 public:
 /// The type of the adapted graph.
 typedef GR Graph;
 /// The type of the edge filter map.
 typedef EF EdgeFilterMap;
 typedef GraphAdaptorExtender<
-SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> >
+SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
-Parent;
+EF, false> > Parent;
 typedef typename Parent::Edge Edge;
 protected:
-ConstMap<typename Graph::Node, bool> const_true_map;
+ConstMap<typename GR::Node, Const<bool, true> > const_true_map;
 FilterEdges() : const_true_map(true) {
 Parent::setNodeFilterMap(const_true_map);
 }
 /// \brief Constructor
 ///
 /// Creates a subgraph for the given graph with the given edge
 /// filter map.
-FilterEdges(Graph& graph, EdgeFilterMap& edge_filter_map) :
+FilterEdges(GR& graph, EF& edge_filter)
-Parent(), const_true_map(true) {
+: Parent(), const_true_map() {
-Parent::setGraph(graph);
+Parent::initialize(graph, const_true_map, edge_filter);
-Parent::setNodeFilterMap(const_true_map);
-Parent::setEdgeFilterMap(edge_filter_map);
 }
 /// \brief Sets the status of the given edge
 ///
 /// This function sets the status of the given edge.
 /// This function just returns a read-only \ref FilterEdges adaptor.
 /// \ingroup graph_adaptors
 /// \relates FilterEdges
 template<typename GR, typename EF>
 FilterEdges<const GR, EF>
-filterEdges(const GR& graph, EF& edge_filter_map) {
+filterEdges(const GR& graph, EF& edge_filter) {
-return FilterEdges<const GR, EF>(graph, edge_filter_map);
+return FilterEdges<const GR, EF>(graph, edge_filter);
 }
 template<typename GR, typename EF>
 FilterEdges<const GR, const EF>
-filterEdges(const GR& graph, const EF& edge_filter_map) {
+filterEdges(const GR& graph, const EF& edge_filter) {
-return FilterEdges<const GR, const EF>(graph, edge_filter_map);
+return FilterEdges<const GR, const EF>(graph, edge_filter);
 }
-template <typename _Digraph>
+template <typename DGR>
 class UndirectorBase {
 public:
-typedef _Digraph Digraph;
+typedef DGR Digraph;
 typedef UndirectorBase Adaptor;
 typedef True UndirectedTag;
 typedef typename Digraph::Arc Edge;
 return INVALID;
 }
 private:
-template <typename _Value>
+template <typename V>
 class ArcMapBase {
 private:
-typedef typename Digraph::template ArcMap<_Value> MapImpl;
+typedef typename DGR::template ArcMap<V> MapImpl;
 public:
 typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag;
-typedef _Value Value;
+typedef V 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) :
+ArcMapBase(const UndirectorBase<DGR>& adaptor) :
 _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
-ArcMapBase(const Adaptor& adaptor, const Value& v)
+ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-: _forward(*adaptor._digraph, v), _backward(*adaptor._digraph, v) {}
+: _forward(*adaptor._digraph, value),
+_backward(*adaptor._digraph, value) {}
-void set(const Arc& a, const Value& v) {
+void set(const Arc& a, const V& value) {
 if (direction(a)) {
-_forward.set(a, v);
+_forward.set(a, value);
 } else {
-_backward.set(a, v);
+_backward.set(a, value);
 }
 }
 ConstReturnValue operator[](const Arc& a) const {
 if (direction(a)) {
 };
 public:
-template <typename _Value>
+template <typename V>
-class NodeMap : public Digraph::template NodeMap<_Value> {
+class NodeMap : public DGR::template NodeMap<V> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef typename Digraph::template NodeMap<Value> Parent;
+typedef typename DGR::template NodeMap<Value> Parent;
-explicit NodeMap(const Adaptor& adaptor)
+explicit NodeMap(const UndirectorBase<DGR>& adaptor)
 : Parent(*adaptor._digraph) {}
-NodeMap(const Adaptor& adaptor, const _Value& value)
+NodeMap(const UndirectorBase<DGR>& adaptor, const V& value)
 : Parent(*adaptor._digraph, value) { }
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
 class ArcMap
-: public SubMapExtender<Adaptor, ArcMapBase<_Value> >
+: public SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> >
 {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent;
+typedef SubMapExtender<Adaptor, ArcMapBase<V> > Parent;
-explicit ArcMap(const Adaptor& adaptor)
+explicit ArcMap(const UndirectorBase<DGR>& adaptor)
 : Parent(adaptor) {}
-ArcMap(const Adaptor& adaptor, const Value& value)
+ArcMap(const UndirectorBase<DGR>& adaptor, const V& value)
 : Parent(adaptor, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class EdgeMap : public Digraph::template ArcMap<_Value> {
+class EdgeMap : public Digraph::template ArcMap<V> {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef typename Digraph::template ArcMap<Value> Parent;
+typedef typename Digraph::template ArcMap<V> Parent;
-explicit EdgeMap(const Adaptor& adaptor)
+explicit EdgeMap(const UndirectorBase<DGR>& adaptor)
 : Parent(*adaptor._digraph) {}
-EdgeMap(const Adaptor& adaptor, const Value& value)
+EdgeMap(const UndirectorBase<DGR>& adaptor, const V& value)
 : Parent(*adaptor._digraph, value) {}
 private:
 EdgeMap& operator=(const EdgeMap& cmap) {
 return operator=<EdgeMap>(cmap);
 return *this;
 }
 };
-typedef typename ItemSetTraits<Digraph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
-typedef typename ItemSetTraits<Digraph, Edge>::ItemNotifier EdgeNotifier;
+typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
 EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
 protected:
 UndirectorBase() : _digraph(0) {}
-Digraph* _digraph;
+DGR* _digraph;
-void setDigraph(Digraph& digraph) {
+void initialize(DGR& digraph) {
 _digraph = &digraph;
 }
 };
 ///
 /// The adapted digraph can also be modified through this adaptor
 /// by adding or removing nodes or edges, unless the \c GR template
 /// parameter is set to be \c const.
 ///
-/// \tparam GR The type of the adapted digraph.
+/// \tparam DGR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It can also be specified to be \c const.
 ///
 /// \note The \c Node type of this adaptor and the adapted digraph are
 /// convertible to each other, moreover the \c Edge type of the adaptor
 /// and the \c Arc type of the adapted digraph are also convertible to
 /// each other.
 /// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type
 /// of the adapted digraph.)
-template<typename GR>
+template<typename DGR>
 #ifdef DOXYGEN
 class Undirector {
 #else
 class Undirector :
-public GraphAdaptorExtender<UndirectorBase<GR> > {
+public GraphAdaptorExtender<UndirectorBase<DGR> > {
 #endif
 public:
 /// The type of the adapted digraph.
-typedef GR Digraph;
+typedef DGR Digraph;
-typedef GraphAdaptorExtender<UndirectorBase<GR> > Parent;
+typedef GraphAdaptorExtender<UndirectorBase<DGR> > Parent;
 protected:
 Undirector() { }
 public:
 /// \brief Constructor
 ///
 /// Creates an undirected graph from the given digraph.
-Undirector(Digraph& digraph) {
+Undirector(DGR& digraph) {
-setDigraph(digraph);
+initialize(digraph);
 }
 /// \brief Arc map combined from two original arc maps
 ///
 /// This map adaptor class adapts two arc maps of the underlying
 /// \brief Returns a read-only Undirector adaptor
 ///
 /// This function just returns a read-only \ref Undirector adaptor.
 /// \ingroup graph_adaptors
 /// \relates Undirector
-template<typename GR>
+template<typename DGR>
-Undirector<const GR> undirector(const GR& digraph) {
+Undirector<const DGR> undirector(const DGR& digraph) {
-return Undirector<const GR>(digraph);
+return Undirector<const DGR>(digraph);
 }
-template <typename _Graph, typename _DirectionMap>
+template <typename GR, typename DM>
 class OrienterBase {
 public:
-typedef _Graph Graph;
+typedef GR Graph;
-typedef _DirectionMap DirectionMap;
+typedef DM DirectionMap;
-typedef typename Graph::Node Node;
+typedef typename GR::Node Node;
-typedef typename Graph::Edge Arc;
+typedef typename GR::Edge Arc;
 void reverseArc(const Arc& arc) {
 _direction->set(arc, !(*_direction)[arc]);
 }
 Arc arcFromId(int idx) const { return _graph->edgeFromId(idx); }
 int maxNodeId() const { return _graph->maxNodeId(); }
 int maxArcId() const { return _graph->maxEdgeId(); }
-typedef typename ItemSetTraits<Graph, Node>::ItemNotifier NodeNotifier;
+typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }
-typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier;
+typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier;
 ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }
-template <typename _Value>
+template <typename V>
-class NodeMap : public _Graph::template NodeMap<_Value> {
+class NodeMap : public GR::template NodeMap<V> {
 public:
-typedef typename _Graph::template NodeMap<_Value> Parent;
+typedef typename GR::template NodeMap<V> Parent;
-explicit NodeMap(const OrienterBase& adapter)
+explicit NodeMap(const OrienterBase<GR, DM>& adapter)
 : Parent(*adapter._graph) {}
-NodeMap(const OrienterBase& adapter, const _Value& value)
+NodeMap(const OrienterBase<GR, DM>& adapter, const V& value)
 : Parent(*adapter._graph, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
-class ArcMap : public _Graph::template EdgeMap<_Value> {
+class ArcMap : public GR::template EdgeMap<V> {
 public:
-typedef typename Graph::template EdgeMap<_Value> Parent;
+typedef typename Graph::template EdgeMap<V> Parent;
-explicit ArcMap(const OrienterBase& adapter)
+explicit ArcMap(const OrienterBase<GR, DM>& adapter)
 : Parent(*adapter._graph) { }
-ArcMap(const OrienterBase& adapter, const _Value& value)
+ArcMap(const OrienterBase<GR, DM>& adapter, const V& value)
 : Parent(*adapter._graph, value) { }
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 protected:
 Graph* _graph;
-DirectionMap* _direction;
+DM* _direction;
-void setDirectionMap(DirectionMap& direction) {
+void initialize(GR& graph, DM& direction) {
+_graph = &graph;
 _direction = &direction;
-}
-void setGraph(Graph& graph) {
-_graph = &graph;
 }
 };
 /// \ingroup graph_adaptors
 public:
 /// \brief Constructor
 ///
 /// Constructor of the adaptor.
-Orienter(Graph& graph, DirectionMap& direction) {
+Orienter(GR& graph, DM& direction) {
-setGraph(graph);
+Parent::initialize(graph, direction);
-setDirectionMap(direction);
 }
 /// \brief Reverses the given arc
 ///
 /// This function reverses the given arc.
 /// This function just returns a read-only \ref Orienter adaptor.
 /// \ingroup graph_adaptors
 /// \relates Orienter
 template<typename GR, typename DM>
 Orienter<const GR, DM>
-orienter(const GR& graph, DM& direction_map) {
+orienter(const GR& graph, DM& direction) {
-return Orienter<const GR, DM>(graph, direction_map);
+return Orienter<const GR, DM>(graph, direction);
 }
 template<typename GR, typename DM>
 Orienter<const GR, const DM>
-orienter(const GR& graph, const DM& direction_map) {
+orienter(const GR& graph, const DM& direction) {
-return Orienter<const GR, const DM>(graph, direction_map);
+return Orienter<const GR, const DM>(graph, direction);
 }
 namespace _adaptor_bits {
-template<typename Digraph,
+template <typename DGR, typename CM, typename FM, typename TL>
-typename CapacityMap,
-typename FlowMap,
-typename Tolerance>
 class ResForwardFilter {
 public:
-typedef typename Digraph::Arc Key;
+typedef typename DGR::Arc Key;
 typedef bool Value;
 private:
-const CapacityMap* _capacity;
+const CM* _capacity;
-const FlowMap* _flow;
+const FM* _flow;
-Tolerance _tolerance;
+TL _tolerance;
 public:
-ResForwardFilter(const CapacityMap& capacity, const FlowMap& flow,
+ResForwardFilter(const CM& capacity, const FM& flow,
-const Tolerance& tolerance = Tolerance())
+const TL& tolerance = TL())
 : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { }
-bool operator[](const typename Digraph::Arc& a) const {
+bool operator[](const typename DGR::Arc& a) const {
 return _tolerance.positive((*_capacity)[a] - (*_flow)[a]);
 }
 };
-template<typename Digraph,
+template<typename DGR,typename CM, typename FM, typename TL>
-typename CapacityMap,
-typename FlowMap,
-typename Tolerance>
 class ResBackwardFilter {
 public:
-typedef typename Digraph::Arc Key;
+typedef typename DGR::Arc Key;
 typedef bool Value;
 private:
-const CapacityMap* _capacity;
+const CM* _capacity;
-const FlowMap* _flow;
+const FM* _flow;
-Tolerance _tolerance;
+TL _tolerance;
 public:
-ResBackwardFilter(const CapacityMap& capacity, const FlowMap& flow,
+ResBackwardFilter(const CM& capacity, const FM& flow,
-const Tolerance& tolerance = Tolerance())
+const TL& tolerance = TL())
 : _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { }
-bool operator[](const typename Digraph::Arc& a) const {
+bool operator[](const typename DGR::Arc& a) const {
 return _tolerance.positive((*_flow)[a]);
 }
 };
 }
 /// multiplicities are counted, i.e. the adaptor has exactly
 /// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel
 /// arcs).
 /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
 ///
-/// \tparam GR The type of the adapted digraph.
+/// \tparam DGR The type of the adapted digraph.
 /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 /// It is implicitly \c const.
 /// \tparam CM The type of the capacity map.
 /// It must be an arc map of some numerical type, which defines
 /// the capacities in the flow problem. It is implicitly \c const.
 ///
 /// \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>
+template<typename DGR, typename CM, typename FM, typename TL>
 class ResidualDigraph
 #else
-template<typename GR,
+template<typename DGR,
-typename CM = typename GR::template ArcMap<int>,
+typename CM = typename DGR::template ArcMap<int>,
 typename FM = CM,
 typename TL = Tolerance<typename CM::Value> >
-class ResidualDigraph :
+class ResidualDigraph
-public FilterArcs<
+: public SubDigraph<
-Undirector<const GR>,
+Undirector<const DGR>,
-typename Undirector<const GR>::template CombinedArcMap<
+ConstMap<typename DGR::Node, Const<bool, true> >,
-_adaptor_bits::ResForwardFilter<const GR, CM, FM, TL>,
+typename Undirector<const DGR>::template CombinedArcMap<
-_adaptor_bits::ResBackwardFilter<const GR, CM, FM, TL> > >
+_adaptor_bits::ResForwardFilter<const DGR, CM, FM, TL>,
+_adaptor_bits::ResBackwardFilter<const DGR, CM, FM, TL> > >
 #endif
 {
 public:
 /// The type of the underlying digraph.
-typedef GR Digraph;
+typedef DGR Digraph;
 /// The type of the capacity map.
 typedef CM CapacityMap;
 /// The type of the flow map.
 typedef FM FlowMap;
 /// The tolerance type.
 protected:
 typedef Undirector<const Digraph> Undirected;
-typedef _adaptor_bits::ResForwardFilter<const Digraph, CapacityMap,
+typedef ConstMap<typename DGR::Node, Const<bool, true> > NodeFilter;
-FlowMap, Tolerance> ForwardFilter;
+typedef _adaptor_bits::ResForwardFilter<const DGR, CM,
-typedef _adaptor_bits::ResBackwardFilter<const Digraph, CapacityMap,
+FM, TL> ForwardFilter;
-FlowMap, Tolerance> BackwardFilter;
+typedef _adaptor_bits::ResBackwardFilter<const DGR, CM,
+FM, TL> BackwardFilter;
 typedef typename Undirected::
 template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter;
-typedef FilterArcs<Undirected, ArcFilter> Parent;
+typedef SubDigraph<Undirected, NodeFilter, ArcFilter> Parent;
 const CapacityMap* _capacity;
 FlowMap* _flow;
 Undirected _graph;
+NodeFilter _node_filter;
 ForwardFilter _forward_filter;
 BackwardFilter _backward_filter;
 ArcFilter _arc_filter;
 public:
 /// \brief Constructor
 ///
 /// Constructor of the residual digraph adaptor. The parameters are the
 /// digraph, the capacity map, the flow map, and a tolerance object.
-ResidualDigraph(const Digraph& digraph, const CapacityMap& capacity,
+ResidualDigraph(const DGR& digraph, const CM& capacity,
-FlowMap& flow, const Tolerance& tolerance = Tolerance())
+FM& flow, const TL& tolerance = Tolerance())
-: Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph),
+: Parent(), _capacity(&capacity), _flow(&flow),
+_graph(digraph), _node_filter(),
 _forward_filter(capacity, flow, tolerance),
 _backward_filter(capacity, flow, tolerance),
 _arc_filter(_forward_filter, _backward_filter)
 {
-Parent::setDigraph(_graph);
+Parent::initialize(_graph, _node_filter, _arc_filter);
-Parent::setArcFilterMap(_arc_filter);
 }
 typedef typename Parent::Arc Arc;
 /// \brief Returns the residual capacity of the given arc.
 typedef Arc Key;
 /// The value type of the map
 typedef typename CapacityMap::Value Value;
 /// Constructor
-ResidualCapacity(const Adaptor& adaptor) : _adaptor(&adaptor) {}
+ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+: _adaptor(&adaptor) {}
 /// Returns the value associated with the given residual arc
 Value operator[](const Arc& a) const {
 return _adaptor->residualCapacity(a);
 }
 };
 /// \brief Returns a (read-only) Residual adaptor
 ///
-/// This function just returns a (read-only) \ref Residual adaptor.
+/// This function just returns a (read-only) \ref ResidualDigraph adaptor.
 /// \ingroup graph_adaptors
-/// \relates Residual
+/// \relates ResidualDigraph
-template<typename GR, typename CM, typename FM>
+template<typename DGR, typename CM, typename FM>
-ResidualDigraph<GR, CM, FM>
+ResidualDigraph<DGR, CM, FM>
-residualDigraph(const GR& digraph, const CM& capacity_map, FM& flow_map) {
+residualDigraph(const DGR& digraph, const CM& capacity_map, FM& flow_map) {
-return ResidualDigraph<GR, CM, FM> (digraph, capacity_map, flow_map);
+return ResidualDigraph<DGR, CM, FM> (digraph, capacity_map, flow_map);
 }
-template <typename _Digraph>
+template <typename DGR>
 class SplitNodesBase {
 public:
-typedef _Digraph Digraph;
+typedef DGR Digraph;
-typedef DigraphAdaptorBase<const _Digraph> Parent;
+typedef DigraphAdaptorBase<const DGR> Parent;
 typedef SplitNodesBase Adaptor;
-typedef typename Digraph::Node DigraphNode;
+typedef typename DGR::Node DigraphNode;
-typedef typename Digraph::Arc DigraphArc;
+typedef typename DGR::Arc DigraphArc;
 class Node;
 class Arc;
 private:
 return INVALID;
 }
 private:
-template <typename _Value>
+template <typename V>
 class NodeMapBase
-: public MapTraits<typename Parent::template NodeMap<_Value> > {
+: public MapTraits<typename Parent::template NodeMap<V> > {
-typedef typename Parent::template NodeMap<_Value> NodeImpl;
+typedef typename Parent::template NodeMap<V> NodeImpl;
 public:
 typedef Node Key;
-typedef _Value Value;
+typedef V 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)
+NodeMapBase(const SplitNodesBase<DGR>& adaptor)
 : _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {}
-NodeMapBase(const Adaptor& adaptor, const Value& value)
+NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
 : _in_map(*adaptor._digraph, value),
 _out_map(*adaptor._digraph, value) {}
-void set(const Node& key, const Value& val) {
+void set(const Node& key, const V& val) {
-if (Adaptor::inNode(key)) { _in_map.set(key, val); }
+if (SplitNodesBase<DGR>::inNode(key)) { _in_map.set(key, val); }
 else {_out_map.set(key, val); }
 }
 ReturnValue operator[](const Node& key) {
-if (Adaptor::inNode(key)) { return _in_map[key]; }
+if (SplitNodesBase<DGR>::inNode(key)) { return _in_map[key]; }
 else { return _out_map[key]; }
 }
 ConstReturnValue operator[](const Node& key) const {
 if (Adaptor::inNode(key)) { return _in_map[key]; }
 private:
 NodeImpl _in_map, _out_map;
 };
-template <typename _Value>
+template <typename V>
 class ArcMapBase
-: public MapTraits<typename Parent::template ArcMap<_Value> > {
+: public MapTraits<typename Parent::template ArcMap<V> > {
-typedef typename Parent::template ArcMap<_Value> ArcImpl;
+typedef typename Parent::template ArcMap<V> ArcImpl;
-typedef typename Parent::template NodeMap<_Value> NodeImpl;
+typedef typename Parent::template NodeMap<V> NodeImpl;
 public:
 typedef Arc Key;
-typedef _Value Value;
+typedef V 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)
+ArcMapBase(const SplitNodesBase<DGR>& adaptor)
 : _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {}
-ArcMapBase(const Adaptor& adaptor, const Value& value)
+ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value)
 : _arc_map(*adaptor._digraph, value),
 _node_map(*adaptor._digraph, value) {}
-void set(const Arc& key, const Value& val) {
+void set(const Arc& key, const V& val) {
-if (Adaptor::origArc(key)) {
+if (SplitNodesBase<DGR>::origArc(key)) {
 _arc_map.set(key._item.first(), val);
 } else {
 _node_map.set(key._item.second(), val);
 }
 }
 ReturnValue operator[](const Arc& key) {
-if (Adaptor::origArc(key)) {
+if (SplitNodesBase<DGR>::origArc(key)) {
 return _arc_map[key._item.first()];
 } else {
 return _node_map[key._item.second()];
 }
 }
 ConstReturnValue operator[](const Arc& key) const {
-if (Adaptor::origArc(key)) {
+if (SplitNodesBase<DGR>::origArc(key)) {
 return _arc_map[key._item.first()];
 } else {
 return _node_map[key._item.second()];
 }
 }
 NodeImpl _node_map;
 };
 public:
-template <typename _Value>
+template <typename V>
 class NodeMap
-: public SubMapExtender<Adaptor, NodeMapBase<_Value> >
+: public SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> >
 {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, NodeMapBase<Value> > Parent;
+typedef SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<Value> > Parent;
-NodeMap(const Adaptor& adaptor)
+NodeMap(const SplitNodesBase<DGR>& adaptor)
 : Parent(adaptor) {}
-NodeMap(const Adaptor& adaptor, const Value& value)
+NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value)
 : Parent(adaptor, value) {}
 private:
 NodeMap& operator=(const NodeMap& cmap) {
 return operator=<NodeMap>(cmap);
 Parent::operator=(cmap);
 return *this;
 }
 };
-template <typename _Value>
+template <typename V>
 class ArcMap
-: public SubMapExtender<Adaptor, ArcMapBase<_Value> >
+: public SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> >
 {
 public:
-typedef _Value Value;
+typedef V Value;
-typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent;
+typedef SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<Value> > Parent;
-ArcMap(const Adaptor& adaptor)
+ArcMap(const SplitNodesBase<DGR>& adaptor)
 : Parent(adaptor) {}
-ArcMap(const Adaptor& adaptor, const Value& value)
+ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value)
 : Parent(adaptor, value) {}
 private:
 ArcMap& operator=(const ArcMap& cmap) {
 return operator=<ArcMap>(cmap);
 protected:
 SplitNodesBase() : _digraph(0) {}
-Digraph* _digraph;
+DGR* _digraph;
-void setDigraph(Digraph& digraph) {
+void initialize(Digraph& digraph) {
 _digraph = &digraph;
 }
 };
 /// capacities directly.
 /// In this case you can use \c SplitNodes adaptor, and set the node
 /// costs/capacities of the original digraph to the \e bind \e arcs
 /// in the adaptor.
 ///
-/// \tparam GR The type of the adapted digraph.
+/// \tparam DGR 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>
+template <typename DGR>
 #ifdef DOXYGEN
 class SplitNodes {
 #else
 class SplitNodes
-: public DigraphAdaptorExtender<SplitNodesBase<const GR> > {
+: public DigraphAdaptorExtender<SplitNodesBase<const DGR> > {
 #endif
 public:
-typedef GR Digraph;
+typedef DGR Digraph;
-typedef DigraphAdaptorExtender<SplitNodesBase<const GR> > Parent;
+typedef DigraphAdaptorExtender<SplitNodesBase<const DGR> > Parent;
-typedef typename Digraph::Node DigraphNode;
+typedef typename DGR::Node DigraphNode;
-typedef typename Digraph::Arc DigraphArc;
+typedef typename DGR::Arc DigraphArc;
 typedef typename Parent::Node Node;
 typedef typename Parent::Arc Arc;
 /// \brief Constructor
 ///
 /// Constructor of the adaptor.
-SplitNodes(const Digraph& g) {
+SplitNodes(const DGR& g) {
-Parent::setDigraph(g);
+Parent::initialize(g);
 }
 /// \brief Returns \c true if the given node is an in-node.
 ///
 /// Returns \c true if the given node is an in-node.
 CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
 : _in_map(in_map), _out_map(out_map) {}
 /// Returns the value associated with the given key.
 Value operator[](const Key& key) const {
-if (Parent::inNode(key)) {
+if (SplitNodesBase<const DGR>::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)) {
+if (SplitNodesBase<const DGR>::inNode(key)) {
 return _in_map[key];
 } else {
 return _out_map[key];
 }
 }
 /// Sets the value associated with the given key.
 void set(const Key& key, const Value& value) {
-if (Parent::inNode(key)) {
+if (SplitNodesBase<const DGR>::inNode(key)) {
 _in_map.set(key, value);
 } else {
 _out_map.set(key, value);
 }
 }
 CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
 : _arc_map(arc_map), _node_map(node_map) {}
 /// Returns the value associated with the given key.
 Value operator[](const Key& arc) const {
-if (Parent::origArc(arc)) {
+if (SplitNodesBase<const DGR>::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)) {
+if (SplitNodesBase<const DGR>::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)) {
+if (SplitNodesBase<const DGR>::origArc(arc)) {
 _arc_map.set(arc, val);
 } else {
 _node_map.set(arc, val);
 }
 }
 /// \brief Returns a (read-only) SplitNodes adaptor
 ///
 /// This function just returns a (read-only) \ref SplitNodes adaptor.
 /// \ingroup graph_adaptors
 /// \relates SplitNodes
-template<typename GR>
+template<typename DGR>
-SplitNodes<GR>
+SplitNodes<DGR>
-splitNodes(const GR& digraph) {
+splitNodes(const DGR& digraph) {
-return SplitNodes<GR>(digraph);
+return SplitNodes<DGR>(digraph);
 }
+#undef LEMON_SCOPE_FIX
 } //namespace lemon
 #endif //LEMON_ADAPTORS_H

changeset 489	2a136de8e3f2
parent 464	acfb0f24d178
child 495	dab9e610e37d