RhodeCode

    Node runningNode(const InArcIt &e) const {

      return Parent::source(static_cast<const Arc&>(e));

    }

    // Base node of the iterator

    //

    // Returns the base node of the iterator

    Node baseNode(const IncEdgeIt &e) const {

      return e.direction ? u(e) : v(e);

    }

    // Running node of the iterator

    //

    // Returns the running node of the iterator

    Node runningNode(const IncEdgeIt &e) const {

      return e.direction ? v(e) : u(e);

    }

    template <typename _Value>

    class ArcMap 

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

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

    public:

	: Parent(_g) {}

      ArcMap(const Graph& _g, const _Value& _v) 

	: Parent(_g, _v) {}

      ArcMap& operator=(const ArcMap& cmap) {

	return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

	return *this;

      }

    };

    template <typename _Value>

    class EdgeMap 

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

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

    public:

	: Parent(_g) {}

      EdgeMap(const Graph& _g, const _Value& _v) 

	: Parent(_g, _v) {}

      EdgeMap& operator=(const EdgeMap& cmap) {

	return operator=<EdgeMap>(cmap);

      }

      template <typename CMap>

      EdgeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

	return *this;

      }

    };

    // Alteration extension

    Edge addEdge(const Node& from, const Node& to) {

      Edge edge = Parent::addEdge(from, to);

      notifier(Edge()).add(edge);

      std::vector<Arc> arcs;

      return Parent::source(static_cast<const Arc&>(arc));

    }

    // Base node of the iterator

    //

    // Returns the base node of the iterator

    Node baseNode(const IncEdgeIt &edge) const {

      return edge._direction ? u(edge) : v(edge);

    }

    // Running node of the iterator

    //

    // Returns the running node of the iterator

    Node runningNode(const IncEdgeIt &edge) const {

      return edge._direction ? v(edge) : u(edge);

    }

    // Mappable extension

    template <typename _Value>

    class NodeMap

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

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

    public:

        : Parent(graph) {}

      NodeMap(const Graph& graph, const _Value& value)

        : Parent(graph, value) {}

    private:

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename _Value>

    class ArcMap

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

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

    public:

        : Parent(graph) {}

      ArcMap(const Graph& graph, const _Value& value)

        : Parent(graph, value) {}

    private:

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename _Value>

    class EdgeMap

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

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

    public:

        : Parent(graph) {}

      EdgeMap(const Graph& graph, const _Value& value)

        : Parent(graph, value) {}

    private:

      EdgeMap& operator=(const EdgeMap& cmap) {

        return operator=<EdgeMap>(cmap);

      }

      template <typename CMap>

      EdgeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    // Alteration extension

    Node addNode() {

      Node node = Parent::addNode();

      notifier(Node()).add(node);

      return node;