/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * Copyright (C) 2003-2010

 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_EDGE_SET_H

#define LEMON_EDGE_SET_H

#include <lemon/core.h>

#include <lemon/bits/edge_set_extender.h>

/// \ingroup graphs

/// \file

/// \brief ArcSet and EdgeSet classes.

///

/// Graphs which use another graph's node-set as own.

namespace lemon {

  template <typename GR>

  class ListArcSetBase {

  public:

    typedef typename GR::Node Node;

    typedef typename GR::NodeIt NodeIt;

  protected:

    struct NodeT {

      int first_out, first_in;

      NodeT() : first_out(-1), first_in(-1) {}

    };

    typedef typename ItemSetTraits<GR, Node>::

    template Map<NodeT>::Type NodesImplBase;

    NodesImplBase* _nodes;

    struct ArcT {

      Node source, target;

      int next_out, next_in;

      int prev_out, prev_in;

      ArcT() : prev_out(-1), prev_in(-1) {}

    };

    std::vector<ArcT> arcs;

    int first_arc;

    int first_free_arc;

    const GR* _graph;

    void initalize(const GR& graph, NodesImplBase& nodes) {

      _graph = &graph;

      _nodes = &nodes;

    }

  public:

    class Arc {

      friend class ListArcSetBase<GR>;

    protected:

      Arc(int _id) : id(_id) {}

      int id;

    public:

      Arc() {}

      Arc(Invalid) : id(-1) {}

      bool operator==(const Arc& arc) const { return id == arc.id; }

      bool operator!=(const Arc& arc) const { return id != arc.id; }

      bool operator<(const Arc& arc) const { return id < arc.id; }

    };

    ListArcSetBase() : first_arc(-1), first_free_arc(-1) {}

    Node addNode() {

      LEMON_ASSERT(false,

        "This graph structure does not support node insertion");

      return INVALID; // avoid warning

    }

    Arc addArc(const Node& u, const Node& v) {

      int n;

      if (first_free_arc == -1) {

        n = arcs.size();

        arcs.push_back(ArcT());

      } else {

        n = first_free_arc;

        first_free_arc = arcs[first_free_arc].next_in;

      }

      arcs[n].next_in = (*_nodes)[v].first_in;

      if ((*_nodes)[v].first_in != -1) {

        arcs[(*_nodes)[v].first_in].prev_in = n;

      }

      (*_nodes)[v].first_in = n;

      arcs[n].next_out = (*_nodes)[u].first_out;

      if ((*_nodes)[u].first_out != -1) {

        arcs[(*_nodes)[u].first_out].prev_out = n;

      }

      (*_nodes)[u].first_out = n;

      arcs[n].source = u;

      arcs[n].target = v;

      return Arc(n);

    }

    void erase(const Arc& arc) {

      int n = arc.id;

      if (arcs[n].prev_in != -1) {

        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;

      } else {

        (*_nodes)[arcs[n].target].first_in = arcs[n].next_in;

      }

      if (arcs[n].next_in != -1) {

        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;

      }

      if (arcs[n].prev_out != -1) {

        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;

      } else {

        (*_nodes)[arcs[n].source].first_out = arcs[n].next_out;

      }

      if (arcs[n].next_out != -1) {

        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;

      }

    }

    void clear() {

      Node node;

      for (first(node); node != INVALID; next(node)) {

        (*_nodes)[node].first_in = -1;

        (*_nodes)[node].first_out = -1;

      }

      arcs.clear();

      first_arc = -1;

      first_free_arc = -1;

    }

    void first(Node& node) const {

      _graph->first(node);

    }

    void next(Node& node) const {

      _graph->next(node);

    }

    void first(Arc& arc) const {

      Node node;

      first(node);

      while (node != INVALID && (*_nodes)[node].first_in == -1) {

        next(node);

      }

      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;

    }

    void next(Arc& arc) const {

      if (arcs[arc.id].next_in != -1) {

        arc.id = arcs[arc.id].next_in;

      } else {

        Node node = arcs[arc.id].target;

        next(node);

        while (node != INVALID && (*_nodes)[node].first_in == -1) {

          next(node);

        }

        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;

      }

    }

    void firstOut(Arc& arc, const Node& node) const {

      arc.id = (*_nodes)[node].first_out;

    }

    void nextOut(Arc& arc) const {

      arc.id = arcs[arc.id].next_out;

    }

    void firstIn(Arc& arc, const Node& node) const {

      arc.id = (*_nodes)[node].first_in;

    }

    void nextIn(Arc& arc) const {

      arc.id = arcs[arc.id].next_in;

    }

    int id(const Node& node) const { return _graph->id(node); }

    int id(const Arc& arc) const { return arc.id; }

    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }

    Arc arcFromId(int ix) const { return Arc(ix); }

    int maxNodeId() const { return _graph->maxNodeId(); };

    int maxArcId() const { return arcs.size() - 1; }

    Node source(const Arc& arc) const { return arcs[arc.id].source;}

    Node target(const Arc& arc) const { return arcs[arc.id].target;}

    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;

    NodeNotifier& notifier(Node) const {

      return _graph->notifier(Node());

    }

    template <typename V>

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

      typedef typename GR::template NodeMap<V> Parent;

    public:

      explicit NodeMap(const ListArcSetBase<GR>& arcset)

        : Parent(*arcset._graph) {}

      NodeMap(const ListArcSetBase<GR>& arcset, const V& value)

        : Parent(*arcset._graph, value) {}

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

  };

  /// \ingroup graphs

  ///

  /// \brief Digraph using a node set of another digraph or graph and

  /// an own arc set.

  ///

  /// This structure can be used to establish another directed graph

  /// over a node set of an existing one. This class uses the same

  /// Node type as the underlying graph, and each valid node of the

  /// original graph is valid in this arc set, therefore the node

  /// objects of the original graph can be used directly with this

  /// class. The node handling functions (id handling, observing, and

  /// iterators) works equivalently as in the original graph.

  ///

  /// This implementation is based on doubly-linked lists, from each

  /// node the outgoing and the incoming arcs make up lists, therefore

  /// one arc can be erased in constant time. It also makes possible,

  /// that node can be removed from the underlying graph, in this case

  /// all arcs incident to the given node is erased from the arc set.

  ///

  /// This class fully conforms to the \ref concepts::Digraph

  /// "Digraph" concept.

  /// It provides only linear time counting for nodes and arcs.

  ///

  /// \param GR The type of the graph which shares its node set with

  /// this class. Its interface must conform to the

  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"

  /// concept.

  template <typename GR>

  class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {

    typedef ArcSetExtender<ListArcSetBase<GR> > Parent;

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

    typedef typename Parent::NodesImplBase NodesImplBase;

    void eraseNode(const Node& node) {

      Arc arc;

      Parent::firstOut(arc, node);

      while (arc != INVALID ) {

        erase(arc);

        Parent::firstOut(arc, node);

      }

      Parent::firstIn(arc, node);

      while (arc != INVALID ) {

        erase(arc);

        Parent::firstIn(arc, node);

      }

    }

    void clearNodes() {

      Parent::clear();

    }

    class NodesImpl : public NodesImplBase {

      typedef NodesImplBase Parent;

    public:

      NodesImpl(const GR& graph, ListArcSet& arcset)

        : Parent(graph), _arcset(arcset) {}

      virtual ~NodesImpl() {}

    protected:

      virtual void erase(const Node& node) {

        _arcset.eraseNode(node);

        Parent::erase(node);

      }

      virtual void erase(const std::vector<Node>& nodes) {

        for (int i = 0; i < int(nodes.size()); ++i) {

          _arcset.eraseNode(nodes[i]);

        }

        Parent::erase(nodes);

      }

      virtual void clear() {

        _arcset.clearNodes();

        Parent::clear();

      }

    private:

      ListArcSet& _arcset;

    };

    NodesImpl _nodes;

  public:

    /// \brief Constructor of the ArcSet.

    ///

    /// Constructor of the ArcSet.

    ListArcSet(const GR& graph) : _nodes(graph, *this) {

      Parent::initalize(graph, _nodes);

    }

    /// \brief Add a new arc to the digraph.

    ///

    /// Add a new arc to the digraph with source node \c s

    /// and target node \c t.

    /// \return The new arc.

    Arc addArc(const Node& s, const Node& t) {

      return Parent::addArc(s, t);

    }

    /// \brief Erase an arc from the digraph.

    ///

    /// Erase an arc \c a from the digraph.

    void erase(const Arc& a) {

      return Parent::erase(a);

    }

  };

  template <typename GR>

  class ListEdgeSetBase {

  public:

    typedef typename GR::Node Node;

    typedef typename GR::NodeIt NodeIt;

  protected:

    struct NodeT {

      int first_out;

      NodeT() : first_out(-1) {}

    };

    typedef typename ItemSetTraits<GR, Node>::

    template Map<NodeT>::Type NodesImplBase;

    NodesImplBase* _nodes;

    struct ArcT {

      Node target;

      int prev_out, next_out;

      ArcT() : prev_out(-1), next_out(-1) {}

    };

    std::vector<ArcT> arcs;

    int first_arc;

    int first_free_arc;

    const GR* _graph;

    void initalize(const GR& graph, NodesImplBase& nodes) {

      _graph = &graph;

      _nodes = &nodes;

    }

  public:

    class Edge {

      friend class ListEdgeSetBase;

    protected:

      int id;

      explicit Edge(int _id) { id = _id;}

    public:

      Edge() {}

      Edge (Invalid) { id = -1; }

      bool operator==(const Edge& arc) const {return id == arc.id;}

      bool operator!=(const Edge& arc) const {return id != arc.id;}

      bool operator<(const Edge& arc) const {return id < arc.id;}

    };

    class Arc {

      friend class ListEdgeSetBase;

    protected:

      Arc(int _id) : id(_id) {}

      int id;

    public:

      operator Edge() const { return edgeFromId(id / 2); }

      Arc() {}

      Arc(Invalid) : id(-1) {}

      bool operator==(const Arc& arc) const { return id == arc.id; }

      bool operator!=(const Arc& arc) const { return id != arc.id; }

      bool operator<(const Arc& arc) const { return id < arc.id; }

    };

    ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {}

    Node addNode() {

      LEMON_ASSERT(false,

        "This graph structure does not support node insertion");

      return INVALID; // avoid warning

    }

    Edge addEdge(const Node& u, const Node& v) {

      int n;

      if (first_free_arc == -1) {

        n = arcs.size();

        arcs.push_back(ArcT());

        arcs.push_back(ArcT());

      } else {

        n = first_free_arc;

        first_free_arc = arcs[n].next_out;

      }

      arcs[n].target = u;

      arcs[n | 1].target = v;

      arcs[n].next_out = (*_nodes)[v].first_out;

      if ((*_nodes)[v].first_out != -1) {

        arcs[(*_nodes)[v].first_out].prev_out = n;

      }

      (*_nodes)[v].first_out = n;

      arcs[n].prev_out = -1;

      if ((*_nodes)[u].first_out != -1) {

        arcs[(*_nodes)[u].first_out].prev_out = (n | 1);

      }

      arcs[n | 1].next_out = (*_nodes)[u].first_out;

      (*_nodes)[u].first_out = (n | 1);

      arcs[n | 1].prev_out = -1;

      return Edge(n / 2);

    }

    void erase(const Edge& arc) {

      int n = arc.id * 2;

      if (arcs[n].next_out != -1) {

        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;

      }

      if (arcs[n].prev_out != -1) {

        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;

      } else {

        (*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;

      }

      if (arcs[n | 1].next_out != -1) {

        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;

      }

      if (arcs[n | 1].prev_out != -1) {

        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;

      } else {

        (*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;

      }

      arcs[n].next_out = first_free_arc;

      first_free_arc = n;

    }

    void clear() {

      Node node;

      for (first(node); node != INVALID; next(node)) {

        (*_nodes)[node].first_out = -1;

      }

      arcs.clear();

      first_arc = -1;

      first_free_arc = -1;

    }

    void first(Node& node) const {

      _graph->first(node);

    }

    void next(Node& node) const {

      _graph->next(node);

    }

    void first(Arc& arc) const {

      Node node;

      first(node);

      while (node != INVALID && (*_nodes)[node].first_out == -1) {

        next(node);

      }

      arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;

    }

    void next(Arc& arc) const {

      if (arcs[arc.id].next_out != -1) {

        arc.id = arcs[arc.id].next_out;

      } else {

        Node node = arcs[arc.id ^ 1].target;

        next(node);

        while(node != INVALID && (*_nodes)[node].first_out == -1) {

          next(node);

        }

        arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;

      }

    }

    void first(Edge& edge) const {

      Node node;

      first(node);

      while (node != INVALID) {

        edge.id = (*_nodes)[node].first_out;

        while ((edge.id & 1) != 1) {

          edge.id = arcs[edge.id].next_out;

        }

        if (edge.id != -1) {

          edge.id /= 2;

          return;

        }

        next(node);

      }

      edge.id = -1;

    }

    void next(Edge& edge) const {

      Node node = arcs[edge.id * 2].target;

      edge.id = arcs[(edge.id * 2) | 1].next_out;

      while ((edge.id & 1) != 1) {

        edge.id = arcs[edge.id].next_out;

      }

      if (edge.id != -1) {

        edge.id /= 2;

        return;

      }

      next(node);

      while (node != INVALID) {

        edge.id = (*_nodes)[node].first_out;

        while ((edge.id & 1) != 1) {

          edge.id = arcs[edge.id].next_out;

        }

        if (edge.id != -1) {

          edge.id /= 2;

          return;

        }

        next(node);

      }

      edge.id = -1;

    }

    void firstOut(Arc& arc, const Node& node) const {

      arc.id = (*_nodes)[node].first_out;

    }

    void nextOut(Arc& arc) const {

      arc.id = arcs[arc.id].next_out;

    }

    void firstIn(Arc& arc, const Node& node) const {

      arc.id = (((*_nodes)[node].first_out) ^ 1);

      if (arc.id == -2) arc.id = -1;

    }

    void nextIn(Arc& arc) const {

      arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);

      if (arc.id == -2) arc.id = -1;

    }

    void firstInc(Edge &arc, bool& dir, const Node& node) const {

      int de = (*_nodes)[node].first_out;

      if (de != -1 ) {

        arc.id = de / 2;

        dir = ((de & 1) == 1);

      } else {

        arc.id = -1;

        dir = true;

      }

    }

    void nextInc(Edge &arc, bool& dir) const {

      int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);

      if (de != -1 ) {

        arc.id = de / 2;

        dir = ((de & 1) == 1);

      } else {

        arc.id = -1;

        dir = true;

      }

    }

    static bool direction(Arc arc) {

      return (arc.id & 1) == 1;

    }

    static Arc direct(Edge edge, bool dir) {

      return Arc(edge.id * 2 + (dir ? 1 : 0));

    }

    int id(const Node& node) const { return _graph->id(node); }

    static int id(Arc e) { return e.id; }

    static int id(Edge e) { return e.id; }

    Node nodeFromId(int id) const { return _graph->nodeFromId(id); }

    static Arc arcFromId(int id) { return Arc(id);}

    static Edge edgeFromId(int id) { return Edge(id);}

    int maxNodeId() const { return _graph->maxNodeId(); };

    int maxEdgeId() const { return arcs.size() / 2 - 1; }

    int maxArcId() const { return arcs.size()-1; }

    Node source(Arc e) const { return arcs[e.id ^ 1].target; }

    Node target(Arc e) const { return arcs[e.id].target; }

    Node u(Edge e) const { return arcs[2 * e.id].target; }

    Node v(Edge e) const { return arcs[2 * e.id + 1].target; }

    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;

    NodeNotifier& notifier(Node) const {

      return _graph->notifier(Node());

    }

    template <typename V>

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

      typedef typename GR::template NodeMap<V> Parent;

    public:

      explicit NodeMap(const ListEdgeSetBase<GR>& arcset)

        : Parent(*arcset._graph) {}

      NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value)

        : Parent(*arcset._graph, value) {}

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

  };

  /// \ingroup graphs

  ///

  /// \brief Graph using a node set of another digraph or graph and an

  /// own edge set.

  ///

  /// This structure can be used to establish another graph over a

  /// node set of an existing one. This class uses the same Node type

  /// as the underlying graph, and each valid node of the original

  /// graph is valid in this arc set, therefore the node objects of

  /// the original graph can be used directly with this class. The

  /// node handling functions (id handling, observing, and iterators)

  /// works equivalently as in the original graph.

  ///

  /// This implementation is based on doubly-linked lists, from each

  /// node the incident edges make up lists, therefore one edge can be

  /// erased in constant time. It also makes possible, that node can

  /// be removed from the underlying graph, in this case all edges

  /// incident to the given node is erased from the arc set.

  ///

  /// This class fully conforms to the \ref concepts::Graph "Graph"

  /// concept.

  /// It provides only linear time counting for nodes, edges and arcs.

  ///

  /// \param GR The type of the graph which shares its node set

  /// with this class. Its interface must conform to the

  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"

  /// concept.

  template <typename GR>

  class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<GR> > {

    typedef EdgeSetExtender<ListEdgeSetBase<GR> > Parent;

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

    typedef typename Parent::Edge Edge;

    typedef typename Parent::NodesImplBase NodesImplBase;

    void eraseNode(const Node& node) {

      Arc arc;

      Parent::firstOut(arc, node);

      while (arc != INVALID ) {

        erase(arc);

        Parent::firstOut(arc, node);

      }

    }

    void clearNodes() {

      Parent::clear();

    }

    class NodesImpl : public NodesImplBase {

      typedef NodesImplBase Parent;

    public:

      NodesImpl(const GR& graph, ListEdgeSet& arcset)

        : Parent(graph), _arcset(arcset) {}

      virtual ~NodesImpl() {}

    protected:

      virtual void erase(const Node& node) {

        _arcset.eraseNode(node);

        Parent::erase(node);

      }

      virtual void erase(const std::vector<Node>& nodes) {

        for (int i = 0; i < int(nodes.size()); ++i) {

          _arcset.eraseNode(nodes[i]);

        }

        Parent::erase(nodes);

      }

      virtual void clear() {

        _arcset.clearNodes();

        Parent::clear();

      }

    private:

      ListEdgeSet& _arcset;

    };

    NodesImpl _nodes;

  public:

    /// \brief Constructor of the EdgeSet.

    ///

    /// Constructor of the EdgeSet.

    ListEdgeSet(const GR& graph) : _nodes(graph, *this) {

      Parent::initalize(graph, _nodes);

    }

    /// \brief Add a new edge to the graph.

    ///

    /// Add a new edge to the graph with node \c u

    /// and node \c v endpoints.

    /// \return The new edge.

    Edge addEdge(const Node& u, const Node& v) {

      return Parent::addEdge(u, v);

    }

    /// \brief Erase an edge from the graph.

    ///

    /// Erase the edge \c e from the graph.

    void erase(const Edge& e) {

      return Parent::erase(e);

    }

  };

  template <typename GR>

  class SmartArcSetBase {

  public:

    typedef typename GR::Node Node;

    typedef typename GR::NodeIt NodeIt;

  protected:

    struct NodeT {

      int first_out, first_in;

      NodeT() : first_out(-1), first_in(-1) {}

    };

    typedef typename ItemSetTraits<GR, Node>::

    template Map<NodeT>::Type NodesImplBase;

    NodesImplBase* _nodes;

    struct ArcT {

      Node source, target;

      int next_out, next_in;

      ArcT() {}

    };

    std::vector<ArcT> arcs;

    const GR* _graph;

    void initalize(const GR& graph, NodesImplBase& nodes) {

      _graph = &graph;

      _nodes = &nodes;

    }

  public:

    class Arc {

      friend class SmartArcSetBase<GR>;

    protected:

      Arc(int _id) : id(_id) {}

      int id;

    public:

      Arc() {}

      Arc(Invalid) : id(-1) {}

      bool operator==(const Arc& arc) const { return id == arc.id; }

      bool operator!=(const Arc& arc) const { return id != arc.id; }

      bool operator<(const Arc& arc) const { return id < arc.id; }

    };

    SmartArcSetBase() {}

    Node addNode() {

      LEMON_ASSERT(false,

        "This graph structure does not support node insertion");

      return INVALID; // avoid warning

    }

    Arc addArc(const Node& u, const Node& v) {

      int n = arcs.size();

      arcs.push_back(ArcT());

      arcs[n].next_in = (*_nodes)[v].first_in;

      (*_nodes)[v].first_in = n;

      arcs[n].next_out = (*_nodes)[u].first_out;

      (*_nodes)[u].first_out = n;

      arcs[n].source = u;

      arcs[n].target = v;

      return Arc(n);

    }

    void clear() {

      Node node;

      for (first(node); node != INVALID; next(node)) {

        (*_nodes)[node].first_in = -1;

        (*_nodes)[node].first_out = -1;

      }

      arcs.clear();

    }

    void first(Node& node) const {

      _graph->first(node);

    }

    void next(Node& node) const {

      _graph->next(node);

    }

    void first(Arc& arc) const {

      arc.id = arcs.size() - 1;

    }

    static void next(Arc& arc) {

      --arc.id;

    }

    void firstOut(Arc& arc, const Node& node) const {

      arc.id = (*_nodes)[node].first_out;

    }

    void nextOut(Arc& arc) const {

      arc.id = arcs[arc.id].next_out;

    }

    void firstIn(Arc& arc, const Node& node) const {

      arc.id = (*_nodes)[node].first_in;

    }

    void nextIn(Arc& arc) const {

      arc.id = arcs[arc.id].next_in;

    }

    int id(const Node& node) const { return _graph->id(node); }

    int id(const Arc& arc) const { return arc.id; }

    Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }

    Arc arcFromId(int ix) const { return Arc(ix); }

    int maxNodeId() const { return _graph->maxNodeId(); };

    int maxArcId() const { return arcs.size() - 1; }

    Node source(const Arc& arc) const { return arcs[arc.id].source;}

    Node target(const Arc& arc) const { return arcs[arc.id].target;}

    typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;

    NodeNotifier& notifier(Node) const {

      return _graph->notifier(Node());

    }

    template <typename V>

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

      typedef typename GR::template NodeMap<V> Parent;

    public:

      explicit NodeMap(const SmartArcSetBase<GR>& arcset)

        : Parent(*arcset._graph) { }

      NodeMap(const SmartArcSetBase<GR>& arcset, const V& value)

        : Parent(*arcset._graph, value) { }

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

  };

  /// \ingroup graphs

  ///

  /// \brief Digraph using a node set of another digraph or graph and

  /// an own arc set.

  ///

  /// This structure can be used to establish another directed graph

  /// over a node set of an existing one. This class uses the same

  /// Node type as the underlying graph, and each valid node of the

  /// original graph is valid in this arc set, therefore the node

  /// objects of the original graph can be used directly with this

  /// class. The node handling functions (id handling, observing, and

  /// iterators) works equivalently as in the original graph.

  ///

  /// \param GR The type of the graph which shares its node set with

  /// this class. Its interface must conform to the

  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"

  /// concept.

  ///

  /// This implementation is slightly faster than the \c ListArcSet,

  /// because it uses continuous storage for arcs and it uses just

  /// single-linked lists for enumerate outgoing and incoming

  /// arcs. Therefore the arcs cannot be erased from the arc sets.

  ///

  /// This class fully conforms to the \ref concepts::Digraph "Digraph"

  /// concept.

  /// It provides only linear time counting for nodes and arcs.

  ///

  /// \warning If a node is erased from the underlying graph and this

  /// node is the source or target of one arc in the arc set, then

  /// the arc set is invalidated, and it cannot be used anymore. The

  /// validity can be checked with the \c valid() member function.

  template <typename GR>

  class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {

    typedef ArcSetExtender<SmartArcSetBase<GR> > Parent;

  public:

    typedef typename Parent::Node Node;

    typedef typename Parent::Arc Arc;

  protected:

    typedef typename Parent::NodesImplBase NodesImplBase;

    void eraseNode(const Node& node) {

      if (typename Parent::InArcIt(*this, node) == INVALID &&

          typename Parent::OutArcIt(*this, node) == INVALID) {

        return;

      }

      throw typename NodesImplBase::Notifier::ImmediateDetach();

    }

    void clearNodes() {

      Parent::clear();

    }

    class NodesImpl : public NodesImplBase {

      typedef NodesImplBase Parent;