RhodeCode

 };

  template <typename MatrixMap, typename Enable = void>

  struct MatrixMapTraits {

    typedef False ReferenceMapTag;

    typedef typename MatrixMap::FirstKey FirstKey;

    typedef typename MatrixMap::SecondKey SecondKey;

    typedef typename MatrixMap::Value Value;

    typedef Value ConstReturnValue;

    typedef Value ReturnValue;

  };

  template <typename MatrixMap>

  struct MatrixMapTraits<

    MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag,

                                  void>::type >

  {

    typedef True ReferenceMapTag;

    typedef typename MatrixMap::FirstKey FirstKey;

    typedef typename MatrixMap::SecondKey SecondKey;

    typedef typename MatrixMap::Value Value;

    typedef typename MatrixMap::ConstReference ConstReturnValue;

    typedef typename MatrixMap::Reference ReturnValue;

    typedef typename MatrixMap::ConstReference ConstReference;

    typedef typename MatrixMap::Reference Reference;

 };

  // Indicators for the tags

  template <typename Graph, typename Enable = void>

  struct NodeNumTagIndicator {

    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;

  };

  template <typename Graph, typename Enable = void>

  struct UndirectedTagIndicator {

    static const bool value = false;

  };

  template <typename Graph>

  struct UndirectedTagIndicator<

    Graph,

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

  > {

    static const bool value = true;

  };

  template <typename Graph, typename Enable = void>

  struct BuildTagIndicator {

    static const bool value = false;

  };

  template <typename Graph>

  struct BuildTagIndicator<

    Graph,

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

  > {

    static const bool value = true;

  };

}

#endif

      if  (u >= v) {

        u = _node_num - 2 - u;

        v = _node_num - 1 - v;

      }

    }

    void _stid(int a, int& s, int& t) const {

      if ((a & 1) == 1) {

        _uvid(a >> 1, s, t);

      } else {

        _uvid(a >> 1, t, s);

      }

    }

    int _eid(int u, int v) const {

      if (u < (_node_num - 1) / 2) {

        return u * _node_num + v;

      } else {

        return (_node_num - 1 - u) * _node_num - v - 1;

      }

    }

  public:

    Node operator()(int ix) const { return Node(ix); }

    int index(const Node& node) const { return node._id; }

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

      if (u._id < v._id) {

        return Edge(_eid(u._id, v._id));

      } else if (u._id != v._id) {

        return Edge(_eid(v._id, u._id));

      } else {

        return INVALID;

      }

    }

    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; }

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

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

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

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

    Node u(Edge edge) const {

      return Node(_uid(edge._id));

    }

    Node v(Edge edge) const {

      return Node(_vid(edge._id));

    }

    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;

    protected:

      int _id;

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

    public:

      Node() {}

      Node (Invalid) { _id = -1; }

      bool operator==(const Node node) const {return _id == node._id;}

      bool operator!=(const Node node) const {return _id != node._id;}

      bool operator<(const Node node) const {return _id < node._id;}

    };

    class Edge {

      friend class FullGraphBase;

      friend class Arc;

    protected:

      int _id;

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

    public:

      Edge() { }

      Edge (Invalid) { _id = -1; }

      bool operator==(const Edge edge) const {return _id == edge._id;}

      bool operator!=(const Edge edge) const {return _id != edge._id;}

      bool operator<(const Edge edge) const {return _id < edge._id;}

    };

    class Arc {

      friend class FullGraphBase;

    protected:

      int _id;

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

    typedef GridGraphBase Graph;

    class Node;

    class Edge;

    class Arc;

  public:

    GridGraphBase() {}

  protected:

    void construct(int width, int height) {

       _width = width; _height = height;

      _node_num = width * height;

      _edge_num = 2 * _node_num - width - height;

      _edge_limit = _node_num - _width;

    }

  public:

    Node operator()(int i, int j) const {

      LEMON_DEBUG(0 <= i && i < _width &&

                  0 <= j  && j < _height, "Index out of range");

      return Node(i + j * _width);

    }

    int col(Node n) const {

      return n._id % _width;

    }

    int row(Node n) const {

      return n._id / _width;

    }

    dim2::Point<int> pos(Node n) const {

      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;

      }

    }

    Node v(Edge edge) const {

      if (edge._id < _edge_limit) {

        return edge._id + _width;

      } else {

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

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

      }

    }

    Node source(Arc arc) const {

      return (arc._id & 1) == 1 ? u(arc) : v(arc);

    }

    Node target(Arc arc) const {

      return (arc._id & 1) == 1 ? v(arc) : u(arc);

    }

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

    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)

          return Edge(v._id);

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

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

                      v._id % _width + _edge_limit);

        }

      }

      return INVALID;

    }

    Arc findArc(Node u, Node v, Arc prev = INVALID) const {

      if (prev != INVALID) return INVALID;

      if (v._id > u._id) {

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

          return Arc((u._id << 1) | 1);

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

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

                       u._id % _width + _edge_limit) << 1) | 1);

        }

      } else {

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

          return Arc(v._id << 1);

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

          return Arc((v._id / _width * (_width - 1) +

                       v._id % _width + _edge_limit) << 1);

        }

      }

      return INVALID;

    }

    class Node {

      friend class GridGraphBase;

    protected:

      int _id;

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

    public:

///\ingroup graphs

///\file

///\brief SmartDigraph and SmartGraph classes.

#include <vector>

#include <lemon/core.h>

#include <lemon/error.h>

#include <lemon/bits/graph_extender.h>

namespace lemon {

  class SmartDigraph;

  ///Base of SmartDigraph

  ///Base of SmartDigraph

  ///

  class SmartDigraphBase {

  protected:

    struct NodeT

    {

      int first_in, first_out;

      NodeT() {}

    };

    struct ArcT

    {

      int target, source, next_in, next_out;

      ArcT() {}

    };

    std::vector<NodeT> nodes;

    std::vector<ArcT> arcs;

  public:

    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;

      return Node(n);

    }

    Arc addArc(Node u, Node v) {

      int n = arcs.size();

      arcs.push_back(ArcT());

      arcs[n].source = u._id;

      arcs[n].target = v._id;

      arcs[n].next_out = nodes[u._id].first_out;

      arcs[n].next_in = nodes[v._id].first_in;

      nodes[u._id].first_out = nodes[v._id].first_in = n;

      return Arc(n);

    }

    void clear() {

      arcs.clear();

      nodes.clear();

    }

    Node source(Arc a) const { return Node(arcs[a._id].source); }

    Node target(Arc a) const { return Node(arcs[a._id].target); }

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

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

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

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

    bool valid(Node n) const {

      return n._id >= 0 && n._id < static_cast<int>(nodes.size());

    }

    bool valid(Arc a) const {

      return a._id >= 0 && a._id < static_cast<int>(arcs.size());

    }