boost::integral_constant ---> std::integral_constant

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Curve_analysis_2.h

@@ -65,7 +65,7 @@ namespace internal {
 
 template<typename Comparable,bool has_template_typedefs>
   struct Is_derived_from_Handle_with_policy {
-    typedef boost::false_type Tag;
+    typedef std::false_type Tag;
 };
 
 template<typename Comparable>
@@ -89,7 +89,7 @@ template<typename Comparable,typename Tag> struct Compare_for_vert_line_map_
 };
 
 template<typename Comparable>
-  struct Compare_for_vert_line_map_<Comparable,boost::true_type> {
+  struct Compare_for_vert_line_map_<Comparable,std::true_type> {
 
     bool operator() (const Comparable& a, const Comparable& b) const {
       return CGAL::Handle_id_less_than< Comparable >()(a,b);

Arrangement_on_surface_2/include/CGAL/Arr_conic_traits_2.h

@@ -71,7 +71,7 @@ public:
   typedef Tag_true                        Has_left_category;
   typedef Tag_true                        Has_merge_category;
   typedef Tag_false                       Has_do_intersect_category;
-  //typedef boost::true_type                Has_line_segment_constructor;
+  //typedef std::true_type                Has_line_segment_constructor;
 
   typedef Arr_oblivious_side_tag          Left_side_category;
   typedef Arr_oblivious_side_tag          Bottom_side_category;

Arrangement_on_surface_2/include/CGAL/Arr_geodesic_arc_on_sphere_traits_2.h

@@ -65,7 +65,7 @@ public:
   typedef Arr_contracted_side_tag               Top_side_category;
   typedef Arr_identified_side_tag               Right_side_category;
 
-  typedef boost::integral_constant<bool, atan_y==0>       Zero_atan_y;
+  typedef std::integral_constant<bool, atan_y==0>       Zero_atan_y;
 
   // Traits objects
   typedef Arr_extended_direction_3<Kernel>                Point_2;
@@ -357,7 +357,7 @@ public:
    */
   void intersection_with_identification(const X_monotone_curve_2& xcv,
                                         Direction_3& dp,
-                                        boost::true_type) const
+                                        std::true_type) const
   {
     const Direction_3& normal = xcv.normal();
     dp = (CGAL::sign(normal.dz()) == POSITIVE) ?
@@ -370,7 +370,7 @@ public:
    */
   void intersection_with_identification(const X_monotone_curve_2& xcv,
                                         Direction_3& dp,
-                                        boost::false_type) const
+                                        std::false_type) const
   {
     const Direction_3& normal = xcv.normal();
     FT z((atan_x * normal.dx() + atan_y * normal.dy()) /
@@ -382,7 +382,7 @@ public:
    * \param[in] cv the curve
    */
   bool overlap_with_identification(const X_monotone_curve_2& xcv,
-                                   boost::true_type) const
+                                   std::true_type) const
   {
     const Direction_3& normal = xcv.normal();
     return ((x_sign(normal) == ZERO) &&
@@ -394,7 +394,7 @@ public:
    * \param[in] cv the curve
    */
   bool overlap_with_identification(const X_monotone_curve_2& xcv,
-                                   boost::false_type) const
+                                   std::false_type) const
   {
     const Direction_3& normal = xcv.normal();
     const Direction_3& iden_normal = identification_normal();
@@ -440,7 +440,7 @@ public:
       Point_2 p;
       Direction_3& d(p);
       d = Direction_3(x, y, z);
-      init(p, boost::integral_constant<bool, atan_y==0>());
+      init(p, std::integral_constant<bool, atan_y==0>());
       return p;
     }
 
@@ -453,14 +453,14 @@ public:
       Point_2 p;
       Direction_3& d(p);
       d = Direction_3(other);
-      init(p, boost::integral_constant<bool, atan_y==0>());
+      init(p, std::integral_constant<bool, atan_y==0>());
       return p;
     }
 
     /*! Initialize a point on the sphere,
      * \param[in] p the point to initialize.
      */
-    void init(Point_2& p, boost::true_type) const
+    void init(Point_2& p, std::true_type) const
     {
       const Direction_3& dir = p;
       if (y_sign(dir) != ZERO) {
@@ -479,7 +479,7 @@ public:
     /*! Initialize a point on the sphere,
      * \param[in] p the point to initialize.
      */
-    void init(Point_2& p, boost::false_type) const
+    void init(Point_2& p, std::false_type) const
     {
       const Direction_3& dir = p;
       if ((x_sign(dir) == ZERO) && (y_sign(dir) == ZERO)) {

Arrangement_on_surface_2/include/CGAL/Arrangement_2/Arrangement_on_surface_2_global.h

@@ -61,7 +61,7 @@ namespace Ss2 = Surface_sweep_2;
 // The last parameter is used to resolve ambiguity between this function and
 // do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
 // Curve_2 are the same class.
-// The last parameter should be boost::false_type but we used a
+// The last parameter should be std::false_type but we used a
 // workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
 //
 // error: no matching function for call to `do_intersect(Arrangement_2<>&,
@@ -132,7 +132,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
 //
 // The last parameter is used to resolve ambiguity between this function and
 // do_intersect of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
-// same class. The last parameter should be boost::true_type but we used a
+// same class. The last parameter should be std::true_type but we used a
 // workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
 //
 // error: no matching function for call to `do_intersect(Arrangement_2<>&,
@@ -406,7 +406,7 @@ void insert_non_empty(Arrangement_on_surface_2<GeometryTraits_2,
 // The last parameter is used to resolve ambiguity between this function and
 // do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
 // Curve_2 are the same class.
-// The last parameter should be boost::false_type but we used a
+// The last parameter should be std::false_type but we used a
 // workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
 //
 // error: no matching function for call to `do_intersect(Arrangement_2<>&,
@@ -460,7 +460,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
 //
 // The last parameter is used to resolve ambiguity between this function and
 // insert of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
-// same class. The last parameter should be boost::true_type but we used a
+// same class. The last parameter should be std::true_type but we used a
 // workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
 //
 // error: no matching function for call to `do_intersect(Arrangement_2<>&,
@@ -1522,7 +1522,7 @@ zone(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
 // Checks whether the given x-monotone curve intersects the existing arrangement.
 // The last parameter is used to resolve ambiguity between this function and
 // do_intersect of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
-// same class. The last parameter should be boost::true_type but we used a
+// same class. The last parameter should be std::true_type but we used a
 // workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
 //
 // error: no matching function for call to `do_intersect(Arrangement_on_surface_2<>&,
@@ -1559,7 +1559,7 @@ do_intersect(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
 // The last parameter is used to resolve ambiguity between this function and
 // do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
 // Curve_2 are the same class.
-// The last parameter should be boost::false_type but we used a
+// The last parameter should be std::false_type but we used a
 // workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
 //
 // error: no matching function for call to

Arrangement_on_surface_2/include/CGAL/Arrangement_2/arrangement_type_traits.h

@@ -24,7 +24,7 @@
 #include <CGAL/license/Arrangement_on_surface_2.h>
 
 
-#include <boost/type_traits/integral_constant.hpp>
+#include <type_traits>
 
 namespace CGAL
 {
@@ -62,7 +62,7 @@ namespace CGAL
 
 // In the meanwhile we use a default implementation.
 template <class T>
-class is_arrangement_2 : public boost::false_type
+class is_arrangement_2 : public std::false_type
 {};
 
 //--------------------------------  Arrangement_2
@@ -74,7 +74,7 @@ class Arrangement_2;
 template <class GeomTraits_, class DCEL_>
 class is_arrangement_2<
   Arrangement_2<GeomTraits_, DCEL_>
-> : public boost::false_type
+> : public std::false_type
 {};
 
 
@@ -87,7 +87,7 @@ class Arrangement_on_surface_2;
 template <class GeomTraits_, class TopTraits_>
 class is_arrangement_2<
   Arrangement_on_surface_2<GeomTraits_, TopTraits_>
-> : public boost::true_type
+> : public std::true_type
 {};
 
 } // namespace CGAL

Circular_kernel_2/benchmark/DxfArrayBenchmarks/benchmark.h

@@ -267,7 +267,7 @@ private:
 
         try{
                     this->start();
-                      insert(_pm,ac.begin(),ac.end(),boost::false_type());
+                      insert(_pm,ac.begin(),ac.end(),std::false_type());
                     this->stop();
           }
           catch (...) {

Circular_kernel_2/benchmark/arrangement_traits/benchmark.h

@@ -214,7 +214,7 @@ class Bench
   try{
     this->start();
 
-      insert(_pm,ac.begin(),ac.end(),boost::false_type());
+      insert(_pm,ac.begin(),ac.end(),std::false_type());
 
     this->stop();
   }

Circular_kernel_2/benchmark/benchmark.h

@@ -219,7 +219,7 @@ private:
           Point_location _pl(_pm);
         try{
                     this->start();
-                      insert(_pm,ac.begin(),ac.end(),boost::false_type());
+                      insert(_pm,ac.begin(),ac.end(),std::false_type());
                     this->stop();
           } catch (std::exception &e) {
                     this->fail();

Circular_kernel_2/benchmark/benchmark_CK2.cpp

@@ -87,7 +87,7 @@ void do_main(const char *s) {
   struct rusage before, after;
   struct timeval utime, stime;
   getrusage(RUSAGE_SELF,&before);
-  insert(_pm,ac.begin(),ac.end(),boost::false_type());
+  insert(_pm,ac.begin(),ac.end(),std::false_type());
   getrusage(RUSAGE_SELF,&after);
   timersub(&(after.ru_utime),&(before.ru_utime),&utime);
   timersub(&(after.ru_stime),&(before.ru_stime),&stime);
@@ -177,7 +177,7 @@ void do_main(int k) {
   struct rusage before, after;
   struct timeval utime, stime;
   getrusage(RUSAGE_SELF,&before);
-  insert(_pm,ac.begin(),ac.end(),boost::false_type());
+  insert(_pm,ac.begin(),ac.end(),std::false_type());
   getrusage(RUSAGE_SELF,&after);
   timersub(&(after.ru_utime),&(before.ru_utime),&utime);
   timersub(&(after.ru_stime),&(before.ru_stime),&stime);

Circular_kernel_2/benchmark/incremental_insertion/benchmark.h

@@ -217,7 +217,7 @@ class Bench
     this->start();
     for (typename ArcContainer::const_iterator it=ac.begin();
          it != ac.end(); ++it) {
-      insert(_pm,*it,_pl,boost::false_type());
+      insert(_pm,*it,_pl,std::false_type());
     };
     this->stop();
   }

Convex_hull_3/include/CGAL/convex_hull_3.h

@@ -155,7 +155,7 @@ struct Default_traits_for_Chull_3{
 
 //FT is a floating point type and Kernel is a filtered kernel
 template <class Point_3, class PolygonMesh>
-struct Default_traits_for_Chull_3<Point_3, PolygonMesh, boost::true_type,Tag_true>{
+struct Default_traits_for_Chull_3<Point_3, PolygonMesh, std::true_type,Tag_true>{
   typedef Convex_hull_traits_3< typename Kernel_traits<Point_3>::Kernel, PolygonMesh, Tag_true > type;
 };
 
@@ -172,7 +172,7 @@ struct Default_polyhedron_for_Chull_3<Convex_hull_traits_3<K, P, Tag> >{
 template <class T>
 struct Is_cartesian_kernel
 {
-  typedef boost::false_type type;
+  typedef std::false_type type;
 };
 
 template <class Kernel, class PolygonMesh>
@@ -233,7 +233,7 @@ public:
 //interval arithmetic (the protector must be created before using this predicate)
 //and in case of failure, exact arithmetic is used.
 template <class Kernel, class P>
-class Is_on_positive_side_of_plane_3<Convex_hull_traits_3<Kernel, P, Tag_true>, boost::true_type >{
+class Is_on_positive_side_of_plane_3<Convex_hull_traits_3<Kernel, P, Tag_true>, std::true_type >{
   typedef Simple_cartesian<CGAL::internal::Exact_field_selector<double>::Type>  Exact_K;
   typedef Simple_cartesian<Interval_nt_advanced >                               Approx_K;
   typedef Convex_hull_traits_3<Kernel, P, Tag_true>                             Traits;

Convex_hull_3/test/Convex_hull_3/quick_hull_default_traits.cpp

@@ -29,6 +29,6 @@ int main()
   CGAL_static_assertion( (std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value) );
   CGAL_static_assertion( (std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value) );
   CGAL_static_assertion( (std::is_same<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>,Default_traits_for_Chull_3<EPIC::Point_3>::type>::value) );
-  CGAL_static_assertion( (std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, boost::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value) );
+  CGAL_static_assertion( (std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, std::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value) );
   return 0;
 }

Envelope_3/include/CGAL/Envelope_3/Envelope_diagram_on_surface_2.h

@@ -129,14 +129,14 @@ public:
 template <class GeomTraits_, class TopTraits_>
 class is_arrangement_2<
   Envelope_diagram_on_surface_2<GeomTraits_, TopTraits_>
-> : public boost::true_type
+> : public std::true_type
 {};
 
 // specialization
 template <class GeomTraits_, class DCEL_>
 class is_arrangement_2<
   Envelope_diagram_2<GeomTraits_, DCEL_>
-> : public boost::true_type
+> : public std::true_type
 {};
 
 

Filtered_kernel/include/CGAL/Lazy_kernel.h

@@ -61,7 +61,7 @@ public:
 
 template<typename T>
 struct Has_result_type
-  : boost::integral_constant< bool,
+  : std::integral_constant< bool,
                               Has_result_type_helper< std::remove_cv_t<T>>::value>
 {};
 

NewKernel_d/include/CGAL/NewKernel_d/Cartesian_LA_base.h

@@ -13,7 +13,7 @@
 #define CGAL_KERNEL_D_CARTESIAN_LA_BASE_H
 #include <CGAL/basic.h>
 #include <CGAL/Origin.h>
-#include <boost/type_traits/integral_constant.hpp>
+#include <type_traits>
 #include <CGAL/representation_tags.h>
 #include <CGAL/NewKernel_d/functor_tags.h>
 #include <CGAL/Uncertain.h>
@@ -89,7 +89,7 @@ struct Cartesian_LA_base_d : public Dimension_base<Dim_>
       ::add<Vector_cartesian_const_iterator_tag>::type
       Iterator_list;
 
-    template<class, class=void, class=boost::integral_constant<int,0> > struct Functor {
+    template<class, class=void, class=std::integral_constant<int,0> > struct Functor {
             typedef Null_functor type;
     };
     template<class D> struct Functor<Construct_ttag<Vector_tag>,D> {
@@ -105,19 +105,19 @@ struct Cartesian_LA_base_d : public Dimension_base<Dim_>
             typedef CartesianDVectorBase::Construct_cartesian_const_iterator<Self> type;
     };
     template<class D> struct Functor<Sum_of_vectors_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
             typedef CartesianDVectorBase::Sum_of_vectors<Self> type;
     };
     template<class D> struct Functor<Difference_of_vectors_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
             typedef CartesianDVectorBase::Difference_of_vectors<Self> type;
     };
     template<class D> struct Functor<Opposite_vector_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
             typedef CartesianDVectorBase::Opposite_vector<Self> type;
     };
     template<class D> struct Functor<Midpoint_tag,D,
-      boost::integral_constant<int,
+      std::integral_constant<int,
            !LA_vector::template Property<Has_vector_plus_minus_tag>::value
         || !LA_vector::template Property<Has_vector_scalar_ops_tag>::value> > {
             typedef CartesianDVectorBase::Midpoint<Self> type;
@@ -135,24 +135,24 @@ struct Cartesian_LA_base_d : public Dimension_base<Dim_>
             typedef CartesianDVectorBase::PV_dimension<Self> type;
     };
     template<class D> struct Functor<Orientation_of_vectors_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_vectors_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_vectors_tag>::value> > {
             typedef CartesianDVectorBase::Orientation_of_vectors<Self> type;
     };
     template<class D> struct Functor<Orientation_of_points_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_points_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_points_tag>::value> > {
             typedef CartesianDVectorBase::Orientation_of_points<Self> type;
     };
     template<class D> struct Functor<Scalar_product_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Has_dot_product_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Has_dot_product_tag>::value> > {
             typedef CartesianDVectorBase::Scalar_product<Self> type;
     };
     template<class D> struct Functor<Squared_distance_to_origin_tag,D,
-      boost::integral_constant<int,!LA_vector::template Property<Stores_squared_norm_tag>::value> > {
+      std::integral_constant<int,!LA_vector::template Property<Stores_squared_norm_tag>::value> > {
             typedef CartesianDVectorBase::Squared_distance_to_origin_stored<Self> type;
     };
     // Use integral_constant<int,2> in case of failure, to distinguish from the previous one.
     template<class D> struct Functor<Squared_distance_to_origin_tag,D,
-      boost::integral_constant<int,
+      std::integral_constant<int,
         (LA_vector::template Property<Stores_squared_norm_tag>::value
          || !LA_vector::template Property<Has_dot_product_tag>::value)*2> > {
             typedef CartesianDVectorBase::Squared_distance_to_origin_via_dotprod<Self> type;

NewKernel_d/include/CGAL/NewKernel_d/LA_eigen/LA.h

@@ -38,10 +38,10 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct LA_eigen {
         struct Rebind_dimension {
           typedef LA_eigen< NT, D2, D3 > Other;
         };
-        template<class,class=void> struct Property : boost::false_type {};
+        template<class,class=void> struct Property : std::false_type {};
-        template<class D> struct Property<Has_vector_plus_minus_tag,D> : boost::true_type {};
+        template<class D> struct Property<Has_vector_plus_minus_tag,D> : std::true_type {};
-        template<class D> struct Property<Has_vector_scalar_ops_tag,D> : boost::true_type {};
+        template<class D> struct Property<Has_vector_scalar_ops_tag,D> : std::true_type {};
-        template<class D> struct Property<Has_dot_product_tag,D> : boost::true_type {};
+        template<class D> struct Property<Has_dot_product_tag,D> : std::true_type {};
 
         typedef Eigen::Matrix<NT,Eigen_dimension<Dim_>::value,1,Eigen::ColMajor|Eigen::AutoAlign,Eigen_dimension<Max_dim_>::value,1> Vector;
         typedef Eigen::Matrix<NT,Eigen::Dynamic,1> Dynamic_vector;

NewKernel_d/include/CGAL/NewKernel_d/Vector/array.h

@@ -38,7 +38,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Array_vector {
         struct Rebind_dimension {
           typedef Array_vector< NT, D2, D3 > Other;
         };
-        template<class> struct Property : boost::false_type {};
+        template<class> struct Property : std::false_type {};
 
         static const unsigned d_=Max_dim_::value;
         CGAL_static_assertion(d_ != (unsigned)UNKNOWN_DIMENSION);

NewKernel_d/include/CGAL/NewKernel_d/Vector/avx4.h

@@ -31,19 +31,19 @@ namespace CGAL {
     typedef Dimension_tag<4> Dimension;
     typedef Dimension_tag<4> Max_dimension;
     // No Rebind_dimension, this is a building block
-    template<class,bool=true> struct Property : boost::false_type {};
+    template<class,bool=true> struct Property : std::false_type {};
     template<bool b> struct Property<Has_vector_plus_minus_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
     /* MAYBE?
        template<bool b> struct Property<Has_vector_scalar_ops_tag,b>
-       : boost::true_type {};
+       : std::true_type {};
        */
     template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
     template<bool b> struct Property<Has_dot_product_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
     template<bool b> struct Property<Has_determinant_of_vectors_omit_last_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
 
     typedef __m256d Vector;
     struct Construct_vector {

NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_iterator_to_points_from_iterator_to_vectors.h

@@ -42,7 +42,7 @@ struct Add_determinant_of_iterator_to_points_from_iterator_to_vectors
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   // TODO: use std::minus, boost::bind, etc
   template<class T> struct Minus_fixed {

NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_iterator_to_points_from_points.h

@@ -42,7 +42,7 @@ struct Add_determinant_of_iterator_to_points_from_points
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@@ -74,7 +74,7 @@ struct Add_determinant_of_iterator_to_points_from_points
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@@ -108,7 +108,7 @@ struct Add_determinant_of_iterator_to_points_from_points
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@@ -144,7 +144,7 @@ struct Add_determinant_of_iterator_to_points_from_points
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@@ -182,7 +182,7 @@ struct Add_determinant_of_iterator_to_points_from_points
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){

NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_iterator_to_vectors_from_vectors.h

@@ -42,7 +42,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@@ -72,7 +72,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@@ -104,7 +104,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@@ -138,7 +138,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@@ -174,7 +174,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   template<class Iter>
   static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){

NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_points_from_vectors.h

@@ -42,7 +42,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT determinant_of_points(Vector const&a, Vector const&b,
       Vector const&c){
@@ -66,7 +66,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT determinant_of_points(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d){
@@ -90,7 +90,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT determinant_of_points(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d, Vector const&e){
@@ -114,7 +114,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT determinant_of_points(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d, Vector const&e, Vector const&f){
@@ -138,7 +138,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<Has_determinant_of_points_tag, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT determinant_of_points(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d, Vector const&e, Vector const&f,

NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_vectors_small_dim_internal.h

@@ -46,7 +46,7 @@ struct CGAL_CLASS
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<CGAL_TAG, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT CGAL_FUNC(Vector const&a, Vector const&b){
     return CGAL::determinant_of_vectors<NT>(a,b);
@@ -69,7 +69,7 @@ struct CGAL_CLASS
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<CGAL_TAG, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT CGAL_FUNC(Vector const&a, Vector const&b,
       Vector const&c){
@@ -93,7 +93,7 @@ struct CGAL_CLASS
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<CGAL_TAG, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT CGAL_FUNC(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d){
@@ -117,7 +117,7 @@ struct CGAL_CLASS
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<CGAL_TAG, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT CGAL_FUNC(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d, Vector const&e){
@@ -141,7 +141,7 @@ struct CGAL_CLASS
     };
   template<class P,class=void> struct Property : LA::template Property<P> {};
   template<class D> struct Property<CGAL_TAG, D> :
-    boost::true_type {};
+    std::true_type {};
 
   static NT CGAL_FUNC(Vector const&a, Vector const&b,
       Vector const&c, Vector const&d, Vector const&e, Vector const&f){

NewKernel_d/include/CGAL/NewKernel_d/Vector/sse2.h

@@ -32,17 +32,17 @@ namespace CGAL {
     typedef Dimension_tag<2> Dimension;
     typedef Dimension_tag<2> Max_dimension;
     // No Rebind_dimension, this is a building block
-    template<class,bool=true> struct Property : boost::false_type {};
+    template<class,bool=true> struct Property : std::false_type {};
     template<bool b> struct Property<Has_vector_plus_minus_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
     /* MAYBE?
        template<bool b> struct Property<Has_vector_scalar_ops_tag,b>
-       : boost::true_type {};
+       : std::true_type {};
        */
     template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
     template<bool b> struct Property<Has_dot_product_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
 
     typedef __m128d Vector;
     struct Construct_vector {

NewKernel_d/include/CGAL/NewKernel_d/Vector/v2int.h

@@ -70,13 +70,13 @@ namespace CGAL {
     typedef Dimension_tag<2> Dimension;
     typedef Dimension_tag<2> Max_dimension;
     // No Rebind_dimension, this is a building block
-    template<class,bool=true> struct Property : boost::false_type {};
+    template<class,bool=true> struct Property : std::false_type {};
     //template<bool b> struct Property<Has_vector_plus_minus_tag,b>
-    //  : boost::true_type {};
+    //  : std::true_type {};
     template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
-      : boost::true_type {};
+      : std::true_type {};
     //template<bool b> struct Property<Has_determinant_of_points_tag,b>
-    //  : boost::true_type {};
+    //  : std::true_type {};
     // Advertise somehow that the sign_of_determinant* are exact?
 
     typedef std::array<NT1,2> Vector;

NewKernel_d/include/CGAL/NewKernel_d/Vector/vector.h

@@ -29,7 +29,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Vector_vector {
         struct Rebind_dimension {
           typedef Vector_vector< NT, D2, D3 > Other;
         };
-        template<class> struct Property : boost::false_type {};
+        template<class> struct Property : std::false_type {};
 
         struct Construct_vector {
                 struct Dimension {

NewKernel_d/include/CGAL/NewKernel_d/functor_properties.h

@@ -20,7 +20,7 @@ namespace CGAL {
     BOOST_MPL_HAS_XXX_TRAIT_DEF(Is_pretty) \
   } \
   template<class T,bool=internal::has_##Is_pretty<T>::value> \
-  struct Is_pretty : boost::false_type {}; \
+  struct Is_pretty : std::false_type {}; \
   template<class T> \
   struct Is_pretty<T,true> : T::Is_pretty {}
 

NewKernel_d/include/CGAL/NewKernel_d/functor_tags.h

@@ -69,19 +69,19 @@ namespace CGAL {
                                    Provides_functor<K, typename boost::mpl::front<List>::type>,
                                    Provides_functors<K, typename boost::mpl::pop_front<List>::type> > {};
         template<class K, class List>
-        struct Provides_functors<K, List, true> : boost::true_type {};
+        struct Provides_functors<K, List, true> : std::true_type {};
 
         template<class K, class List, bool=boost::mpl::empty<List>::type::value>
         struct Provides_types : boost::mpl::and_ <
                                    Provides_type<K, typename boost::mpl::front<List>::type>,
                                    Provides_types<K, typename boost::mpl::pop_front<List>::type> > {};
         template<class K, class List>
-        struct Provides_types<K, List, true> : boost::true_type {};
+        struct Provides_types<K, List, true> : std::true_type {};
 
         namespace internal { BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_Type,template Type<Null_tag>,false) }
         template<class Kernel, class Tg,
           bool = internal::has_Type<Kernel>::value /* false */>
-        struct Provides_type_i : boost::false_type {};
+        struct Provides_type_i : std::false_type {};
         template<class Kernel, class Tg>
         struct Provides_type_i <Kernel, Tg, true>
           : Has_type_different_from<typename Kernel::template Type<Tg>, Null_type> {};
@@ -93,7 +93,7 @@ namespace CGAL {
 
         template<class Kernel, class Tg, class O=void,
           bool = internal::has_Functor<Kernel>::value /* false */>
-        struct Provides_functor_i : boost::false_type {};
+        struct Provides_functor_i : std::false_type {};
         template<class Kernel, class Tg, class O>
         struct Provides_functor_i <Kernel, Tg, O, true>
           : Has_type_different_from<typename Kernel::template Functor<Tg, O>, Null_functor> {};
@@ -332,19 +332,19 @@ namespace CGAL {
         struct Stores_squared_norm_tag {};
 
         template<class> struct Preserved_by_non_linear_extra_coordinate
-          : boost::false_type {};
+          : std::false_type {};
         template<> struct Preserved_by_non_linear_extra_coordinate
-          <Has_extra_dimension_tag> : boost::true_type {};
+          <Has_extra_dimension_tag> : std::true_type {};
         template<> struct Preserved_by_non_linear_extra_coordinate
-          <Has_determinant_of_vectors_tag> : boost::true_type {};
+          <Has_determinant_of_vectors_tag> : std::true_type {};
         template<> struct Preserved_by_non_linear_extra_coordinate
-          <Has_determinant_of_points_tag> : boost::true_type {};
+          <Has_determinant_of_points_tag> : std::true_type {};
         template<> struct Preserved_by_non_linear_extra_coordinate
-          <Has_determinant_of_iterator_to_vectors_tag> : boost::true_type {};
+          <Has_determinant_of_iterator_to_vectors_tag> : std::true_type {};
         template<> struct Preserved_by_non_linear_extra_coordinate
-          <Has_determinant_of_iterator_to_points_tag> : boost::true_type {};
+          <Has_determinant_of_iterator_to_points_tag> : std::true_type {};
         template<> struct Preserved_by_non_linear_extra_coordinate
-          <Has_determinant_of_vectors_omit_last_tag> : boost::true_type {};
+          <Has_determinant_of_vectors_omit_last_tag> : std::true_type {};
 
         // Kernel properties
         struct Point_stores_squared_distance_to_origin_tag {};

NewKernel_d/include/CGAL/NewKernel_d/utils.h

@@ -35,7 +35,7 @@ namespace internal {
 }
 
 template <class T, class No, bool=internal::has_type<T>::value /*false*/>
-struct Has_type_different_from : boost::false_type {};
+struct Has_type_different_from : std::false_type {};
 template <class T, class No>
 struct Has_type_different_from <T, No, true>
 : boost::mpl::not_<std::is_same<typename T::type, No> > {};

Optimal_transportation_reconstruction_2/include/CGAL/Optimal_transportation_reconstruction_2.h

@@ -1184,9 +1184,9 @@ public:
   // number type (like a multiprecision), the coordinates of the points
   // will increase a lot due to the relocation step. These functions
   // simply turn a relocated point to a rounded to double version.
-  void relocate_on_the_double_grid(Point&, boost::true_type) const
+  void relocate_on_the_double_grid(Point&, std::true_type) const
   {}
-  void relocate_on_the_double_grid(Point& p, boost::false_type) const
+  void relocate_on_the_double_grid(Point& p, std::false_type) const
   {
     double x=to_double(m_traits.compute_x_2_object()(p));
     double y=to_double(m_traits.compute_y_2_object()(p));

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h

@@ -1147,7 +1147,7 @@ bool do_intersect(const PolylineRange& polylines1,
                       typename boost::mpl::eval_if<
                         boost::has_range_iterator<PolylineRange>,
                         boost::range_value<PolylineRange>,
-                        boost::false_type >::type
+                        std::false_type >::type
                     >::value
                    >* = 0//end enable_if
 #endif
@@ -1194,7 +1194,7 @@ bool do_intersect(const Polyline& polyline1,
                       typename boost::mpl::eval_if<
                         boost::has_range_iterator<Polyline>,
                         boost::range_value<Polyline>,
-                        boost::false_type
+                        std::false_type
                       >::type
                     >::value
                   >* = 0//end enable_if
@@ -1365,7 +1365,7 @@ bool do_intersect(const TriangleMesh& tm,
                       typename boost::mpl::eval_if<
                         boost::has_range_iterator<PolylineRange>,
                         boost::range_value<PolylineRange>,
-                        boost::false_type
+                        std::false_type
                       >::type
                     >::value
                   >* = 0//end enable_if
@@ -1435,7 +1435,7 @@ bool do_intersect(const TriangleMesh& tm,
                         typename boost::mpl::eval_if<
                           boost::has_range_iterator<Polyline>,
                           boost::range_value<Polyline>,
-                          boost::false_type
+                          std::false_type
                         >::type
                       >::type // not a range of a range
                     >::value

STL_Extension/include/CGAL/is_convertible.h

@@ -17,7 +17,7 @@
 #ifndef CGAL_IS_CONVERTIBLE_H
 #define CGAL_IS_CONVERTIBLE_H
 
-#include <boost/type_traits/integral_constant.hpp>
+#include <type_traits>
 #ifdef CGAL_USE_GMPXX
 #include <gmpxx.h>
 #endif
@@ -30,7 +30,7 @@ template<class From,class To>struct is_implicit_convertible
 #ifdef CGAL_USE_GMPXX
 // Work around a gmpxx misfeature
 template<class T>struct is_implicit_convertible<__gmp_expr<mpq_t,T>,mpz_class>
-        : boost::false_type {};
+        : std::false_type {};
 #endif
 
 // TODO: add is_explicit_convertible (using boost::is_constructible?)