Do not rely on result_type definitions in kernels

Cartesian_kernel/include/CGAL/Cartesian/Circle_2.h

@@ -25,6 +25,7 @@ namespace CGAL {
 template <class R_ >
 class CircleC2
 {
+  typedef typename R_::Boolean              Boolean;
   typedef typename R_::FT                   FT;
   typedef typename R_::RT                   RT;
   typedef typename R_::Circle_2             Circle_2;
@@ -49,8 +50,8 @@ class CircleC2
     base = Rep(center, squared_radius, orient);
   }
 
-  bool           operator==(const CircleC2 &s) const;
-  bool           operator!=(const CircleC2 &s) const;
+  Boolean operator==(const CircleC2& s) const;
+  Boolean operator!=(const CircleC2& s) const;
 
   const Point_2 & center() const
   {
@@ -69,6 +70,25 @@ class CircleC2
 
 };
 
+template < class R >
+typename R::Boolean
+CircleC2<R>::operator==(const CircleC2<R> &t) const
+{
+  if (CGAL::identical(base, t.base))
+    return true;
+
+  return center() == t.center() &&
+         squared_radius() == t.squared_radius() &&
+         orientation() == t.orientation();
+}
+
+template < class R >
+typename R::Boolean
+CircleC2<R>::operator!=(const CircleC2<R> &t) const
+{
+  return !(*this == t);
+}
+
 } //namespace CGAL
 
 #endif // CGAL_CARTESIAN_CIRCLE_2_H

Cartesian_kernel/include/CGAL/Cartesian/Circle_3.h

@@ -23,6 +23,8 @@ namespace CGAL {
 
 template <class R_ >
 class CircleC3 {
+  typedef typename R_::Boolean                  Boolean;
+  typedef typename R_::Bounded_side             Bounded_side;
   typedef typename R_::Sphere_3                 Sphere_3;
   typedef typename R_::Plane_3                  Plane_3;
   typedef typename R_::Point_3                  Point_3;
@@ -130,12 +132,12 @@ class CircleC3 {
     return diametral_sphere();
   }
 
-  Point_3 center() const
+  decltype(auto) center() const
   {
     return diametral_sphere().center();
   }
 
-  FT squared_radius() const
+  decltype(auto) squared_radius() const
   {
     return diametral_sphere().squared_radius();
   }
@@ -155,7 +157,7 @@ class CircleC3 {
     return CGAL_PI * CGAL_PI * 4.0 * to_double(squared_radius());
   }
 
-  FT area_divided_by_pi() const
+  decltype(auto) area_divided_by_pi() const
   {
     return squared_radius();
   }
@@ -200,15 +202,15 @@ class CircleC3 {
                         (x+mx).sup(),(y+my).sup(),(z+mz).sup());
   }
 
-  bool operator==(const CircleC3 &) const;
-  bool operator!=(const CircleC3 &) const;
+  Boolean operator==(const CircleC3 &) const;
+  Boolean operator!=(const CircleC3 &) const;
 
-  bool has_on(const Point_3 &p) const;
-  bool has_on_bounded_side(const Point_3 &p) const;
-  bool has_on_unbounded_side(const Point_3 &p) const;
+  Boolean has_on(const Point_3 &p) const;
+  Boolean has_on_bounded_side(const Point_3 &p) const;
+  Boolean has_on_unbounded_side(const Point_3 &p) const;
   Bounded_side bounded_side(const Point_3 &p) const;
 
-  bool is_degenerate() const
+  Boolean is_degenerate() const
   {
     return diametral_sphere().is_degenerate();
   }
@@ -217,7 +219,7 @@ class CircleC3 {
 
 template < class R >
 inline
-bool
+typename R::Boolean
 CircleC3<R>::
 has_on(const typename CircleC3<R>::Point_3 &p) const
 {
@@ -227,7 +229,7 @@ has_on(const typename CircleC3<R>::Point_3 &p) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 CircleC3<R>::
 has_on_bounded_side(const typename CircleC3<R>::Point_3 &p) const
 {
@@ -237,7 +239,7 @@ has_on_bounded_side(const typename CircleC3<R>::Point_3 &p) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 CircleC3<R>::
 has_on_unbounded_side(const typename CircleC3<R>::Point_3 &p) const
 {
@@ -246,8 +248,7 @@ has_on_unbounded_side(const typename CircleC3<R>::Point_3 &p) const
 }
 
 template < class R >
-CGAL_KERNEL_INLINE
-Bounded_side
+typename R::Bounded_side
 CircleC3<R>::
 bounded_side(const typename CircleC3<R>::Point_3 &p) const
 {
@@ -256,8 +257,7 @@ bounded_side(const typename CircleC3<R>::Point_3 &p) const
 }
 
 template < class R >
-CGAL_KERNEL_INLINE
-bool
+typename R::Boolean
 CircleC3<R>::operator==(const CircleC3<R> &t) const
 {
   if (CGAL::identical(base, t.base))
@@ -283,8 +283,7 @@ CircleC3<R>::operator==(const CircleC3<R> &t) const
 }
 
 template < class R >
-CGAL_KERNEL_INLINE
-bool
+typename R::Boolean
 CircleC3<R>::operator!=(const CircleC3<R> &t) const
 {
   return !(*this == t);

Cartesian_kernel/include/CGAL/Cartesian/Direction_2.h

@@ -26,6 +26,8 @@ template < class R_ >
 class DirectionC2
 {
   typedef DirectionC2<R_>                   Self;
+
+  typedef typename R_::Boolean              Boolean;
   typedef typename R_::FT                   FT;
   typedef FT                                RT;
   typedef typename R_::Point_2              Point_2;
@@ -49,8 +51,8 @@ class DirectionC2
   DirectionC2(const FT &x, const FT &y)
     : base{x, y} {}
 
-  bool operator==(const DirectionC2 &d) const;
-  bool operator!=(const DirectionC2 &d) const;
+  Boolean operator==(const DirectionC2 &d) const;
+  Boolean operator!=(const DirectionC2 &d) const;
 
   Vector_2 to_vector() const;
 
@@ -66,7 +68,7 @@ class DirectionC2
 
 template < class R >
 inline
-bool
+typename R::Boolean
 DirectionC2<R>::operator==(const DirectionC2<R> &d) const
 {
   if (CGAL::identical(base, d.base))
@@ -76,7 +78,7 @@ DirectionC2<R>::operator==(const DirectionC2<R> &d) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 DirectionC2<R>::operator!=(const DirectionC2<R> &d) const
 {
   return !( *this == d );

Cartesian_kernel/include/CGAL/Cartesian/Iso_cuboid_3.h

@@ -26,6 +26,8 @@ namespace CGAL {
 template < class R_ >
 class Iso_cuboidC3
 {
+  typedef typename R_::Boolean              Boolean;
+  typedef typename R_::Bounded_side         Bounded_side;
   typedef typename R_::FT                   FT;
   typedef typename R_::Iso_cuboid_3         Iso_cuboid_3;
   typedef typename R_::Point_3              Point_3;
@@ -98,8 +100,8 @@ class Iso_cuboidC3
                                     Construct_point_3()(max_hx/hw, max_hy/hw, max_hz/hw)));
   }
 
-  typename R::Boolean   operator==(const Iso_cuboidC3& s) const;
-  typename R::Boolean   operator!=(const Iso_cuboidC3& s) const;
+  Boolean operator==(const Iso_cuboidC3& s) const;
+  Boolean operator!=(const Iso_cuboidC3& s) const;
 
   const Point_3 & min BOOST_PREVENT_MACRO_SUBSTITUTION () const
   {
@@ -118,11 +120,11 @@ class Iso_cuboidC3
   }
 
   Bounded_side bounded_side(const Point_3& p) const;
-  typename R::Boolean           has_on(const Point_3& p) const;
-  typename R::Boolean           has_on_boundary(const Point_3& p) const;
-  typename R::Boolean           has_on_bounded_side(const Point_3& p) const;
-  typename R::Boolean           has_on_unbounded_side(const Point_3& p) const;
-  typename R::Boolean           is_degenerate() const;
+  Boolean has_on(const Point_3& p) const;
+  Boolean has_on_boundary(const Point_3& p) const;
+  Boolean has_on_bounded_side(const Point_3& p) const;
+  Boolean has_on_unbounded_side(const Point_3& p) const;
+  Boolean is_degenerate() const;
   const FT &   xmin() const;
   const FT &   ymin() const;
   const FT &   zmin() const;
@@ -267,7 +269,7 @@ Iso_cuboidC3<R>::volume() const
 
 template < class R >
 CGAL_KERNEL_MEDIUM_INLINE
-Bounded_side
+typename R::Bounded_side
 Iso_cuboidC3<R>::
 bounded_side(const typename Iso_cuboidC3<R>::Point_3& p) const
 {

Cartesian_kernel/include/CGAL/Cartesian/Line_3.h

@@ -24,6 +24,7 @@ namespace CGAL {
 template < class R_ >
 class LineC3
 {
+  typedef typename R_::Boolean              Boolean;
   typedef typename R_::FT                   FT;
   typedef typename R_::Point_3              Point_3;
   typedef typename R_::Vector_3             Vector_3;
@@ -65,8 +66,8 @@ class LineC3
   LineC3(const Point_3 &p, const Direction_3 &d)
   { *this = R().construct_line_3_object()(p, d); }
 
-  bool        operator==(const LineC3 &l) const;
-  bool        operator!=(const LineC3 &l) const;
+  typename R::Boolean operator==(const LineC3 &l) const;
+  typename R::Boolean operator!=(const LineC3 &l) const;
 
   Plane_3     perpendicular_plane(const Point_3 &p) const;
   Line_3      opposite() const;
@@ -88,13 +89,13 @@ class LineC3
 
   Point_3     point(const FT i) const;
 
-  bool        has_on(const Point_3 &p) const;
-  bool        is_degenerate() const;
+  Boolean has_on(const Point_3 &p) const;
+  Boolean is_degenerate() const;
 };
 
 template < class R >
 inline
-bool
+typename R::Boolean
 LineC3<R>::operator==(const LineC3<R> &l) const
 {
   if (CGAL::identical(base, l.base))
@@ -104,7 +105,7 @@ LineC3<R>::operator==(const LineC3<R> &l) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 LineC3<R>::operator!=(const LineC3<R> &l) const
 {
   return !(*this == l);
@@ -135,7 +136,7 @@ LineC3<R>::opposite() const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 LineC3<R>::
 has_on(const typename LineC3<R>::Point_3 &p) const
 {
@@ -144,7 +145,7 @@ has_on(const typename LineC3<R>::Point_3 &p) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 LineC3<R>::is_degenerate() const
 {
   return to_vector() == NULL_VECTOR;

Cartesian_kernel/include/CGAL/Cartesian/Point_3.h

@@ -107,6 +107,15 @@ class PointC3
     return base.cartesian_end();
   }
 
+  typename R_::Boolean operator==(const PointC3 &p) const
+  {
+      return base == p.base;
+  }
+  typename R_::Boolean operator!=(const PointC3 &p) const
+  {
+      return !(*this == p);
+  }
+
   int dimension() const
   {
       return base.dimension();

Cartesian_kernel/include/CGAL/Cartesian/Segment_3.h

@@ -25,6 +25,7 @@ namespace CGAL {
 template < class R_ >
 class SegmentC3
 {
+  typedef typename R_::Boolean              Boolean;
   typedef typename R_::Point_3              Point_3;
   typedef typename R_::Direction_3          Direction_3;
   typedef typename R_::Vector_3             Vector_3;
@@ -44,11 +45,11 @@ class SegmentC3
   SegmentC3(const Point_3 &sp, const Point_3 &ep)
     : base{sp, ep} {}
 
-  bool        has_on(const Point_3 &p) const;
-  bool        collinear_has_on(const Point_3 &p) const;
+  Boolean has_on(const Point_3 &p) const;
+  Boolean collinear_has_on(const Point_3 &p) const;
 
-  bool        operator==(const SegmentC3 &s) const;
-  bool        operator!=(const SegmentC3 &s) const;
+  Boolean operator==(const SegmentC3 &s) const;
+  Boolean operator!=(const SegmentC3 &s) const;
 
   const Point_3 &   source() const
   {
@@ -73,12 +74,12 @@ class SegmentC3
   Line_3      supporting_line() const;
   Segment_3   opposite() const;
 
-  bool        is_degenerate() const;
+  Boolean is_degenerate() const;
 };
 
 template < class R >
 inline
-bool
+typename R::Boolean
 SegmentC3<R>::operator==(const SegmentC3<R> &s) const
 {
   if (CGAL::identical(base, s.base))
@@ -88,7 +89,7 @@ SegmentC3<R>::operator==(const SegmentC3<R> &s) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 SegmentC3<R>::operator!=(const SegmentC3<R> &s) const
 {
   return !(*this == s);
@@ -184,15 +185,15 @@ SegmentC3<R>::opposite() const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 SegmentC3<R>::is_degenerate() const
 {
   return source() == target();
 }
 
 template < class R >
 inline
-bool
+typename R::Boolean
 SegmentC3<R>::
 has_on(const typename SegmentC3<R>::Point_3 &p) const
 {
@@ -201,7 +202,7 @@ has_on(const typename SegmentC3<R>::Point_3 &p) const
 
 template < class R >
 inline
-bool
+typename R::Boolean
 SegmentC3<R>::
 collinear_has_on(const typename SegmentC3<R>::Point_3 &p) const
 {