RhodeCode

        return b;

      }

    };//class Boundingbox

  ///\ingroup maps

  ///

  template<class M>

  class XMap 

  {

    M& _map;

  public:

  template<class M> 

  inline XMap<M> xMap(const M &m) 

  {

    return XMap<M>(m);

  }

  ///\ingroup maps

  ///Constant (read only) version of \ref XMap

  ///

  template<class M>

  class ConstXMap 

  template<class M> 

  inline ConstXMap<M> xMap(const M &m) 

  {

    return ConstXMap<M>(m);

  }

  ///\ingroup maps

  ///Map of y-coordinates of a \ref Point "Point"-map.

  ///

  template<class M>

  class YMap 

  template<class M> 

  inline YMap<M> yMap(const M &m) 

  {

    return YMap<M>(m);

  }

  ///\ingroup maps

  ///Constant (read only) version of \ref YMap

  ///

  template<class M>

  class ConstYMap 

  inline ConstYMap<M> yMap(const M &m) 

  {

    return ConstYMap<M>(m);

  }

    ///

    ///Map of the \ref Point::normSquare() "normSquare()"

    ///of a \ref Point "Point"-map.

    ///\ingroup maps

    ///

  template<class M>

  class StdMap {

    template <typename K1, typename T1, typename C1>

    friend class StdMap;

  public:

    typedef True ReferenceMapTag;

    typedef K Key;

    typedef T Value;

    typedef T& Reference;

    typedef const T& ConstReference;

  private:

    typedef std::map<K, T, Compare> Map;

    Value _value;

  ///

  ///Tolerance is a class to provide a basic way to

  ///handle the comparison of numbers that are obtained

  ///as a result of a probably inexact computation.

  ///

  ///This is an abstract class, it should be specialized for all numerical

  ///may offer additional tuning parameters.

  ///

  ///\sa Tolerance<float>

  ///\sa Tolerance<double>

  ///\sa Tolerance<long double>

  ///\sa Tolerance<int>

    //   static bool finite(Value a) {}

    //   static Value big() {}

    //   static Value negativeBig() {}

  };

  ///\sa Tolerance

  ///\relates Tolerance

  template<>

  class Tolerance<float>

  {

    static float def_epsilon;

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///\sa Tolerance

  ///\relates Tolerance

  template<>

  class Tolerance<double>

  {

    static double def_epsilon;

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///\sa Tolerance

  ///\relates Tolerance

  template<>

  class Tolerance<long double>

  {

    static long double def_epsilon;

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///\sa Tolerance

  template<>

  class Tolerance<int>

  {

  public:

    ///\e

    typedef int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned integer specialization of \ref Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned int>

  {

  public:

    ///\e

    typedef unsigned int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///\sa Tolerance

  template<>

  class Tolerance<long int>

  {

  public:

    ///\e

    typedef long int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned long integer specialization of \ref Tolerance.

  ///\sa Tolerance

  template<>

  class Tolerance<unsigned long int>

  {

  public:

    ///\e

    typedef unsigned long int Value;

    ///\name Comparisons

    ///@{

    ///Returns \c true if \c a is \e surely strictly less than \c b

    static bool less(Value a,Value b) { return a<b;}

    ///Returns \c true if \c a is \e surely different from \c b

    ///Returns zero

    static Value zero() {return 0;}

  };

#if defined __GNUC__ && !defined __STRICT_ANSI__

  ///Long long integer specialization of \ref Tolerance.

  ///\warning This class (more exactly, type <tt>long long</tt>)

  ///is not ansi compatible.

  ///\sa Tolerance

  template<>

    ///@}

    ///Returns zero

    static Value zero() {return 0;}

  };

  ///Unsigned long long integer specialization of \ref Tolerance.

  ///\warning This class (more exactly, type <tt>unsigned long long</tt>)

  ///is not ansi compatible.

  ///\sa Tolerance

  template<>