RhodeCode

    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;

    }