RhodeCode

  /// This interface of the BFS algorithm should be used in special cases

  /// when extra actions have to be performed in connection with certain

  /// events of the BFS algorithm. Otherwise consider to use Bfs or bfs()

  /// instead.

  ///

      // Invalid arc constructor

    /// First node of the edge

    Node u(const Edge &e) const {

      return Parent::source(e);

    }

    /// Source of the given arc

    /// Second node of the edge

    Node v(const Edge &e) const {

      return Parent::target(e);

    }

    /// Target of the given arc

    /// Returns a directed arc corresponding to the specified edge.

    /// If the given bool is true, the first node of the given edge and

    /// the source node of the returned arc are the same.

    static Arc direct(const Edge &e, bool d) {

      return Arc(e, d);

    /// Returns whether the given directed arc has the same orientation

    /// as the corresponding edge.

    static bool direction(const Arc &a) { return a.forward; }

  /// This interface of the DFS algorithm should be used in special cases

  /// when extra actions have to be performed in connection with certain

  /// events of the DFS algorithm. Otherwise consider to use Dfs or dfs()

  /// instead.

  ///

    //Pointer to the map of processed nodes.

    void *_processed;

    DijkstraWizardBase() : _g(0), _length(0), _processed(0), _pred(0),

      _processed(0), _pred(0), _dist(0), _source(s) {}

      if(Base::_processed)

        dij.processedMap(*reinterpret_cast<ProcessedMap*>(Base::_processed));

      if(Base::_pred)

        dij.predMap(*reinterpret_cast<PredMap*>(Base::_pred));

      if(Base::_dist)

        dij.distMap(*reinterpret_cast<DistMap*>(Base::_dist));

/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine

  /// Two dimensional vector (plain vector)

    os << "(" << z.x << "," << z.y << ")";

  /// Bounding box of plain vectors (\ref Point points).

  /// A class to calculate or store the bounding box of plain vectors

  /// (\ref Point points).

  template<typename T>

  class Box {

      ///Default constructor: creates an empty box

      Box() { _empty = true; }

      ///Construct a box from one point

      Box(Point<T> a) {

      ///Construct a box from two points

      ///Construct a box from two points.

      Box(Point<T> a,Point<T> b)

      ///Construct a box from four numbers

      ///Construct a box from four numbers.

      Box(T l,T b,T r,T t)

      ///Return \c true if the box is empty.

      ///Return \c true if the box is empty (i.e. return \c false

      ///The coordinates of an empty box are not defined.

      ///Make the box empty

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///If the box is empty, then the return value is not defined.

      ///Checks whether a point is inside the box

      ///Increments the box with a point

      ///Increments the box with a point.

      Box& add(const Point<T>& u){

      ///Increments the box to contain another box

      ///Increments the box to contain another box.

      Box& add(const Box &u){

      ///Intersection of two boxes

      ///Intersection of two boxes.

      Box operator&(const Box& u) const {

        Box b;

  };//class Box

  ///Read a box from a stream

  ///Read a box from a stream.

  ///\relates Box

  template<typename T>

  inline std::istream& operator>>(std::istream &is, Box<T>& b) {

    char c;

    Point<T> p;

    if (is >> c) {

      if (c != '(') is.putback(c);

    } else {

      is.clear();

    }

    if (!(is >> p)) return is;

    b.bottomLeft(p);

    if (is >> c) {

      if (c != ',') is.putback(c);

    } else {

      is.clear();

    }

    if (!(is >> p)) return is;

    b.topRight(p);

    if (is >> c) {

      if (c != ')') is.putback(c);

    } else {

      is.clear();

    }

    return is;

  }

  ///Write a box to a stream

  ///Write a box to a stream.

  ///\relates Box

  template<typename T>

  inline std::ostream& operator<<(std::ostream &os, const Box<T>& b)

  {

    os << "(" << b.bottomLeft() << "," << b.topRight() << ")";

    return os;

  }

      dim2::Box<double> bb;

        bb = dim2::Box<double>(dim2::Point<double>(0,0));

    dim2::Box<double> bb;

      bb = dim2::Box<double>(dim2::Point<double>(0,0));

  typedef dim2::Box<int> Box;

  Box box1;

  check(box1.empty(), "Wrong empty() in dim2::Box.");

  check(!box1.empty(), "Wrong empty() in dim2::Box.");

        "Wrong addition of points to dim2::Box.");

  check(box1.inside(Point(2,3)), "Wrong inside() in dim2::Box.");

  check(box1.inside(Point(1,3)), "Wrong inside() in dim2::Box.");

  check(!box1.inside(Point(0,3)), "Wrong inside() in dim2::Box.");

  Box box2(Point(2,2));

  check(!box2.empty(), "Wrong empty() in dim2::Box.");

  Box box3 = box1 & box2;

        box3.left()==2 && box3.bottom()==2 &&

        "Wrong intersection of two dim2::Box objects.");

        "Wrong addition of two dim2::Box objects.");