RhodeCode

    template <typename V>

    class NodeMap : public DGR::template NodeMap<V> {

    public:

      explicit NodeMap(const Adaptor& adaptor)

        : Parent(*adaptor._digraph) {}

      NodeMap(const Adaptor& adaptor, const V& value)

        : Parent(*adaptor._digraph, value) { }

    template <typename V>

    class ArcMap : public DGR::template ArcMap<V> {

    public:

      explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)

        : Parent(*adaptor._digraph) {}

      ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)

        : Parent(*adaptor._digraph, value) {}

    template <typename V>

    class NodeMap : public GR::template NodeMap<V> {

    public:

      explicit NodeMap(const GraphAdaptorBase<GR>& adapter)

        : Parent(*adapter._graph) {}

    template <typename V>

    class ArcMap : public GR::template ArcMap<V> {

    public:

      explicit ArcMap(const GraphAdaptorBase<GR>& adapter)

        : Parent(*adapter._graph) {}

    template <typename V>

    class EdgeMap : public GR::template EdgeMap<V> {

    public:

      explicit EdgeMap(const GraphAdaptorBase<GR>& adapter)

        : Parent(*adapter._graph) {}

  template <typename DGR>

  class ReverseDigraphBase : public DigraphAdaptorBase<DGR> {

  public:

    typedef DGR Digraph;

  protected:

    ReverseDigraphBase() : Parent() { }

    public DigraphAdaptorExtender<ReverseDigraphBase<DGR> > {

#endif

  public:

    /// The type of the adapted digraph.

    typedef DGR Digraph;

  protected:

    ReverseDigraph() { }

  template <typename DGR, typename NF, typename AF, bool ch = true>

  class SubDigraphBase : public DigraphAdaptorBase<DGR> {

  public:

    typedef DGR Digraph;

    typedef SubDigraphBase Adaptor;

  protected:

    NF* _node_filter;

      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 

	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {

    public:

      typedef V Value;

      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)

      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,

	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {

    public:

      typedef V Value;

      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)

  class SubDigraphBase<DGR, NF, AF, false>

    : public DigraphAdaptorBase<DGR> {

  public:

    typedef DGR Digraph;

    typedef SubDigraphBase Adaptor;

  protected:

    NF* _node_filter;

      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,

          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {

    public:

      typedef V Value;

      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)

      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,

          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {

    public:

      typedef V Value;

      ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)

  template <typename GR, typename NF, typename EF, bool ch = true>

  class SubGraphBase : public GraphAdaptorBase<GR> {

  public:

    typedef GR Graph;

    typedef SubGraphBase Adaptor;

  protected:

      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,

          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {

    public:

      typedef V Value;

      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)

      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,

          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {

    public:

      typedef V Value;

      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)

      : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,

        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {

    public:

      typedef V Value;

      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)

  class SubGraphBase<GR, NF, EF, false>

    : public GraphAdaptorBase<GR> {

  public:

    typedef GR Graph;

    typedef SubGraphBase Adaptor;

  protected:

    NF* _node_filter;

      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,

          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {

    public:

      typedef V Value;

      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)

      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,

          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {

    public:

      typedef V Value;

      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor)

      : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,

        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {

    public:

      typedef V Value;

      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)

                     true> > {

#endif

    typedef DigraphAdaptorExtender<

      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 

                     true> > Parent;

    typedef typename Parent::Node Node;

                   true> > {

    typedef GraphAdaptorExtender<

      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 

                   true> > Parent;

    typedef typename Parent::Node Node;

  protected:

    ConstMap<typename GR::Edge, Const<bool, true> > const_true_map;

                     AF, false> > {

#endif

  public:

    /// The type of the adapted digraph.

    typedef DGR Digraph;

    typedef AF ArcFilterMap;

    typedef typename Parent::Arc Arc;

                   EF, false> > {

#endif

  public:

    /// The type of the adapted graph.

    typedef GR Graph;

    typedef EF EdgeFilterMap;

    typedef typename Parent::Edge Edge;

    template <typename V>

    class NodeMap : public DGR::template NodeMap<V> {

    public:

      typedef V Value;

      explicit NodeMap(const UndirectorBase<DGR>& adaptor)

    template <typename V>

    class ArcMap

    public:

      typedef V Value;

      explicit ArcMap(const UndirectorBase<DGR>& adaptor)

    template <typename V>

    class EdgeMap : public Digraph::template ArcMap<V> {

    public:

      typedef V Value;

      explicit EdgeMap(const UndirectorBase<DGR>& adaptor)

    public GraphAdaptorExtender<UndirectorBase<DGR> > {

#endif

  public:

    /// The type of the adapted digraph.

    typedef DGR Digraph;

  protected:

    Undirector() { }

    template <typename V>

    class NodeMap : public GR::template NodeMap<V> {

    public:

      explicit NodeMap(const OrienterBase<GR, DM>& adapter)

        : Parent(*adapter._graph) {}

    template <typename V>

    class ArcMap : public GR::template EdgeMap<V> {

    public:

      explicit ArcMap(const OrienterBase<GR, DM>& adapter)

        : Parent(*adapter._graph) { }

    public DigraphAdaptorExtender<OrienterBase<GR, DM> > {

#endif

  public:

    typedef DM DirectionMap;

    typedef typename Parent::Arc Arc;

  protected:

    Orienter() { }

  public:

  template <typename DGR>

  class SplitNodesBase {

  public:

    typedef DGR Digraph;

    typedef SplitNodesBase Adaptor;

    template <typename V>

    class NodeMap

    public:

      typedef V Value;

      NodeMap(const SplitNodesBase<DGR>& adaptor)

    template <typename V>

    class ArcMap

    public:

      typedef V Value;

      ArcMap(const SplitNodesBase<DGR>& adaptor)

    : public DigraphAdaptorExtender<SplitNodesBase<const DGR> > {

#endif

  public:

    typedef DGR Digraph;

    typedef typename DGR::Node DigraphNode;

  public:

    // The graph type.

    // The item type.

    typedef _Item Item;

    typedef _Value& Reference;

    // The notifier type.

    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;

    // The MapBase of the Map which imlements the core regisitry function.

    typedef typename Notifier::ObserverBase Parent;

    typedef std::allocator<Value> Allocator;

    //

    // Graph initialized map constructor.

      Parent::attach(graph.notifier(Item()));

      allocate_memory();

    //

    // It constructs a map and initialize all of the the map.

      Parent::attach(graph.notifier(Item()));

      allocate_memory();

  template <typename Base>

  class UndirDigraphExtender : public Base {

  public:

    typedef typename Parent::Arc Edge;

    typedef typename Parent::Node Node;

  template <typename Base>

  class BidirBpGraphExtender : public Base {

  public:

    typedef BidirBpGraphExtender Digraph;

  class DefaultMap

    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {

  public:

    typedef DefaultMap<_Graph, _Item, _Value> Map;

    typedef typename Parent::Value Value;

      : Parent(graph, value) {}

  template <typename Base>

  class ArcSetExtender : public Base {

  public:

    typedef ArcSetExtender Digraph;

    class ArcMap 

      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {

      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;

      explicit ArcMap(const Digraph& _g) 

	: Parent(_g) {}

  template <typename Base>

  class EdgeSetExtender : public Base {

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Edge Edge;

    int maxId(Node) const {

      return Parent::maxNodeId();

    class NodeIt : public Node { 

    public:

      NodeIt(Invalid i) : Node(i) { }

	_graph.first(static_cast<Node&>(*this));

      }

      NodeIt& operator++() { 

	return *this; 

      }

    class ArcIt : public Arc { 

    public:

      ArcIt(Invalid i) : Arc(i) { }

	_graph.first(static_cast<Arc&>(*this));

      }

      ArcIt& operator++() { 

	return *this; 

      }

    class OutArcIt : public Arc { 

    public:

      OutArcIt(Invalid i) : Arc(i) { }

	_graph.firstOut(*this, node);

      }

      OutArcIt& operator++() { 

	return *this; 

      }

    class InArcIt : public Arc { 

    public:

      InArcIt(Invalid i) : Arc(i) { }

	_graph.firstIn(*this, node);

      }

      InArcIt& operator++() { 

	return *this; 

      }

    class EdgeIt : public Parent::Edge { 

    public:

      EdgeIt(Invalid i) : Edge(i) { }

	_graph.first(static_cast<Edge&>(*this));

      }

      EdgeIt& operator++() { 

	return *this; 

      }

    class IncEdgeIt : public Parent::Edge {

      friend class EdgeSetExtender;

      bool direction;

    public:

      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }

	_graph.firstInc(*this, direction, n);

      }

	direction = (_graph.source(ue) == n);

      }

      IncEdgeIt& operator++() {

	return *this; 

      }

    template <typename _Value>

    class ArcMap 

    public:

	: Parent(_g) {}

	: Parent(_g, _v) {}

    template <typename _Value>

    class EdgeMap 

    public:

	: Parent(_g) {}

	: Parent(_g, _v) {}

  template <typename _Digraph>

  class DigraphAdaptorExtender : public _Digraph {

  public:

    typedef _Digraph Digraph;

    typedef DigraphAdaptorExtender Adaptor;

  template <typename _Graph>

  class GraphAdaptorExtender : public _Graph {

  public:

    typedef _Graph Graph;

    typedef GraphAdaptorExtender Adaptor;

  template <typename Base>

  class DigraphExtender : public Base {

  public:

    typedef DigraphExtender Digraph;

    class NodeMap

      : public MapExtender<DefaultMap<Digraph, Node, _Value> > {

      typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;

      explicit NodeMap(const Digraph& digraph)

        : Parent(digraph) {}

    class ArcMap

      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {

      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;

      explicit ArcMap(const Digraph& digraph)

        : Parent(digraph) {}

  template <typename Base>

  class GraphExtender : public Base {

  public:

    typedef GraphExtender Graph;

    class NodeMap

      : public MapExtender<DefaultMap<Graph, Node, _Value> > {

      typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;

      NodeMap(const Graph& graph)

        : Parent(graph) {}

    class ArcMap

      : public MapExtender<DefaultMap<Graph, Arc, _Value> > {

      typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;

      ArcMap(const Graph& graph)

        : Parent(graph) {}

    class EdgeMap

      : public MapExtender<DefaultMap<Graph, Edge, _Value> > {

      typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;

      EdgeMap(const Graph& graph)

        : Parent(graph) {}

  template <typename _Map>

  class MapExtender : public _Map {

  public:

    typedef MapExtender Map;

    typedef typename Parent::Key Item;

  public:

      : Parent(graph) {}

      : Parent(graph, value) {}

  public:

    class MapIt : public Item {

    public:

      typedef typename Map::Value Value;

    class ConstMapIt : public Item {

    public:

      typedef typename Map::Value Value;

    class ItemIt : public Item {

    public:

      ItemIt() {}

  template <typename _Graph, typename _Map>

  class SubMapExtender : public _Map {

  public:

    typedef SubMapExtender Map;

    typedef typename Parent::Key Item;

  public:

      : Parent(_graph), graph(_graph) {}

      : Parent(_graph, _value), graph(_graph) {}

  public:

    class MapIt : public Item {

    public:

      typedef typename Map::Value Value;

    class ConstMapIt : public Item {

    public:

      typedef typename Map::Value Value;

    class ItemIt : public Item {

    public:

      ItemIt() {}

  private:

  };

    // The graph type of the map.

    // The item type of the map.

    typedef _Item Item;

    // The map type.

    typedef VectorMap Map;

    // The reference type of the map;

    typedef typename Container::const_reference ConstReference;

    // \brief Constructor to attach the new map into the notifier.

    // It constructs a map and attachs it into the notifier.

    // It adds all the items of the graph to the map.

      Parent::attach(graph.notifier(Item()));

      container.resize(Parent::notifier()->maxId() + 1);

    // It constructs a map uses a given value to initialize the map.

    // It adds all the items of the graph to the map.

      Parent::attach(graph.notifier(Item()));

      container.resize(Parent::notifier()->maxId() + 1, value);

    class BaseGraphComponent : public BaseDigraphComponent {

    public:

      typedef BaseDigraphComponent::Node Node;

      typedef BaseDigraphComponent::Arc Arc;

      /// represented by two opposite directed arcs.

      class Edge : public GraphItem<'e'> {

        typedef GraphItem<'e'> Parent;

        /// \brief Default constructor.

        ///

    template <typename GR, typename K, typename V>

    class GraphMap : public ReferenceMap<K, V, V&, const V&> {

    public:

      /// The key type of the map.

      typedef K Key;

      ///

      /// Construct a new map for the graph.

      /// \brief Construct a new map with default value.

      ///

      /// Construct a new map for the graph and initalize the values.

    private:

        const _Map &m;