SemiOpenInterval.h

Go to the documentation of this file.

// -*- C++ -*-

#if !defined(__geom_SemiOpenInterval_h__)
#define __geom_SemiOpenInterval_h__

// If we are debugging the whole geom package.
#if defined(DEBUG_geom) && !defined(DEBUG_SemiOpenInterval)
#define DEBUG_SemiOpenInterval
#endif

#ifdef DEBUG_SemiOpenInterval
// Debug the Interval class as well.
#ifndef DEBUG_Interval
#define DEBUG_Interval
#endif
#endif

#include "Interval.h"
  
BEGIN_NAMESPACE_GEOM



template<int N, typename T = double>
class SemiOpenInterval
  : public Interval<N,T> {
private:

  //
  // Private types.
  //

  typedef Interval<N,T> Base;

public:

  //
  // Public types.
  //

  typedef T Number;
  typedef typename Base::Point Point;

public:
  
  //--------------------------------------------------------------------------
  // @{
  
  SemiOpenInterval() : 
    Base() 
  {}

  SemiOpenInterval(const Point& min, const Point& max) :
    Base(min, max)
  {}
    
  SemiOpenInterval(const Number xmin, const Number xmax) :
    Base(xmin, xmax)
  {}
    
  SemiOpenInterval(const Number xmin, const Number ymin, 
                   const Number xmax, const Number ymax) :
    Base(xmin, ymin, xmax, ymax)
  {}
    
  SemiOpenInterval(const Number xmin, const Number ymin, const Number zmin,
                   const Number xmax, const Number ymax, const Number zmax) :
    Base(xmin, ymin, zmin, xmax, ymax, zmax)
  {}
    

  SemiOpenInterval(const Number* coordinates) :
    Base(coordinates)
  {}
    
  SemiOpenInterval(const SemiOpenInterval& other):
    Base(other)
  {}

  SemiOpenInterval(const Interval<N,T>& x) :
    Base(x)
  {}

  SemiOpenInterval& 
  operator=(const SemiOpenInterval& other) {
    Base::operator=(other);
    return *this;
  }

  using Base::add;

  ~SemiOpenInterval() 
  {}

  // @}
  //--------------------------------------------------------------------------
  // @{

  using Base::bound;

  // @}
  //--------------------------------------------------------------------------
  // @{
    
  using Base::getLowerCorner;

  using Base::getUpperCorner;

  using Base::computeContent;

  // @}
  //--------------------------------------------------------------------------
  // @{

  using Base::setLowerCorner;

  using Base::setUpperCorner;

  using Base::setCorners;

  using Base::setLowerCoordinate;

  using Base::setUpperCoordinate;

  // @}
  //--------------------------------------------------------------------------
  // @{

  using Base::getDimension;

  // @}
  //--------------------------------------------------------------------------
  // @{
  
  bool 
  isEmpty() const;

  // CONTINUE: Should other members be templated?
  template<typename PointType>
  bool 
  isIn(const PointType& p) const;

  // @}
};
  

//
// File I/O.
//

  

template<int N, typename T>
void
printFormatted(std::ostream& out, const SemiOpenInterval<N,T>& x);


//
// Mathematical Functions.
//

 

template<int N, typename T>
bool 
doOverlap(const SemiOpenInterval<N,T>& a, const SemiOpenInterval<N,T>& b);


END_NAMESPACE_GEOM

#define __geom_SemiOpenInterval_ipp__
#include "SemiOpenInterval.ipp"
#undef __geom_SemiOpenInterval_ipp__

#endif

---