RhodeCode

        if (Parent::direction(e)) {

          _forward->set(e, a);

        } else {

          _backward->set(e, a);

        }

      }

      /// \brief Returns the value associated with a key.

      ///

      /// Returns the value associated with a key.

      typename MapTraits<ForwardMap>::ConstReturnValue

      operator[](const Key& e) const {

        if (Parent::direction(e)) {

          return (*_forward)[e];

        } else {

          return (*_backward)[e];

        }

      }

      /// \brief Returns the value associated with a key.

      ///

      /// Returns the value associated with a key.

      typename MapTraits<ForwardMap>::ReturnValue

      operator[](const Key& e) {

        if (Parent::direction(e)) {

          return (*_forward)[e];

        } else {

          return (*_backward)[e];

        }

      }

    protected:

      ForwardMap* _forward;

      BackwardMap* _backward;

    };

    /// \brief Just gives back a combined arc map

    ///

    /// Just gives back a combined arc map

    template <typename ForwardMap, typename BackwardMap>

    static CombinedArcMap<ForwardMap, BackwardMap>

    combinedArcMap(ForwardMap& forward, BackwardMap& backward) {

      return CombinedArcMap<ForwardMap, BackwardMap>(forward, backward);

    }

    template <typename ForwardMap, typename BackwardMap>

    static CombinedArcMap<const ForwardMap, BackwardMap>

    combinedArcMap(const ForwardMap& forward, BackwardMap& backward) {

      return CombinedArcMap<const ForwardMap,

        BackwardMap>(forward, backward);

    }

    template <typename ForwardMap, typename BackwardMap>

    static CombinedArcMap<ForwardMap, const BackwardMap>

    combinedArcMap(ForwardMap& forward, const BackwardMap& backward) {

      return CombinedArcMap<ForwardMap,

        const BackwardMap>(forward, backward);

    }

    template <typename ForwardMap, typename BackwardMap>

    static CombinedArcMap<const ForwardMap, const BackwardMap>

    combinedArcMap(const ForwardMap& forward, const BackwardMap& backward) {

      return CombinedArcMap<const ForwardMap,

        const BackwardMap>(forward, backward);

    }

  };

  /// \brief Just gives back an undirected view of the given digraph

  ///

  /// Just gives back an undirected view of the given digraph

  template<typename Digraph>

  Undirector<const Digraph>

  undirector(const Digraph& digraph) {

    return Undirector<const Digraph>(digraph);

  }

  template <typename _Graph, typename _DirectionMap>

  class OrienterBase {

  public:

    typedef _Graph Graph;

    typedef _DirectionMap DirectionMap;

    typedef typename Graph::Node Node;

    typedef typename Graph::Edge Arc;

    void reverseArc(const Arc& arc) {

      _direction->set(arc, !(*_direction)[arc]);

    }

    void first(Node& i) const { _graph->first(i); }

    void first(Arc& i) const { _graph->first(i); }

    void firstIn(Arc& i, const Node& n) const {

      _graph->firstInc(i, d, n);

      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);

    }

    void firstOut(Arc& i, const Node& n ) const {

      _graph->firstInc(i, d, n);

      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);

    }

    void next(Node& i) const { _graph->next(i); }

    void next(Arc& i) const { _graph->next(i); }

    void nextIn(Arc& i) const {

      bool d = !(*_direction)[i];

      _graph->nextInc(i, d);

      while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);

    }

    void nextOut(Arc& i) const {

      bool d = (*_direction)[i];

      _graph->nextInc(i, d);

      while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);

    }

    Node source(const Arc& e) const {

      return (*_direction)[e] ? _graph->u(e) : _graph->v(e);

    }

    Node target(const Arc& e) const {

      return (*_direction)[e] ? _graph->v(e) : _graph->u(e);

    }

    typedef NodeNumTagIndicator<Graph> NodeNumTag;

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

    typedef EdgeNumTagIndicator<Graph> ArcNumTag;

    int arcNum() const { return _graph->edgeNum(); }

    typedef FindEdgeTagIndicator<Graph> FindArcTag;

    Arc findArc(const Node& u, const Node& v,

                const Arc& prev = INVALID) {

      Arc arc = prev;

      bool d = arc == INVALID ? true : (*_direction)[arc];

      if (d) {

        arc = _graph->findEdge(u, v, arc);

        while (arc != INVALID && !(*_direction)[arc]) {

          _graph->findEdge(u, v, arc);

        }

        if (arc != INVALID) return arc;

      }

      _graph->findEdge(v, u, arc);

      while (arc != INVALID && (*_direction)[arc]) {

        _graph->findEdge(u, v, arc);

      }

      return arc;

    }

    Node addNode() {

      return Node(_graph->addNode());

    }

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

      Arc arc = _graph->addArc(u, v);

      _direction->set(arc, _graph->source(arc) == u);

      return arc;

    }

    void erase(const Node& i) { _graph->erase(i); }

    void erase(const Arc& i) { _graph->erase(i); }

    void clear() { _graph->clear(); }

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

    int id(const Arc& e) const { return _graph->id(e); }

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

    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;

    NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); }

    typedef typename ItemSetTraits<Graph, Arc>::ItemNotifier ArcNotifier;

    ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); }

    template <typename _Value>

    class NodeMap : public _Graph::template NodeMap<_Value> {

    public:

      typedef typename _Graph::template NodeMap<_Value> Parent;

      explicit NodeMap(const OrienterBase& adapter)

        : Parent(*adapter._graph) {}

      NodeMap(const OrienterBase& adapter, const _Value& value)

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

    private:

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }