Segment.h

// -*- C++ -*-

#if !defined(__geom_Segment_h__)
#define __geom_Segment_h__

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

#ifdef DEBUG_Segment
#ifndef DEBUG_Point
#define DEBUG_Point
#endif
#endif

#include "Point.h"

BEGIN_NAMESPACE_GEOM


template<int N, typename T = double>
class Segment {
  //
  // Public types.
  //

public:
    
  typedef T Number;
  typedef ads::FixedArray<N,T> Point;

  //
  // Data
  //

private:
    
  Point _source, _target;
    
public:
    
  //--------------------------------------------------------------------------
  // @{

  Segment() :
    _source(),
    _target() 
  {}

  Segment(const Point& source, const Point& target) : 
    _source(source), 
    _target(target) 
  {}

  Segment(const Segment& other) : 
    _source(other._source), 
    _target(other._target) 
  {}

  Segment& 
  operator=(const Segment& other);

  ~Segment() 
  {}

  void 
  make(const Point& source, const Point& target) { 
    _source = source; 
    _target = target; 
  }

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

  const Point& 
  getSource() const { 
    return _source; 
  }

  const Point& 
  getTarget() const { 
    return _target; 
  }
    
  // @}
  //--------------------------------------------------------------------------
  // @{

  // CONTINUE
#if 0
  void
  setSource(const Point& source) { 
    _source = source; 
  }

  void
  setTarget(const Point& target) { 
    _target = target; 
  }
#endif

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

  Segment& 
  operator+=(const Point& p);

  Segment& 
  operator-=(const Point& p);

  // @}
};

  
//
// Equality Operators.
//



template<int N, typename T>
inline
bool 
operator==(const Segment<N,T>& x, const Segment<N,T>& y) {
  return (x.getSource() == y.getSource() && x.getTarget() == y.getTarget());
}



template<int N, typename T>
inline
bool 
operator!=(const Segment<N,T>& x, const Segment<N,T>& y) {
  return !(x == y);
}


//
// Unary Operators.
//



template<int N, typename T>
inline
const Segment<N,T>&
operator+(const Segment<N,T>& x) {
  return x;
}



template<int N, typename T>
inline
Segment<N,T> 
operator-(const Segment<N,T>& x) {
  return Segment<N,T>(x.getTarget(), x.getSource());
}


//
// Binary Operators.
//



template<int N, typename T>
inline
Segment<N,T> 
operator+(const Segment<N,T>& s, const typename Segment<N,T>::Point& p) {
  return Segment<N,T>(s.getSource() + p, s.getTarget() + p);
}



template<int N, typename T>
inline
Segment<N,T> 
operator-(const Segment<N,T>& s, const typename Segment<N,T>::Point& p) {
  return Segment<N,T>(s.getSource() - p, s.getTarget() - p);
}


//
// File I/O Operators.
//



template<int N, typename T>
inline
std::istream& 
operator>>(std::istream& in, Segment<N,T>& x) {
  typename Segment<N,T>::Point source, target;
  in >> source >> target;
  x.make(source, target);
  return in;
}



template<int N, typename T>
inline
std::ostream& 
operator<<(std::ostream& out, const Segment<N,T>& x)
{
  return out << x.getSource() << " " << x.getTarget();
}


END_NAMESPACE_GEOM

#define __geom_Segment_ipp__
#include "Segment.ipp"
#undef __geom_Segment_ipp__
  
#endif

---