Distance.hpp

Go to the documentation of this file.

#ifndef GL_DISTANCE_HPP
#define GL_DISTANCE_HPP

#include <string>

namespace gl 
{
template <class SCALAR>
struct Distance
{
  Distance () : isInfinite_(true), distance_(0) {}     
  Distance (const SCALAR distance) : isInfinite_(false), distance_(distance) {}                                        
  Distance(const Distance &) = default;                
  Distance(Distance &&) noexcept = default;            
  Distance &operator=(const Distance &) = default;     
  Distance &operator=(Distance &&) noexcept = default; 
  ~Distance() = default;                               

  bool operator == (const Distance& rhs)
  {
    return isInfinite_ == rhs.isInfinite_
        && distance_ == rhs.distance_;
  }
  bool operator!= (const Distance& rhs)
  {
    return !operator==(rhs);
  }
  bool operator< (const Distance& rhs)
  {
    if (isInfinite_) return false;
    if (rhs.isInfinite_) return true;
    if (distance_ < rhs.distance_) return true;
    return false;
  }
  bool operator> (const Distance& rhs)
  {
    return !operator<(rhs) && operator!=(rhs);
  }
  inline Distance operator+ (const Distance& rhs)
  {
    Distance res; // set to infinite
    if (isInfinite_ || rhs.isInfinite_)
      return res;
    res.setDistance(distance_+rhs.distance_);
    return res;
  }

  inline std::string getDistance() const
  {
    if (isInfinite()) return "Inf";
    return std::to_string(distance_);
  }
  inline SCALAR scalarDistance() const
  {
    return isInfinite_ ? GL_INF(SCALAR) : distance_;
  }
  inline void setDistance (SCALAR distance)
  {
    distance_ = distance;
    isInfinite_ = false;
  }

  inline bool isInfinite() const
  {
    return isInfinite_;
  }
  inline void setInfinite() const
  {
    distance_ = 0;
    isInfinite_ = true;
  }

  inline bool isZero() const
  {
    return !isInfinite() && distance_ == 0;
  }

private:
  bool isInfinite_;
  SCALAR distance_;
};

} // namespace gl

#endif // GL_DISTANCE_HPP