Point2DBase.h

Go to the documentation of this file.

#ifndef GeometryVector_Point2DBase_h
#define GeometryVector_Point2DBase_h
 
#include "DataFormats/GeometryVector/interface/PointTag.h"
#include "DataFormats/GeometryVector/interface/PV2DBase.h"
#include "DataFormats/GeometryVector/interface/Vector2DBase.h"
 
template <class T, class FrameTag>
class Point2DBase : public PV2DBase<T, PointTag, FrameTag> {
public:
  typedef PV2DBase<T, PointTag, FrameTag> BaseClass;
  typedef Vector2DBase<T, FrameTag> VectorType;
  typedef Basic2DVector<T> BasicVectorType;
  typedef typename BaseClass::Polar Polar;
 
  Point2DBase() {}
 
  template <class U>
  Point2DBase(const Point2DBase<U, FrameTag>& p) : BaseClass(p.basicVector()) {}
 
  Point2DBase(const T& x, const T& y) : BaseClass(x, y) {}
 
  explicit Point2DBase(const Polar& set) : BaseClass(set) {}
 
  template <class U>
  explicit Point2DBase(const Basic2DVector<U>& v) : BaseClass(v) {}
 
  template <class U>
  Point2DBase& operator+=(const Vector2DBase<U, FrameTag>& v) {
    this->basicVector() += v.basicVector();
    return *this;
  }
 
  template <class U>
  Point2DBase& operator-=(const Vector2DBase<U, FrameTag>& v) {
    this->basicVector() -= v.basicVector();
    return *this;
  }
};
 
template <typename T, typename U, class Frame>
inline Point2DBase<typename PreciseFloatType<T, U>::Type, Frame> operator+(const Point2DBase<T, Frame>& p,
                                                                           const Vector2DBase<U, Frame>& v) {
  typedef Point2DBase<typename PreciseFloatType<T, U>::Type, Frame> RT;
  return RT(p.basicVector() + v.basicVector());
}
 
template <typename T, typename U, class Frame>
inline Point2DBase<typename PreciseFloatType<T, U>::Type, Frame> operator+(const Vector2DBase<T, Frame>& p,
                                                                           const Point2DBase<U, Frame>& v) {
  typedef Point2DBase<typename PreciseFloatType<T, U>::Type, Frame> RT;
  return RT(p.basicVector() + v.basicVector());
}
 
template <typename T, typename U, class Frame>
inline Vector2DBase<typename PreciseFloatType<T, U>::Type, Frame> operator-(const Point2DBase<T, Frame>& p1,
                                                                            const Point2DBase<U, Frame>& p2) {
  typedef Vector2DBase<typename PreciseFloatType<T, U>::Type, Frame> RT;
  return RT(p1.basicVector() - p2.basicVector());
}
 
#endif  // GeometryVector_Point2DBase_h