RhodeCode

    static const bool value = false;

  };

  template <typename Graph>

  struct NodeNumTagIndicator<

    Graph,

    typename enable_if<typename Graph::NodeNumTag, void>::type

  > {

    static const bool value = true;

  };

  template <typename Graph, typename Enable = void>

  struct EdgeNumTagIndicator {

    static const bool value = false;

  };

  template <typename Graph>

  struct EdgeNumTagIndicator<

    Graph,

    typename enable_if<typename Graph::EdgeNumTag, void>::type

  > {

    static const bool value = true;

  };

  template <typename Graph, typename Enable = void>

  struct FindEdgeTagIndicator {

    static const bool value = false;

  };

  template <typename Graph>

  struct FindEdgeTagIndicator<

    Graph,

    typename enable_if<typename Graph::FindEdgeTag, void>::type

  > {

    static const bool value = true;

  };

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

      if (s._id < t._id) {

        return Arc((_eid(s._id, t._id) << 1) | 1);

      } else if (s._id != t._id) {

        return Arc(_eid(t._id, s._id) << 1);

      } else {

        return INVALID;

      }

    }

    typedef True NodeNumTag;

    typedef True EdgeNumTag;

    int nodeNum() const { return _node_num; }

    int arcNum() const { return 2 * _edge_num; }

    int edgeNum() const { return _edge_num; }

    static int id(Node node) { return node._id; }

    static int id(Arc arc) { return arc._id; }

    static int id(Edge edge) { return edge._id; }

    int maxNodeId() const { return _node_num-1; }

    int maxArcId() const { return 2 * _edge_num-1; }

    Node source(Arc arc) const {

      return Node((arc._id & 1) == 1 ?

                  _uid(arc._id >> 1) : _vid(arc._id >> 1));

    }

    Node target(Arc arc) const {

      return Node((arc._id & 1) == 1 ?

                  _vid(arc._id >> 1) : _uid(arc._id >> 1));

    }

    typedef True FindEdgeTag;

    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {

      return prev != INVALID ? INVALID : edge(u, v);

    }

    Arc findArc(Node s, Node t, Arc prev = INVALID) const {

      return prev != INVALID ? INVALID : arc(s, t);

    }

    class Node {

      friend class FullGraphBase;

      return dim2::Point<int>(col(n), row(n));

    }

    int width() const {

      return _width;

    }

    int height() const {

      return _height;

    }

    typedef True NodeNumTag;

    typedef True ArcNumTag;

    int nodeNum() const { return _node_num; }

    int edgeNum() const { return _edge_num; }

    int arcNum() const { return 2 * _edge_num; }

    Node u(Edge edge) const {

      if (edge._id < _edge_limit) {

        return edge._id;

      } else {

        return (edge._id - _edge_limit) % (_width - 1) +

          (edge._id - _edge_limit) / (_width - 1) * _width;

    static int id(Edge edge) { return edge._id; }

    static int id(Arc arc) { return arc._id; }

    int maxNodeId() const { return _node_num - 1; }

    int maxEdgeId() const { return _edge_num - 1; }

    int maxArcId() const { return 2 * _edge_num - 1; }

    static Node nodeFromId(int id) { return Node(id);}

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

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

    typedef True FindEdgeTag;

    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {

      if (prev != INVALID) return INVALID;

      if (v._id > u._id) {

        if (v._id - u._id == _width)

          return Edge(u._id);

        if (v._id - u._id == 1 && u._id % _width < _width - 1) {

          return Edge(u._id / _width * (_width - 1) +

                      u._id % _width + _edge_limit);

        }

      } else {

        if (u._id - v._id == _width)

    typedef SmartDigraphBase Graph;

    class Node;

    class Arc;

  public:

    SmartDigraphBase() : nodes(), arcs() { }

    SmartDigraphBase(const SmartDigraphBase &_g)

      : nodes(_g.nodes), arcs(_g.arcs) { }

    typedef True NodeNumTag;

    int nodeNum() const { return nodes.size(); }

    int arcNum() const { return arcs.size(); }

    int maxNodeId() const { return nodes.size()-1; }

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

    Node addNode() {

      int n = nodes.size();

      nodes.push_back(NodeT());

      nodes[n].first_in = -1;

      nodes[n].first_out = -1;