Merge branch 'master' into HEAD

AABB_tree/include/CGAL/AABB_tree/internal/AABB_ray_intersection.h

@@ -201,7 +201,7 @@ template<typename Ray, typename SkipFunctor>
 boost::optional< typename AABB_tree<AABBTraits>::template Intersection_and_primitive_id<Ray>::Type >
 AABB_tree<AABBTraits>::first_intersection(const Ray& query,
                                           const SkipFunctor& skip) const {
-  CGAL_static_assertion_msg((std::is_same<Ray, typename AABBTraits::Ray_3>::value),
+  static_assert(std::is_same<Ray, typename AABBTraits::Ray_3>::value,
                             "Ray and Ray_3 must be the same type");
 
   switch(size()) // copy-paste from AABB_tree::traversal

AABB_tree/test/AABB_tree/aabb_test_is_ray_intersection_geomtraits.cpp

@@ -26,16 +26,16 @@ int main()
 {
   using namespace CGAL::internal::AABB_tree;
 
-  CGAL_static_assertion_msg(
+  static_assert(
     (Is_ray_intersection_geomtraits<CGAL::Epeck>::value),
     "CGAL::Epeck should be a RayIntersectionGeomTraits");
-  CGAL_static_assertion_msg(
+  static_assert(
     (Is_ray_intersection_geomtraits< CGAL::Simple_cartesian<double> >::value),
     "CGAL::Epeck should be a RayIntersectionGeomTraits");
-  CGAL_static_assertion_msg(
+  static_assert(
     (!Is_ray_intersection_geomtraits<AABBGeomTraits>::value),
     "Pure AABBGeomTraits shouldn't be a RayIntersectionGeomTraits");
-  CGAL_static_assertion_msg(
+  static_assert(
     (!Is_ray_intersection_geomtraits<nope>::value),
     "The empty struct shouldn't be a RayIntersectionGeomTraits");
 

Algebraic_foundations/examples/Algebraic_foundations/fraction_traits.cpp

@@ -9,8 +9,8 @@ int main(){
     typedef FT::Numerator_type Numerator_type;
     typedef FT::Denominator_type Denominator_type;
 
-    CGAL_static_assertion((std::is_same<Numerator_type,CGAL::Gmpz>::value));
+    static_assert(std::is_same<Numerator_type,CGAL::Gmpz>::value);
-    CGAL_static_assertion((std::is_same<Denominator_type,CGAL::Gmpz>::value));
+    static_assert(std::is_same<Denominator_type,CGAL::Gmpz>::value);
 
     Numerator_type numerator;
     Denominator_type denominator;

Algebraic_foundations/examples/Algebraic_foundations/interoperable.cpp

@@ -9,7 +9,7 @@ binary_func(const A& a , const B& b){
     typedef CGAL::Coercion_traits<A,B> CT;
 
     // check for explicit interoperability
-    CGAL_static_assertion((CT::Are_explicit_interoperable::value));
+    static_assert(CT::Are_explicit_interoperable::value);
 
     // CT::Cast is used to to convert both types into the coercion type
     typename CT::Cast cast;

Algebraic_foundations/include/CGAL/Algebraic_structure_traits.h

@@ -353,8 +353,7 @@ class Algebraic_structure_traits_base< Type_,
             typedef Coercion_traits< NT1, NT2 > CT;
             typedef typename CT::Type Coercion_type_NT1_NT2;
             CGAL_USE_TYPE(Coercion_type_NT1_NT2);
-            CGAL_static_assertion((
+            static_assert(::std::is_same<Coercion_type_NT1_NT2 , Type >::value);
-              ::std::is_same<Coercion_type_NT1_NT2 , Type >::value));
 
             typename Coercion_traits< NT1, NT2 >::Cast cast;
             operator()( cast(x), cast(y), q, r );

Algebraic_foundations/include/CGAL/Coercion_traits.h

@@ -35,9 +35,9 @@
 #define CGAL_IMPLICIT_INTEROPERABLE_BINARY_OPERATOR_WITH_RT( NT, Result_type  ) \
   template < class CT_Type_1, class CT_Type_2 >                         \
   Result_type operator()( const CT_Type_1& x, const CT_Type_2& y ) const { \
-    CGAL_static_assertion((::std::is_same<                              \
+    static_assert(::std::is_same<                              \
             typename Coercion_traits< CT_Type_1, CT_Type_2 >::Type, NT  \
-            >::value));                                                 \
+            >::value) ;                                                 \
                                                                         \
     typename Coercion_traits< CT_Type_1, CT_Type_2 >::Cast cast;        \
     return operator()( cast(x), cast(y) );                              \

Algebraic_foundations/include/CGAL/Scalar_factor_traits.h

@@ -85,13 +85,13 @@ public:
 
         // determine extractable scalar factor
         Scalar operator () (const NT& a) {
-            CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
+            static_assert(::std::is_same< NT,Scalar >::value);
             typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
             return scalar_factor(a, SAT());
         }
         // determine extractable scalar factor
         Scalar operator () (const NT& a, const Scalar& d) {
-            CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
+            static_assert(::std::is_same< NT,Scalar >::value);
             typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
             return scalar_factor(a,d,SAT());
         }

Algebraic_foundations/include/CGAL/Test/_test_algebraic_structure.h

@@ -44,7 +44,7 @@
 template <typename AdaptableFunctor, typename ResultType>
 void check_result_type(AdaptableFunctor, ResultType){
   typedef typename AdaptableFunctor::result_type result_type;
-  CGAL_static_assertion((::std::is_same<result_type,ResultType>::value));
+  static_assert(::std::is_same<result_type,ResultType>::value);
   CGAL_USE_TYPE(result_type);
 }
 // check nothing for CGAL::Null_functor
@@ -122,12 +122,11 @@ void test_algebraic_structure_intern( const CGAL::Integral_domain_tag& ) {
     CGAL_SNAP_AST_FUNCTORS(AST);
 
     using CGAL::Null_functor;
-    CGAL_static_assertion(
+    static_assert(!::std::is_same< Integral_division, Null_functor >::value);
-        (!::std::is_same< Integral_division, Null_functor >::value));
+    static_assert(!::std::is_same< Divides, Null_functor >::value);
-    CGAL_static_assertion((!::std::is_same< Divides, Null_functor >::value));
+    static_assert(!::std::is_same< Is_zero, Null_functor >::value);
-    CGAL_static_assertion((!::std::is_same< Is_zero, Null_functor >::value));
+    static_assert(!::std::is_same< Is_one, Null_functor >::value);
-    CGAL_static_assertion((!::std::is_same< Is_one, Null_functor >::value));
+    static_assert(!::std::is_same< Square, Null_functor >::value);
-    CGAL_static_assertion((!::std::is_same< Square, Null_functor >::value));
 
     // functor
     const Is_zero is_zero = Is_zero();
@@ -206,7 +205,7 @@ void test_algebraic_structure_intern(
     CGAL_SNAP_AST_FUNCTORS(AST);
 
     using CGAL::Null_functor;
-    CGAL_static_assertion((!::std::is_same< Gcd, Null_functor>::value));
+    static_assert(!::std::is_same< Gcd, Null_functor>::value);
 
     const Gcd gcd = Gcd();
     assert( gcd(  AS ( 0), AS ( 0))  ==  unit_normal( AS (0) ) );
@@ -268,9 +267,9 @@ void test_algebraic_structure_intern( const CGAL::Euclidean_ring_tag&) {
     CGAL_SNAP_AST_FUNCTORS(AST);
 
     using CGAL::Null_functor;
-    CGAL_static_assertion((!::std::is_same< Div,     Null_functor>::value));
+    static_assert(!::std::is_same< Div,     Null_functor>::value);
-    CGAL_static_assertion((!::std::is_same< Mod,     Null_functor>::value));
+    static_assert(!::std::is_same< Mod,     Null_functor>::value);
-    CGAL_static_assertion((!::std::is_same< Div_mod, Null_functor>::value));
+    static_assert(!::std::is_same< Div_mod, Null_functor>::value);
 
     const Div     div=Div();
     const Mod     mod=Mod();
@@ -387,7 +386,7 @@ void test_algebraic_structure_intern( const CGAL::Field_with_sqrt_tag& ) {
 
     CGAL_SNAP_AST_FUNCTORS(AST);
 
-    CGAL_static_assertion((!::std::is_same< Sqrt, Null_functor>::value));
+    static_assert(!::std::is_same< Sqrt, Null_functor>::value);
     const Sqrt sqrt =Sqrt();
     AS  a(4);
 
@@ -613,11 +612,9 @@ class Test_is_square {
         CGAL_USE_TYPE(First_argument_type);
         CGAL_USE_TYPE(Second_argument_type);
 
-        CGAL_static_assertion(
+        static_assert(::std::is_same< AS , First_argument_type>::value);
-                ( ::std::is_same< AS , First_argument_type>::value));
+        static_assert(::std::is_same< AS& , Second_argument_type>::value);
-        CGAL_static_assertion(
+        //static_assert(::std::is_same< bool , Result_type>::value);
-                ( ::std::is_same< AS& , Second_argument_type>::value));
-        //CGAL_static_assertion(( ::std::is_same< bool , Result_type>::value));
         bool b = Result_type(true); CGAL_USE(b);
 
         AS test_number = AS(3)*AS(3);
@@ -649,8 +646,8 @@ public:
         typedef typename Sqrt::result_type   Result_type;
         CGAL_USE_TYPE(Argument_type);
         CGAL_USE_TYPE(Result_type);
-        CGAL_static_assertion(( ::std::is_same< AS , Argument_type>::value));
+        static_assert(::std::is_same< AS , Argument_type>::value);
-        CGAL_static_assertion(( ::std::is_same< AS , Result_type>::value));
+        static_assert(::std::is_same< AS , Result_type>::value);
         typedef Algebraic_structure_traits<AS> AST;
         typedef typename AST::Is_exact Is_exact;
         assert( !Is_exact::value ||  AS (3) == sqrt( AS (9)));
@@ -675,12 +672,9 @@ public:
         CGAL_USE_TYPE(First_argument_type);
         CGAL_USE_TYPE(Second_argument_type);
         CGAL_USE_TYPE(Result_type);
-        CGAL_static_assertion(
+        static_assert(::std::is_same<int, First_argument_type>::value);
-                ( ::std::is_same<int, First_argument_type>::value));
+        static_assert(::std::is_same< AS , Second_argument_type>::value);
-        CGAL_static_assertion(
+        static_assert(::std::is_same< AS , Result_type>::value);
-                ( ::std::is_same< AS , Second_argument_type>::value));
-        CGAL_static_assertion(
-                ( ::std::is_same< AS , Result_type>::value));
          AS  epsilon(1);
         assert( test_equality_epsilon(  AS (2),
                                 root( 4,  AS (16) ), epsilon ) );
@@ -803,7 +797,7 @@ void test_algebraic_structure(){
     typedef CGAL::Algebraic_structure_traits<  AS  > AST;
     CGAL_SNAP_AST_FUNCTORS(AST);
 
-    CGAL_static_assertion((::std::is_same<AS,typename AST::Type>::value));
+    static_assert(::std::is_same<AS,typename AST::Type>::value);
 
     typedef typename AST::Boolean Boolean;
     assert(!Boolean());
@@ -816,14 +810,13 @@ void test_algebraic_structure(){
     using CGAL::Integral_domain_without_division_tag;
     using CGAL::Null_functor;
     // Test for desired exactness
-    CGAL_static_assertion(
+    static_assert(::std::is_same< typename AST::Is_exact, Is_exact >::value);
-            ( ::std::is_same< typename AST::Is_exact, Is_exact >::value));
+    static_assert(::std::is_convertible< Tag,
+                    Integral_domain_without_division_tag >::value );
+    static_assert(::std::is_same< Tag, Algebraic_category>::value);
+    static_assert(!::std::is_same< Simplify, Null_functor>::value);
+    static_assert(!::std::is_same< Unit_part, Null_functor>::value);
 
-    CGAL_static_assertion(( ::std::is_convertible< Tag,
-                    Integral_domain_without_division_tag >::value ));
-    CGAL_static_assertion(( ::std::is_same< Tag, Algebraic_category>::value));
-    CGAL_static_assertion((!::std::is_same< Simplify, Null_functor>::value));
-    CGAL_static_assertion((!::std::is_same< Unit_part, Null_functor>::value));
     const Simplify   simplify=Simplify();;
     const Unit_part  unit_part= Unit_part();
 
@@ -943,8 +936,7 @@ void test_algebraic_structure( const  AS & a, const  AS & b, const  AS & c) {
 
     typedef CGAL::Algebraic_structure_traits<AS> AST;
     typedef typename AST::Is_numerical_sensitive Is_numerical_sensitive;
-    CGAL_static_assertion(
+    static_assert(!::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value);
-            !(::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
     CGAL_USE_TYPE(Is_numerical_sensitive);
 }
 

Algebraic_foundations/include/CGAL/Test/_test_coercion_traits.h

@@ -326,7 +326,7 @@ void test_implicit_interoperable_one_way() {
   typedef typename CT::Type C;
   typedef typename CT::Are_implicit_interoperable Are_implicit_interoperable;
 
-  CGAL_static_assertion(
+  static_assert(
       (::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
   assert((::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
 
@@ -346,9 +346,9 @@ void test_explicit_interoperable_one_way(){
   typedef typename CT::Cast Cast;
   typedef typename Cast::result_type result_type;
   CGAL_USE_TYPE(result_type);
-  CGAL_static_assertion((::std::is_same<result_type,Type>::value));
+  static_assert(::std::is_same<result_type,Type>::value);
-  CGAL_static_assertion((::std::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
+  static_assert(::std::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
-  CGAL_static_assertion((::std::is_same<Type,RT>::value));
+  static_assert(::std::is_same<Type,RT>::value);
   typename CT::Cast cast;
 
   A a(3);

Algebraic_foundations/include/CGAL/Test/_test_fraction_traits.h

@@ -37,11 +37,11 @@ void test_fraction_traits(){
     typedef typename FT::Compose   Compose;
 
     CGAL_USE_TYPE(Is_fraction);
-    CGAL_static_assertion( (::std::is_same<Type,T>::value));
+    static_assert(::std::is_same<Type,T>::value);
-    CGAL_static_assertion( (::std::is_same<Is_fraction,Tag_true>::value));
+    static_assert(::std::is_same<Is_fraction,Tag_true>::value);
-    CGAL_static_assertion(!(::std::is_same<Common_factor,Null_functor>::value));
+    static_assert(!::std::is_same<Common_factor,Null_functor>::value);
-    CGAL_static_assertion(!(::std::is_same<Decompose,Null_functor>::value));
+    static_assert(!::std::is_same<Decompose,Null_functor>::value);
-    CGAL_static_assertion(!(::std::is_same<Compose,Null_functor>::value));
+    static_assert(!::std::is_same<Compose,Null_functor>::value);
 
 
     // Decompose

Algebraic_foundations/include/CGAL/Test/_test_rational_traits.h

@@ -29,7 +29,7 @@ void test_rational_traits(){
 
     typedef Rational_traits<Rational> Rational_traits;
     typedef typename Rational_traits::RT RT;
-    CGAL_static_assertion((::std::is_same<RT,RT>::value));
+    static_assert(::std::is_same<RT,RT>::value);
 
     assert( Rational_traits().numerator(x) == RT(7));
     assert( Rational_traits().denominator(x) == RT(2));

Algebraic_foundations/include/CGAL/Test/_test_real_embeddable.h

@@ -48,9 +48,9 @@ namespace CGAL {
         void operator() (const ToDouble& to_double) {
             typedef typename ToDouble::argument_type Argument_type;
             typedef typename ToDouble::result_type   Result_type;
-            CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
+            static_assert( ::std::is_same<Type, Argument_type>::value);
             CGAL_USE_TYPE(Argument_type);
-            CGAL_static_assertion(( ::std::is_same<double, Result_type>::value));
+            static_assert( ::std::is_same<double, Result_type>::value);
             CGAL_USE_TYPE(Result_type);
             assert(42.0 == to_double(Type(42)));
         }
@@ -71,9 +71,9 @@ namespace CGAL {
             typedef typename To_interval::argument_type Argument_type;
             typedef typename To_interval::result_type   Result_type;
             typedef std::pair<double,double>  Interval_type;
-            CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
+            static_assert( ::std::is_same<Type, Argument_type>::value);
             CGAL_USE_TYPE(Argument_type);
-            CGAL_static_assertion(( ::std::is_same<Interval_type, Result_type>::value));
+            static_assert( ::std::is_same<Interval_type, Result_type>::value);
             CGAL_USE_TYPE(Result_type); CGAL_USE_TYPE(Interval_type);
 
 //            assert(NiX::in(42.0,to_Interval(Type(42))));
@@ -139,7 +139,7 @@ void test_real_embeddable() {
     CGAL_SNAP_RET_FUNCTORS(RET);
     typedef typename RET::Is_real_embeddable Is_real_embeddable;
     using CGAL::Tag_true;
-    CGAL_static_assertion(( ::std::is_same< Is_real_embeddable, Tag_true>::value));
+    static_assert(::std::is_same< Is_real_embeddable, Tag_true>::value);
     CGAL_USE_TYPE(Is_real_embeddable);
 
     typedef typename RET::Boolean Boolean;
@@ -246,7 +246,7 @@ void test_not_real_embeddable() {
     typedef CGAL::Real_embeddable_traits<Type> RET;
     typedef typename RET::Is_real_embeddable Is_real_embeddable;
     using CGAL::Tag_false;
-    CGAL_static_assertion(( ::std::is_same< Is_real_embeddable, Tag_false>::value));
+    static_assert(::std::is_same< Is_real_embeddable, Tag_false>::value);
     CGAL_USE_TYPE(Is_real_embeddable);
 }
 
@@ -254,13 +254,13 @@ void test_not_real_embeddable() {
 //template <class Type, class CeilLog2Abs>
 //void test_rounded_log2_abs(Type zero, CGAL::Null_functor, CeilLog2Abs) {
 //    typedef CGAL::Null_functor Null_functor;
-//    CGAL_static_assertion(( ::std::is_same< CeilLog2Abs, Null_functor>::value));
+//    static_assert(::std::is_same< CeilLog2Abs, Null_functor>::value);
 //}
 //
 //template <class Type, class FloorLog2Abs, class CeilLog2Abs>
 //void test_rounded_log2_abs(Type zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
 //    typedef CGAL::Null_functor Null_functor;
-//    CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
+//    static_assert(!::std::is_same< CeilLog2Abs, Null_functor>::value);
 //
 //    assert( fl_log(Type( 7)) == 2 );
 //    assert( cl_log(Type( 7)) == 3 );

Algebraic_foundations/test/Algebraic_foundations/Algebraic_extension_traits.cpp

@@ -9,21 +9,21 @@ int main(){
 
         typedef AET::Type Type;
         CGAL_USE_TYPE(Type);
-        CGAL_static_assertion((::std::is_same<int,Type>::value));
+        static_assert(::std::is_same<int,Type>::value);
 
         typedef AET::Is_extended Is_extended;
         CGAL_USE_TYPE(Is_extended);
-        CGAL_static_assertion(
+        static_assert(
                 (::std::is_same<CGAL::Tag_false,Is_extended>::value));
 
         typedef AET::Normalization_factor Normalization_factor;
         {
             typedef Normalization_factor::argument_type argument_type;
             CGAL_USE_TYPE(argument_type);
-            CGAL_static_assertion((::std::is_same<argument_type,int>::value));
+            static_assert(::std::is_same<argument_type,int>::value);
             typedef Normalization_factor::result_type result_type;
             CGAL_USE_TYPE(result_type);
-            CGAL_static_assertion((::std::is_same<result_type,int>::value));
+            static_assert(::std::is_same<result_type,int>::value);
             Normalization_factor nfac;
             assert(nfac(3)==1);
         }
@@ -31,10 +31,10 @@ int main(){
         {
             typedef DFAI::argument_type argument_type;
             CGAL_USE_TYPE(argument_type);
-            CGAL_static_assertion((::std::is_same<argument_type,int>::value));
+            static_assert(::std::is_same<argument_type,int>::value);
             typedef DFAI::result_type result_type;
             CGAL_USE_TYPE(result_type);
-            CGAL_static_assertion((::std::is_same<result_type,int>::value));
+            static_assert(::std::is_same<result_type,int>::value);
             DFAI dfai;
             assert(dfai(3)==1);
         }
@@ -45,21 +45,21 @@ int main(){
 
         typedef AET::Type Type;
         CGAL_USE_TYPE(Type);
-        CGAL_static_assertion((::std::is_same<EXT,Type>::value));
+        static_assert(::std::is_same<EXT,Type>::value);
 
         typedef AET::Is_extended Is_extended;
         CGAL_USE_TYPE(Is_extended);
-        CGAL_static_assertion(
+        static_assert(
                 (::std::is_same<CGAL::Tag_true,Is_extended>::value));
 
         typedef AET::Normalization_factor Normalization_factor;
         {
             typedef Normalization_factor::argument_type argument_type;
             CGAL_USE_TYPE(argument_type);
-            CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
+            static_assert(::std::is_same<argument_type,EXT>::value);
             typedef Normalization_factor::result_type result_type;
             CGAL_USE_TYPE(result_type);
-            CGAL_static_assertion((::std::is_same<result_type,EXT>::value));
+            static_assert(::std::is_same<result_type,EXT>::value);
             Normalization_factor nfac;
             assert(nfac(EXT(3))==1);
             assert(nfac(EXT(3,0,5))==1);
@@ -69,10 +69,10 @@ int main(){
         {
             typedef DFAI::argument_type argument_type;
             CGAL_USE_TYPE(argument_type);
-            CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
+            static_assert(::std::is_same<argument_type,EXT>::value);
             typedef DFAI::result_type result_type;
             CGAL_USE_TYPE(result_type);
-            CGAL_static_assertion((::std::is_same<result_type,EXT>::value));
+            static_assert(::std::is_same<result_type,EXT>::value);
             DFAI dfai;
             assert(dfai(EXT(3))==1);
             assert(dfai(EXT(3,0,5))==1);

Algebraic_foundations/test/Algebraic_foundations/Algebraic_structure_traits.cpp

@@ -7,7 +7,7 @@
     {                                                                   \
         typedef AST::NAME NAME;                                         \
         CGAL_USE_TYPE(NAME);                                             \
-        CGAL_static_assertion(                                            \
+        static_assert(                                            \
                 (::std::is_same<CGAL::Null_functor,NAME>::value));    \
     }
 
@@ -16,19 +16,19 @@ int main(){
 
     typedef AST::Type Type;
     CGAL_USE_TYPE(Type);
-    CGAL_static_assertion((::std::is_same<void,Type>::value));
+    static_assert(::std::is_same<void,Type>::value);
 
     typedef AST::Algebraic_category Algebraic_category;
     CGAL_USE_TYPE(Algebraic_category);
-    CGAL_static_assertion(
+    static_assert(
         (::std::is_same<CGAL::Null_tag,Algebraic_category>::value));
 
     typedef AST::Is_exact Is_exact;
     CGAL_USE_TYPE(Is_exact);
-    CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_exact>::value));
+    static_assert(::std::is_same<CGAL::Null_tag,Is_exact>::value);
     typedef AST::Is_numerical_sensitive Is_sensitive;
     CGAL_USE_TYPE(Is_sensitive);
-    CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_sensitive>::value));
+    static_assert(::std::is_same<CGAL::Null_tag,Is_sensitive>::value);
 
     CGAL_IS_AST_NULL_FUNCTOR (  Simplify);
     CGAL_IS_AST_NULL_FUNCTOR (  Unit_part);

Algebraic_foundations/test/Algebraic_foundations/Coercion_traits.cpp

@@ -6,22 +6,17 @@ int main(){
     {
     typedef CGAL::Coercion_traits<int,int> CT;
     CGAL_USE_TYPE(CT);
-    CGAL_static_assertion(( std::is_same<CT::Type,int>::value));
+    static_assert( std::is_same<CT::Type,int>::value);
-    CGAL_static_assertion(
+    static_assert( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value);
-            ( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
+    static_assert( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
-    CGAL_static_assertion(
-            ( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
     assert( 5 == CT::Cast()(5));
     }
     {
     typedef CGAL::Coercion_traits<CGAL::Tag_true,CGAL::Tag_false> CT;
     CGAL_USE_TYPE(CT);
-//    CGAL_static_assertion(( std::is_same<CT::Type,CGAL::Null_type>::value));
+//    static_assert( std::is_same<CT::Type,CGAL::Null_type>::value);
-    CGAL_static_assertion(
+    static_assert(std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value);
-            ( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
+    static_assert(std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value);
-    CGAL_static_assertion(
+    static_assert(std::is_same<CT::Cast,CGAL::Null_functor>::value);
-            ( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
-    CGAL_static_assertion(
-            ( std::is_same<CT::Cast,CGAL::Null_functor>::value));
     }
 }

Algebraic_foundations/test/Algebraic_foundations/Real_embeddable_traits.cpp

@@ -7,7 +7,7 @@
     {                                                                   \
         typedef RET::NAME NAME;                                         \
         CGAL_USE_TYPE(NAME);                                            \
-        CGAL_static_assertion(                                            \
+        static_assert(                                            \
                 (::std::is_same<CGAL::Null_functor,NAME>::value));    \
     }
 
@@ -16,11 +16,11 @@ int main(){
 
     typedef RET::Type Type;
     CGAL_USE_TYPE(Type);
-    CGAL_static_assertion((::std::is_same<void,Type>::value));
+    static_assert(::std::is_same<void,Type>::value);
 
     typedef RET::Is_real_embeddable Is_real_embeddable;
     CGAL_USE_TYPE(Is_real_embeddable);
-    CGAL_static_assertion((::std::is_same<CGAL::Tag_false,Is_real_embeddable>::value));
+    static_assert(::std::is_same<CGAL::Tag_false,Is_real_embeddable>::value);
 
     CGAL_IS_RET_NULL_FUNCTOR(Abs);
     CGAL_IS_RET_NULL_FUNCTOR(Sgn);

Algebraic_foundations/test/Algebraic_foundations/Scalar_factor_traits.cpp

@@ -7,33 +7,31 @@
 int main(){
     typedef CGAL::Scalar_factor_traits<int> SFT;
     CGAL_USE_TYPE(SFT);
-    CGAL_static_assertion((::std::is_same<int, SFT::Type>::value));
+    static_assert(::std::is_same<int, SFT::Type>::value);
-    CGAL_static_assertion((::std::is_same<int, SFT::Scalar>::value));
+    static_assert(::std::is_same<int, SFT::Scalar>::value);
 
     typedef SFT::Scalar_factor Scalar_factor;
     {
         typedef Scalar_factor::result_type result_type;
         CGAL_USE_TYPE(result_type);
-        CGAL_static_assertion((::std::is_same<int, result_type>::value));
+        static_assert(::std::is_same<int, result_type>::value);
 
         typedef Scalar_factor::argument_type argument_type;
         CGAL_USE_TYPE(argument_type);
-        CGAL_static_assertion((::std::is_same<int, argument_type>::value));
+        static_assert(::std::is_same<int, argument_type>::value);
     }
     typedef SFT::Scalar_div Scalar_div;
     {
         typedef Scalar_div::result_type result_type;
         CGAL_USE_TYPE(result_type);
-        CGAL_static_assertion((::std::is_same<void, result_type>::value));
+        static_assert(::std::is_same<void, result_type>::value);
 
         typedef Scalar_div::first_argument_type first_argument_type;
         CGAL_USE_TYPE(first_argument_type);
-        CGAL_static_assertion(
+        static_assert(::std::is_same<int&, first_argument_type>::value);
-                (::std::is_same<int&, first_argument_type>::value));
         typedef Scalar_div::second_argument_type second_argument_type;
         CGAL_USE_TYPE(second_argument_type);
-        CGAL_static_assertion(
+        static_assert(::std::is_same<int, second_argument_type>::value);
-                (::std::is_same<int, second_argument_type>::value));
     }
 
     int i;

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Algebraic_curve_kernel_2.h

@@ -481,18 +481,18 @@ public:
       Curve_analysis_2 _construct_defining_polynomial_from(Bound b) const {
         typedef CGAL::Fraction_traits<Bound> FT;
         // We rely on the fact that the Bound is a fraction
-        CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
+        static_assert(::std::is_same<typename FT::Is_fraction,
-                                             CGAL::Tag_true>::value));
+                                             CGAL::Tag_true>::value);
         typedef typename FT::Numerator_type Numerator;
         typedef typename FT::Denominator_type Denominator;
         typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion;
-        CGAL_static_assertion((::std::is_same
+        static_assert(::std::is_same
                               <Coefficient,
-                                  typename Num_coercion::Type>::value));
+                                  typename Num_coercion::Type>::value);
         typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
-        CGAL_static_assertion((::std::is_same
+        static_assert(::std::is_same
                                <Coefficient,
-                                typename Denom_coercion::Type>::value));
+                                typename Denom_coercion::Type>::value);
         typename Num_coercion::Cast num_cast;
         typename Denom_coercion::Cast denom_cast;
         typename FT::Decompose decompose;
@@ -2541,18 +2541,18 @@ public:
       Polynomial_1 operator() (const Polynomial_2& f, Bound b) const {
         typedef CGAL::Fraction_traits<Bound> FT;
         // We rely on the fact that the Bound is a fraction
-        CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
+        static_assert(::std::is_same<typename FT::Is_fraction,
-                                             CGAL::Tag_true>::value));
+                                             CGAL::Tag_true>::value);
         typedef typename FT::Numerator_type Numerator;
         typedef typename FT::Denominator_type Denominator;
         typedef CGAL::Coercion_traits<Numerator,Coefficient> Num_coercion;
-        CGAL_static_assertion((::std::is_same
+        static_assert(::std::is_same
                               <Coefficient,
-                                  typename Num_coercion::Type>::value));
+                                  typename Num_coercion::Type>::value);
         typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
-        CGAL_static_assertion((::std::is_same
+        static_assert(::std::is_same
                                <Coefficient,
-                                typename Denom_coercion::Type>::value));
+                                typename Denom_coercion::Type>::value);
         typename Num_coercion::Cast num_cast;
         typename Denom_coercion::Cast denom_cast;
         typename FT::Decompose decompose;

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Algebraic_real_d_1.h

@@ -71,7 +71,7 @@ class Algebraic_real_d_1 :
     public ::CGAL::Handle_with_policy< AlgebraicRealRep_d_1, HandlePolicy > {
 
   // currently Rational is the only supported Bound type.
-  CGAL_static_assertion(
+  static_assert(
       (   ::std::is_same <Rational_,
           typename Get_arithmetic_kernel<Coefficient_>::Arithmetic_kernel::Rational>::value));
 

Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/algebraic_curve_kernel_2_tools.h

@@ -186,7 +186,7 @@ template<typename AlgebraicKernel_1,
                                           InputIterator start,
                                           InputIterator end,
                                           OutputIterator output) {
-    CGAL_static_assertion
+    static_assert
       ((::std::is_same
         <typename AlgebraicKernel_1::Algebraic_real_1,
         typename std::iterator_traits<InputIterator>::value_type >::value));
@@ -224,14 +224,14 @@ template<typename Poly_coer_1,typename Polynomial_1>
   void cast_back_utcf(const Poly_coer_1& p,Polynomial_1& q) {
   // We can assume that both template arguments are polynomial types
   typedef CGAL::Fraction_traits<Poly_coer_1> FT;
-  CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
+  static_assert(::std::is_same<typename FT::Is_fraction,
-                       CGAL::Tag_true>::value));
+                       CGAL::Tag_true>::value);
   typedef typename FT::Numerator_type Numerator;
   typedef typename FT::Denominator_type Denominator;
   typedef CGAL::Coercion_traits<Numerator,Polynomial_1> Num_coercion;
-  CGAL_static_assertion((::std::is_same
+  static_assert(::std::is_same
                        <Polynomial_1,
-                       typename Num_coercion::Type>::value));
+                       typename Num_coercion::Type>::value);
   Numerator p_num;
   Denominator p_denom;
   typename FT::Decompose()(p,p_num,p_denom);

Algebraic_kernel_d/test/Algebraic_kernel_d/Real_embeddable_traits_extension.cpp

@@ -47,8 +47,8 @@ void test_real_embeddable_extension(const NT_&){
     typedef typename Floor::result_type   Result_type;
     CGAL_USE_TYPE(Argument_type);
     CGAL_USE_TYPE(Result_type);
-    CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
+    static_assert(::std::is_same<NT, Argument_type>::value);
-    CGAL_static_assertion(( ::std::is_same<Integer, Result_type>::value));
+    static_assert(::std::is_same<Integer, Result_type>::value);
     assert(Integer(42) == floor(NT(42)));
     assert(Integer(-42) == floor(NT(-42)));
   }
@@ -59,8 +59,8 @@ void test_real_embeddable_extension(const NT_&){
     typedef typename Floor_log2_abs::result_type   Result_type;
     CGAL_USE_TYPE(Argument_type);
     CGAL_USE_TYPE(Result_type);
-    CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
+    static_assert(::std::is_same<NT, Argument_type>::value);
-    CGAL_static_assertion(( ::std::is_same<long, Result_type>::value));
+    static_assert(::std::is_same<long, Result_type>::value);
 
     assert(long(0) == floor_log2_abs(NT(1)));
     assert(long(0) == floor_log2_abs(NT(-1)));
@@ -86,8 +86,8 @@ void test_real_embeddable_extension(const NT_&){
     typedef typename Ceil::result_type   Result_type;
     CGAL_USE_TYPE(Argument_type);
     CGAL_USE_TYPE(Result_type);
-    CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
+    static_assert(::std::is_same<NT, Argument_type>::value);
-    CGAL_static_assertion(( ::std::is_same<Integer, Result_type>::value));
+    static_assert(::std::is_same<Integer, Result_type>::value);
     assert(Integer(42) == ceil(NT(42)));
     assert(Integer(-42) == ceil(NT(-42)));
   }
@@ -98,8 +98,8 @@ void test_real_embeddable_extension(const NT_&){
     typedef typename Ceil_log2_abs::result_type   Result_type;
     CGAL_USE_TYPE(Argument_type);
     CGAL_USE_TYPE(Result_type);
-    CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
+    static_assert(::std::is_same<NT, Argument_type>::value);
-    CGAL_static_assertion(( ::std::is_same<long, Result_type>::value));
+    static_assert(::std::is_same<long, Result_type>::value);
 
     assert(long(0) == ceil_log2_abs(NT(1)));
     assert(long(0) == ceil_log2_abs(NT(-1)));

Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_curve_kernel_2.h

@@ -62,20 +62,20 @@ void test_algebraic_curve_kernel_2() {
 
     typedef AlgebraicCurveKernel_2 AK_2;
 
-  /*  CGAL_static_assertion( (::std::is_same<
+  /*  static_assert(::std::is_same<
-            Algebraic_real_1, typename AK::Algebraic_real_1 >::value) );
+            Algebraic_real_1, typename AK::Algebraic_real_1 >::value);
 
-    CGAL_static_assertion((::std::is_same<
+    static_assert(::std::is_same<
             Isolator,
-            typename AK::Isolator >::value) );
+            typename AK::Isolator >::value);
 
-    CGAL_static_assertion((::std::is_same<
+    static_assert(::std::is_same<
             Coefficient,
-            typename AK::Coefficient >::value));
+            typename AK::Coefficient >::value);
 
-    CGAL_static_assertion((::std::is_same<
+    static_assert(::std::is_same<
             Polynomial_1,
-            typename AK::Polynomial_1 >::value));*/
+            typename AK::Polynomial_1 >::value);*/
 
     typedef typename AK_2::Polynomial_2 Poly_2;
     typedef typename AK_2::Curve_analysis_2 Curve_analysis_2;

Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_1.h

@@ -109,8 +109,8 @@ void test_algebraic_kernel_1(const AlgebraicKernel_d_1& ak_1){
     typedef typename Name::result_type   RT_;                     \
     CGAL_USE_TYPE(AT_);                                           \
     CGAL_USE_TYPE(RT_);                                           \
-    {CGAL_static_assertion(( ::std::is_same<AT,AT_>::value));}  \
+    {static_assert(::std::is_same<AT,AT_>::value);}  \
-    {CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));}  \
+    {static_assert(::std::is_same<RT,RT_>::value);}  \
   }
 #define CGAL_CHECK_BFUNCTION(Name,AT1,AT2,RT)                           \
   {                                                                     \
@@ -120,9 +120,9 @@ void test_algebraic_kernel_1(const AlgebraicKernel_d_1& ak_1){
     CGAL_USE_TYPE(AT1_);                                                \
     CGAL_USE_TYPE(AT2_);                                                \
     CGAL_USE_TYPE(RT_);                                                 \
-    {CGAL_static_assertion(( ::std::is_same<AT1,AT1_>::value));}      \
+    {static_assert(::std::is_same<AT1,AT1_>::value);}      \
-    {CGAL_static_assertion(( ::std::is_same<AT2,AT2_>::value));}      \
+    {static_assert(::std::is_same<AT2,AT2_>::value);}      \
-    {CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));}        \
+    {static_assert(::std::is_same<RT,RT_>::value);}        \
   }
 
   // TODO: missing check for Construct_algebraic_real_1

Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_2.h

@@ -93,8 +93,8 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
     typedef typename Name::result_type   RT_;                   \
     CGAL_USE_TYPE(AT_);                                           \
     CGAL_USE_TYPE(RT_);                                           \
-    {CGAL_static_assertion(( ::std::is_same<AT,AT_>::value));}  \
+    {static_assert(::std::is_same<AT,AT_>::value);}  \
-    {CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));}  \
+    {static_assert(::std::is_same<RT,RT_>::value);}  \
   }
   #define CGAL_CHECK_BFUNCTION(Name,AT1,AT2,RT)                           \
   {                                                                     \
@@ -104,22 +104,22 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
     CGAL_USE_TYPE(AT1_);                                                 \
     CGAL_USE_TYPE(AT2_);                                                \
     CGAL_USE_TYPE(RT_);                                                 \
-    {CGAL_static_assertion(( ::std::is_same<AT1,AT1_>::value));}        \
+    {static_assert(::std::is_same<AT1,AT1_>::value);}        \
-    {CGAL_static_assertion(( ::std::is_same<AT2,AT2_>::value));}        \
+    {static_assert(::std::is_same<AT2,AT2_>::value);}        \
-    {CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));}          \
+    {static_assert(::std::is_same<RT,RT_>::value);}          \
   }
 
 
-  CGAL_static_assertion(( ::std::is_same
+  static_assert(::std::is_same
                          <Algebraic_real_2,
                          typename Construct_algebraic_real_2::result_type>
-                           ::value));
+                           ::value);
   CGAL_CHECK_UFUNCTION(Is_square_free_2,Polynomial_2,bool);
   CGAL_CHECK_UFUNCTION(Make_square_free_2,Polynomial_2,Polynomial_2);
   // TODO: missing check for Square_free_factorize_2
   CGAL_CHECK_BFUNCTION(Is_coprime_2,Polynomial_2,Polynomial_2,bool);
-  CGAL_static_assertion(( ::std::is_same
+  static_assert(::std::is_same
-                         <bool,typename Make_coprime_2::result_type>::value));
+                         <bool,typename Make_coprime_2::result_type>::value);
   CGAL_CHECK_BFUNCTION(Number_of_solutions_2,Polynomial_2,Polynomial_2,
                        size_type);
   CGAL_CHECK_UFUNCTION(Compute_x_2,Algebraic_real_2,Algebraic_real_1);
@@ -128,8 +128,8 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
   CGAL_CHECK_UFUNCTION(Compute_polynomial_y_2,Algebraic_real_2,Polynomial_1);
   CGAL_CHECK_BFUNCTION(Isolate_x_2,Algebraic_real_2,Polynomial_1,BInterval);
   CGAL_CHECK_BFUNCTION(Isolate_y_2,Algebraic_real_2,Polynomial_1,BInterval);
-  CGAL_static_assertion(( ::std::is_same
+  static_assert(::std::is_same
-                         < BArray,typename Isolate_2::result_type>::value));
+                         < BArray,typename Isolate_2::result_type>::value);
   CGAL_CHECK_BFUNCTION(Sign_at_2,Polynomial_2,Algebraic_real_2,Sign);
   CGAL_CHECK_BFUNCTION(Is_zero_at_2,Polynomial_2,Algebraic_real_2,bool);
   CGAL_CHECK_BFUNCTION(Compare_x_2,Algebraic_real_2,Algebraic_real_2,Sign);

Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_real_comparable.h

@@ -39,8 +39,8 @@ namespace internal {
         void operator() (ToDouble to_double) {
             typedef typename ToDouble::argument_type Argument_type;
             typedef typename ToDouble::result_type   Result_type;
-            CGAL_static_assertion((::std::is_same<NT, Argument_type>::value));
+            static_assert(::std::is_same<NT, Argument_type>::value);
-            CGAL_static_assertion((::std::is_same<double, Result_type>::value));
+            static_assert(::std::is_same<double, Result_type>::value);
             assert(42.0 == to_double(NT(42)));
         }
     };
@@ -59,8 +59,8 @@ namespace internal {
         void operator() (ToInterval to_Interval) {
             typedef typename ToInterval::argument_type Argument_type;
             typedef typename ToInterval::result_type   Result_type;
-            CGAL_static_assertion((::std::is_same<NT, Argument_type>::value));
+            static_assert(::std::is_same<NT, Argument_type>::value);
-            CGAL_static_assertion((::std::is_same< typename Argument_type::Interval, Result_type>::value));
+            static_assert(::std::is_same< typename Argument_type::Interval, Result_type>::value);
 
             // TODO: NiX::in not available!?
             //assert(NiX::in(42.0,to_Interval(NT(42))));
@@ -99,7 +99,7 @@ void test_real_comparable() {
     typedef CGAL::Real_embeddable_traits<NT> Traits;
     typedef typename Traits::Is_real_embeddable Is_real_comparable;
     using ::CGAL::Tag_true;
-    CGAL_static_assertion((::std::is_same< Is_real_comparable, Tag_true>::value));
+    static_assert(::std::is_same< Is_real_comparable, Tag_true>::value);
     typename Traits::Compare compare;
     typename Traits::Sign    sign;
     typename Traits::Abs     abs;
@@ -168,20 +168,20 @@ void test_not_real_comparable() {
     typedef CGAL::Real_embeddable_traits<NT> Traits;
     typedef typename Traits::Is_real_embeddable Is_real_comparable;
     using ::CGAL::Tag_false;
-    CGAL_static_assertion((::std::is_same< Is_real_comparable, Tag_false>::value));
+    static_assert(::std::is_same< Is_real_comparable, Tag_false>::value);
 }
 
 
 template <class NT, class CeilLog2Abs>
 void test_rounded_log2_abs(NT zero, ::CGAL::Null_functor, CeilLog2Abs) {
     typedef ::CGAL::Null_functor Nulltype;
-    CGAL_static_assertion((::std::is_same< CeilLog2Abs, Nulltype>::value));
+    static_assert(::std::is_same< CeilLog2Abs, Nulltype>::value);
 }
 
 template <class NT, class FloorLog2Abs, class CeilLog2Abs>
 void test_rounded_log2_abs(NT zero, FloorLog2Abs fl_log, CeilLog2Abs cl_log) {
     typedef ::CGAL::Null_functor Null_functor;
-    CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
+    static_assert(!::std::is_same< CeilLog2Abs, Null_functor>::value);
 
     assert( fl_log(NT( 7)) == 2 );
     assert( cl_log(NT( 7)) == 3 );

Alpha_shapes_2/include/CGAL/Alpha_shape_2.h

@@ -61,7 +61,7 @@ public:
   // because the periodic triangulations' point() function returns a temporary
   // value while the lazy predicate evaluations that are used when the Exact tag
   // is set to true rely on a permanent and safe access to the points.
-  CGAL_static_assertion(
+  static_assert(
    (std::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
    (std::is_same<typename Dt::Periodic_tag, Tag_false>::value));
 
@@ -76,8 +76,8 @@ public:
   typedef Type_of_alpha               FT;
 
   // check that simplices are correctly instantiated
-  CGAL_static_assertion( (std::is_same<NT, typename Dt::Face::NT>::value) );
+  static_assert(std::is_same<NT, typename Dt::Face::NT>::value);
-  CGAL_static_assertion( (std::is_same<NT, typename Dt::Vertex::NT>::value) );
+  static_assert(std::is_same<NT, typename Dt::Vertex::NT>::value);
 
   typedef typename Dt::Point Point;
 

Alpha_shapes_2/include/CGAL/Alpha_shape_vertex_base_2.h

@@ -19,6 +19,7 @@
 #include <utility>
 #include <CGAL/Triangulation_vertex_base_2.h>
 #include <CGAL/Alpha_shapes_2/internal/Lazy_alpha_nt_2.h>
+#include <CGAL/Default.h>
 
 //-------------------------------------------------------------------
 namespace CGAL {

Alpha_shapes_2/include/CGAL/Alpha_shapes_2/internal/Lazy_alpha_nt_2.h

@@ -148,8 +148,8 @@ class Lazy_alpha_nt_2
   Approx_point to_approx(const Input_point& wp) const
   {
     // The traits class' Point_2 must be convertible using the Cartesian converter
-    CGAL_static_assertion((Is_traits_point_convertible_2<
+    static_assert(Is_traits_point_convertible_2<
-                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
+                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
 
     To_approx converter;
     return converter(wp);
@@ -158,8 +158,8 @@ class Lazy_alpha_nt_2
   Exact_point to_exact(const Input_point& wp) const
   {
     // The traits class' Point_2 must be convertible using the Cartesian converter
-    CGAL_static_assertion((Is_traits_point_convertible_2<
+    static_assert(Is_traits_point_convertible_2<
-                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
+                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
 
     To_exact converter;
     return converter(wp);

Alpha_shapes_3/include/CGAL/Alpha_shape_3.h

@@ -97,7 +97,7 @@ public:
   // because the periodic triangulations' point() function returns a temporary
   // value while the lazy predicate evaluations that are used when the Exact tag
   // is set to true rely on a permanent and safe access to the points.
-  CGAL_static_assertion(
+  static_assert(
    (std::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
    (std::is_same<typename Dt::Periodic_tag, Tag_false>::value));
 
@@ -108,8 +108,8 @@ public:
   typedef typename Gt::FT Coord_type;
 
   //checks whether tags are correctly set in Vertex and Cell classes
-  CGAL_static_assertion( (std::is_same<NT,typename Dt::Cell::NT>::value) );
+  static_assert(std::is_same<NT,typename Dt::Cell::NT>::value);
-  CGAL_static_assertion( (std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value) );
+  static_assert(std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value);
 
   typedef typename Dt::Point Point;
 

Alpha_shapes_3/include/CGAL/Alpha_shapes_3/internal/Lazy_alpha_nt_3.h

@@ -139,8 +139,8 @@ class Lazy_alpha_nt_3{
   Approx_point to_approx(const Input_point& wp) const
   {
     // The traits class' Point_3 must be convertible using the Cartesian converter
-    CGAL_static_assertion((Is_traits_point_convertible_3<
+    static_assert(Is_traits_point_convertible_3<
-                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
+                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
 
     To_approx converter;
     return converter(wp);
@@ -149,8 +149,8 @@ class Lazy_alpha_nt_3{
   Exact_point to_exact(const Input_point& wp) const
   {
     // The traits class' Point_3 must be convertible using the Cartesian converter
-    CGAL_static_assertion((Is_traits_point_convertible_3<
+    static_assert(Is_traits_point_convertible_3<
-                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
+                            Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
 
     To_exact converter;
     return converter(wp);

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h

@@ -193,7 +193,7 @@ public:
   {
     // Due to the Steiner point computation being a dichotomy, the algorithm is inherently inexact
     // and passing exact kernels is explicitly disabled to ensure no misunderstanding.
-    CGAL_static_assertion((std::is_floating_point<FT>::value));
+    static_assert(std::is_floating_point<FT>::value);
   }
 
 public:

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Triangle_mesh_oracle.h

@@ -146,7 +146,7 @@ public:
 
     VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
                                get_const_property_map(vertex_point, tmesh));
-    CGAL_static_assertion((std::is_same<typename boost::property_traits<VPM>::value_type, Point_3>::value));
+    static_assert(std::is_same<typename boost::property_traits<VPM>::value_type, Point_3>::value);
 
     Splitter_base::reserve(num_faces(tmesh));
 

Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Triangle_soup_oracle.h

@@ -143,7 +143,7 @@ public:
 #endif
 
     PPM pm = choose_parameter<PPM>(get_parameter(np, internal_np::point_map));
-    CGAL_static_assertion((std::is_same<typename boost::property_traits<PPM>::value_type, Point_3>::value));
+    static_assert(std::is_same<typename boost::property_traits<PPM>::value_type, Point_3>::value);
 
     Splitter_base::reserve(faces.size());
 

Arithmetic_kernel/test/Arithmetic_kernel/Get_arithmetic_kernel.cpp

@@ -18,17 +18,17 @@ int main() {
   {
     typedef CGAL::Get_arithmetic_kernel<Integer>::Arithmetic_kernel AK_;
     CGAL_USE_TYPE(AK_);
-    CGAL_static_assertion((std::is_same<AK,AK_>::value));
+    static_assert(std::is_same<AK,AK_>::value);
   }
   {
     typedef CGAL::Get_arithmetic_kernel<Rational>::Arithmetic_kernel AK_;
     CGAL_USE_TYPE(AK_);
-    CGAL_static_assertion((std::is_same<AK,AK_>::value));
+    static_assert(std::is_same<AK,AK_>::value);
   }
   {
     typedef CGAL::Get_arithmetic_kernel<BFI>::Arithmetic_kernel AK_;
     CGAL_USE_TYPE(AK_);
-    CGAL_static_assertion((std::is_same<AK,AK_>::value));
+    static_assert(std::is_same<AK,AK_>::value);
   }
   return 0;
 }

Arrangement_on_surface_2/include/CGAL/Arr_bounded_planar_topology_traits_2.h

@@ -90,10 +90,10 @@ public:
   typedef typename Gt_adaptor_2::Top_side_category    Top_side_category;
   typedef typename Gt_adaptor_2::Right_side_category  Right_side_category;
 
-  CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value));
+  static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value));
+  static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value));
+  static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value));
+  static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value);
   //@}
 
   /*! \struct

Arrangement_on_surface_2/include/CGAL/Arr_dcel_base.h

@@ -38,7 +38,7 @@ namespace CGAL {
 
 inline void* _clean_pointer(const void* p)
 {
-  CGAL_static_assertion(sizeof(void*) == sizeof(size_t));
+  static_assert(sizeof(void*) == sizeof(size_t));
   const size_t  mask = ~1;
   const size_t  val = (reinterpret_cast<size_t>(p) & mask);
 

Arrangement_on_surface_2/include/CGAL/Arr_overlay_2.h

@@ -172,14 +172,14 @@ overlay(const Arrangement_on_surface_2<GeometryTraitsA_2, TopologyTraitsA>& arr1
   typedef typename Agt2::Point_2                                A_point;
   typedef typename Bgt2::Point_2                                B_point;
   typedef typename Rgt2::Point_2                                Res_point;
-  CGAL_static_assertion((std::is_convertible<A_point, Res_point>::value));
+  static_assert(std::is_convertible<A_point, Res_point>::value);
-  CGAL_static_assertion((std::is_convertible<B_point, Res_point>::value));
+  static_assert(std::is_convertible<B_point, Res_point>::value);
 
   typedef typename Agt2::X_monotone_curve_2                     A_xcv;
   typedef typename Bgt2::X_monotone_curve_2                     B_xcv;
   typedef typename Rgt2::X_monotone_curve_2                     Res_xcv;
-  CGAL_static_assertion((std::is_convertible<A_xcv, Res_xcv>::value));
+  static_assert(std::is_convertible<A_xcv, Res_xcv>::value);
-  CGAL_static_assertion((std::is_convertible<B_xcv, Res_xcv>::value));
+  static_assert(std::is_convertible<B_xcv, Res_xcv>::value);
 
   typedef Arr_traits_basic_adaptor_2<Rgt2>              Gt_adaptor_2;
   typedef Arr_overlay_traits_2<Gt_adaptor_2, Arr_a, Arr_b>

Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Base_rational_arc_ds_1.h

@@ -62,9 +62,9 @@ public:
   typedef std::vector<std::pair<Algebraic_real_1, Multiplicity> >
                                                         Root_multiplicity_vector;
 
-  CGAL_static_assertion((std::is_same<Integer,Coefficient>::value));
+  static_assert(std::is_same<Integer,Coefficient>::value);
-  CGAL_static_assertion((std::is_same<Polynomial_1,
+  static_assert(std::is_same<Polynomial_1,
-                       typename FT_poly_rat_1::Numerator_type>::value));
+                       typename FT_poly_rat_1::Numerator_type>::value);
 
 public:
 

Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Rational_arc_d_1.h

@@ -100,9 +100,9 @@ public:
 
   typedef Algebraic_point_2                                 Point_2;
 
-  CGAL_static_assertion((std::is_same<Integer, Coefficient>::value));
+  static_assert(std::is_same<Integer, Coefficient>::value);
-  CGAL_static_assertion((std::is_same<Polynomial_1,
+  static_assert(std::is_same<Polynomial_1,
-                       typename FT_poly_rat_1::Numerator_type>::value));
+                       typename FT_poly_rat_1::Numerator_type>::value);
 
 public:
   const Rational_function& get_rational_function(const Polynomial_1& numerator,

Arrangement_on_surface_2/include/CGAL/Arr_spherical_topology_traits_2.h

@@ -91,14 +91,14 @@ public:
   typedef typename Gt_adaptor_2::Top_side_category    Top_side_category;
   typedef typename Gt_adaptor_2::Right_side_category  Right_side_category;
 
-  CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Left_side_category, Arr_identified_side_tag >::value));
+                         std::is_same< Left_side_category, Arr_identified_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Bottom_side_category, Arr_contracted_side_tag >::value));
+                         std::is_same< Bottom_side_category, Arr_contracted_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Top_side_category, Arr_contracted_side_tag >::value));
+                         std::is_same< Top_side_category, Arr_contracted_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Right_side_category, Arr_identified_side_tag >::value));
+                         std::is_same< Right_side_category, Arr_identified_side_tag >::value);
   //@}
 
   /*! \struct

Arrangement_on_surface_2/include/CGAL/Arr_unb_planar_topology_traits_2.h

@@ -87,14 +87,14 @@ public:
   typedef typename Gt_adaptor_2::Top_side_category    Top_side_category;
   typedef typename Gt_adaptor_2::Right_side_category  Right_side_category;
 
-  CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Left_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Left_side_category, Arr_open_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Bottom_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Bottom_side_category, Arr_open_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag>::value ||
+  static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag>::value ||
-                         std::is_same< Top_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Top_side_category, Arr_open_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Right_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Right_side_category, Arr_open_side_tag >::value);
   //@}
 
   /*! \struct

Arrangement_on_surface_2/include/CGAL/Arrangement_on_surface_2.h

@@ -77,10 +77,10 @@ public:
   typedef typename Traits_adaptor_2::Top_side_category    Top_side_category;
   typedef typename Traits_adaptor_2::Right_side_category  Right_side_category;
 
-  CGAL_static_assertion((Arr_sane_identified_tagging<Left_side_category,
+  static_assert(Arr_sane_identified_tagging<Left_side_category,
                         Bottom_side_category,
                         Top_side_category,
-                        Right_side_category>::value));
+                        Right_side_category>::value);
 
 public:
   typedef Arrangement_on_surface_2<Geometry_traits_2, Topology_traits>

Arrangement_on_surface_2/include/CGAL/Arrangement_zone_2.h

@@ -67,10 +67,10 @@ protected:
   typedef typename Traits_adaptor_2::Top_side_category    Top_side_category;
   typedef typename Traits_adaptor_2::Right_side_category  Right_side_category;
 
-  CGAL_static_assertion((Arr_sane_identified_tagging<Left_side_category,
+  static_assert(Arr_sane_identified_tagging<Left_side_category,
                                                     Bottom_side_category,
                                                     Top_side_category,
-                                                    Right_side_category>::value));
+                                                    Right_side_category>::value);
 
 public:
   typedef ZoneVisitor_                                   Visitor;

Arrangement_on_surface_2/test/Arrangement_on_surface_2/test_tags.cpp

@@ -272,38 +272,38 @@ int main ()
 
   assert(ident12() == false);
 
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same< CGAL::internal::Arr_complete_left_side_category< Traits5 >::Category,
        CGAL::Arr_oblivious_side_tag >::value)
   );
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same< CGAL::internal::Arr_complete_left_side_category< Traits1 >::Category,
        CGAL::Arr_open_side_tag >::value)
   );
 
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same<CGAL::internal::Arr_complete_bottom_side_category< Traits5 >::Category,
        CGAL::Arr_oblivious_side_tag >::value)
   );
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same<CGAL::internal::Arr_complete_bottom_side_category< Traits1 >::Category,
        CGAL::Arr_open_side_tag >::value)
   );
 
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same< CGAL::internal::Arr_complete_top_side_category< Traits5 >::Category,
        CGAL::Arr_oblivious_side_tag >::value)
   );
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same< CGAL::internal::Arr_complete_top_side_category< Traits1 >::Category,
        CGAL::Arr_open_side_tag >::value)
   );
 
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same< CGAL::internal::Arr_complete_right_side_category< Traits5 >::Category,
        CGAL::Arr_oblivious_side_tag >::value)
   );
-  CGAL_static_assertion(
+  static_assert(
       (std::is_same< CGAL::internal::Arr_complete_right_side_category< Traits1 >::Category,
        CGAL::Arr_open_side_tag >::value)
   );

BGL/include/CGAL/boost/graph/IO/Generic_facegraph_builder.h

@@ -49,10 +49,10 @@ public:
     typedef typename CGAL::GetVertexPointMap<Graph, NamedParameters>::type             VPM;
 
     // usually will be true, but might not be the case if using custom type points
-//    CGAL_static_assertion((std::is_same<typename Kernel::Point_3,
+//    static_assert(std::is_same<typename Kernel::Point_3,
-//                                        typename boost::property_traits<VPM>::value_type>::value));
+//                                        typename boost::property_traits<VPM>::value_type>::value);
-//    CGAL_static_assertion((std::is_same<typename Kernel::Point_3,
+//    static_assert(std::is_same<typename Kernel::Point_3,
-//                                        typename boost::range_value<Point_container>::type>::value));
+//                                        typename boost::range_value<Point_container>::type>::value);
 
     typedef typename internal_np::Lookup_named_param_def<
       internal_np::vertex_normal_map_t, NamedParameters,

BGL/include/CGAL/boost/graph/internal/Has_member_clear.h

@@ -29,7 +29,7 @@ public:
 };
 
 template<class T>
-CGAL_CPP17_INLINE constexpr bool Has_member_clear_v = Has_member_clear<T>::value;
+inline constexpr bool Has_member_clear_v = Has_member_clear<T>::value;
 
 }  // internal
 }  // cgal

BGL/test/BGL/test_Has_member_clear.cpp

@@ -19,13 +19,13 @@ struct with_clear_const {
 int main()
 {
   using namespace CGAL::internal;
-  CGAL_static_assertion(Has_member_clear<with_clear>::value);
+  static_assert(Has_member_clear<with_clear>::value);
 
-  CGAL_static_assertion(!Has_member_clear<wo_clear>::value);
+  static_assert(!Has_member_clear<wo_clear>::value);
 
-  CGAL_static_assertion(!Has_member_clear<with_clear_but_args>::value);
+  static_assert(!Has_member_clear<with_clear_but_args>::value);
 
-  CGAL_static_assertion(Has_member_clear<with_clear_const>::value);
+  static_assert(Has_member_clear<with_clear_const>::value);
 
   return 0;
 }

BGL/test/BGL/test_Has_member_id.cpp

@@ -28,17 +28,17 @@ int main()
 {
   using namespace CGAL::internal;
 
-  CGAL_static_assertion(!Has_member_id<StructNoId>::value);
+  static_assert(!Has_member_id<StructNoId>::value);
-  CGAL_static_assertion(Has_member_id<StructWithId>::value);
+  static_assert(Has_member_id<StructWithId>::value);
-  CGAL_static_assertion(!Has_member_id<Polyhedron::Face>::value);
+  static_assert(!Has_member_id<Polyhedron::Face>::value);
-  CGAL_static_assertion(Has_member_id<Polyhedron_with_ids::Facet>::value);
+  static_assert(Has_member_id<Polyhedron_with_ids::Facet>::value);
-  CGAL_static_assertion(Has_member_id<Polyhedron_with_ids::FBase>::value);
+  static_assert(Has_member_id<Polyhedron_with_ids::FBase>::value);
-  CGAL_static_assertion(
+  static_assert(
     (Has_member_id<Polyhedron_with_ids::Items::Face_wrapper<Polyhedron_with_ids::HDS, K>::Face>::value));
 
-  CGAL_static_assertion(!Has_member_id<CGAL::Triangulation_face_base_2<K> >::value);
+  static_assert(!Has_member_id<CGAL::Triangulation_face_base_2<K> >::value);
-  CGAL_static_assertion(Has_member_id<CGAL::Triangulation_vertex_base_with_id_2<K> >::value);
+  static_assert(Has_member_id<CGAL::Triangulation_vertex_base_with_id_2<K> >::value);
-  CGAL_static_assertion(Has_member_id<CGAL::Triangulation_face_base_with_id_2<K> >::value);
+  static_assert(Has_member_id<CGAL::Triangulation_face_base_with_id_2<K> >::value);
 
   return 0;
 }

BGL/test/BGL/test_Properties.cpp

@@ -98,7 +98,7 @@ void test_vertex_index_map_uniqueness(const Graph& g,
   typedef typename CGAL::GetInitializedVertexIndexMap<Graph, NamedParameters>::const_type CVIM;
 
   // in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
-  static_assert((std::is_same<VIM, CVIM>::value), "VIM, CVIM must be the same type");
+  static_assert(std::is_same<VIM, CVIM>::value, "VIM, CVIM must be the same type");
 
   VIM ivim = CGAL::get_initialized_vertex_index_map(g, np);
 
@@ -114,7 +114,7 @@ void test_halfedge_index_map_uniqueness(const Graph& g,
   typedef typename CGAL::GetInitializedHalfedgeIndexMap<Graph, NamedParameters>::const_type CHIM;
 
   // in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
-  static_assert((std::is_same<HIM, CHIM>::value), "HIM, CHIM must be the same type");
+  static_assert(std::is_same<HIM, CHIM>::value, "HIM, CHIM must be the same type");
 
   HIM ihim = CGAL::get_initialized_halfedge_index_map(g, np);
 
@@ -130,7 +130,7 @@ void test_edge_index_map_uniqueness(const Graph& g,
   typedef typename CGAL::GetInitializedEdgeIndexMap<Graph, NamedParameters>::const_type CEIM;
 
   // in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
-  static_assert((std::is_same<EIM, CEIM>::value), "EIM, CEIM must be the same type");
+  static_assert(std::is_same<EIM, CEIM>::value, "EIM, CEIM must be the same type");
 
   EIM ieim = CGAL::get_initialized_edge_index_map(g, np);
 
@@ -146,7 +146,7 @@ void test_face_index_map_uniqueness(const Graph& g,
   typedef typename CGAL::GetInitializedFaceIndexMap<Graph, NamedParameters>::const_type CFIM;
 
   // in the case where the map is passed by NP, its type doesn't depend on whether the mesh is const or not
-  static_assert((std::is_same<FIM, CFIM>::value), "FIM, CFIM must be the same type");
+  static_assert(std::is_same<FIM, CFIM>::value, "FIM, CFIM must be the same type");
 
   FIM ifim = CGAL::get_initialized_face_index_map(g, np);
 

Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_meta_traits.h

@@ -123,14 +123,14 @@ public:
   typedef typename Arr::Right_side_category     Right_side_category;
 
   // a side is either oblivious or open (unbounded)
-  CGAL_static_assertion((std::is_same<Left_side_category, Arr_oblivious_side_tag>::value ||
+  static_assert(std::is_same<Left_side_category, Arr_oblivious_side_tag>::value ||
-                         std::is_same<Left_side_category, Arr_open_side_tag>::value));
+                         std::is_same<Left_side_category, Arr_open_side_tag>::value);
-  CGAL_static_assertion((std::is_same<Bottom_side_category, Arr_oblivious_side_tag>::value ||
+  static_assert(std::is_same<Bottom_side_category, Arr_oblivious_side_tag>::value ||
-                         std::is_same<Bottom_side_category, Arr_open_side_tag>::value));
+                         std::is_same<Bottom_side_category, Arr_open_side_tag>::value);
-  CGAL_static_assertion((std::is_same<Top_side_category, Arr_oblivious_side_tag>::value ||
+  static_assert(std::is_same<Top_side_category, Arr_oblivious_side_tag>::value ||
-                         std::is_same<Top_side_category, Arr_open_side_tag>::value));
+                         std::is_same<Top_side_category, Arr_open_side_tag>::value);
-  CGAL_static_assertion((std::is_same<Right_side_category, Arr_oblivious_side_tag>::value ||
+  static_assert(std::is_same<Right_side_category, Arr_oblivious_side_tag>::value ||
-                         std::is_same<Right_side_category, Arr_open_side_tag>::value));
+                         std::is_same<Right_side_category, Arr_open_side_tag>::value);
 
   typedef typename Arr::Halfedge_handle         Halfedge_handle;
   typedef typename Arr::Vertex_handle           Vertex_handle;

Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_traits_decorator.h

@@ -53,14 +53,14 @@ public:
   typedef typename Base::Right_side_category       Right_side_category;
 
   // a side is either oblivious or open (unbounded)
-  CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Left_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Left_side_category, Arr_open_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Bottom_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Bottom_side_category, Arr_open_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Top_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Top_side_category, Arr_open_side_tag >::value);
-  CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
+  static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
-                         std::is_same< Right_side_category, Arr_open_side_tag >::value));
+                         std::is_same< Right_side_category, Arr_open_side_tag >::value);
 
   class Ex_point_2
   {

Box_intersection_d/include/CGAL/Box_intersection_d/segment_tree.h

@@ -326,7 +326,7 @@ public:
 };
 
 template <class T>
-CGAL_CPP17_INLINE constexpr bool Has_member_report_v = Has_member_report<T>::value;
+inline constexpr bool Has_member_report_v = Has_member_report<T>::value;
 
 template <typename Callback>
 inline

Box_intersection_d/include/CGAL/box_intersection_d.h

@@ -63,8 +63,8 @@ void box_intersection_segment_tree_d(
   const NT sup = Box_intersection_d::box_limits<NT>::sup();
 
 #ifndef CGAL_LINKED_WITH_TBB
-  CGAL_static_assertion_msg (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+  static_assert (!std::is_convertible<ConcurrencyTag, Parallel_tag>::value,
-                             "Parallel_tag is enabled but TBB is unavailable.");
+                 "Parallel_tag is enabled but TBB is unavailable.");
 #else // CGAL_LINKED_WITH_TBB
   if(std::is_convertible<ConcurrencyTag, Parallel_tag>::value)
   {

Box_intersection_d/test/Box_intersection_d/test_Has_member_report.cpp

@@ -18,8 +18,8 @@ struct With_report_as_a_template_member_function {
 
 int main() {
   using CGAL::Box_intersection_d::Has_member_report;
-  CGAL_static_assertion(!Has_member_report<S>::value);
+  static_assert(!Has_member_report<S>::value);
-  CGAL_static_assertion(Has_member_report<With_report>::value);
+  static_assert(Has_member_report<With_report>::value);
-  CGAL_static_assertion(Has_member_report<With_report_as_a_template_member_function>::value);
+  static_assert(Has_member_report<With_report_as_a_template_member_function>::value);
   return EXIT_SUCCESS;
 }

Circulator/include/CGAL/circulator.h

@@ -191,45 +191,45 @@ template <class C> inline
 void Assert_circulator( const C &) {
     typedef typename Circulator_traits<C>::category category;
     CGAL_USE_TYPE(category);
-    CGAL_static_assertion((std::is_convertible<category, Circulator_tag>::value));
+    static_assert(std::is_convertible<category, Circulator_tag>::value);
 }
 
 template <class I> inline
 void Assert_iterator( const I &) {
     typedef typename Circulator_traits<I>::category category;
     CGAL_USE_TYPE(category);
-    CGAL_static_assertion((std::is_convertible<category, Iterator_tag>::value));
+    static_assert(std::is_convertible<category, Iterator_tag>::value);
 }
 template <class I> inline
 void Assert_input_category( const I &/*i*/) {
     typedef typename std::iterator_traits<I>::iterator_category category;
     CGAL_USE_TYPE(category);
-    CGAL_static_assertion((std::is_convertible<category, std::input_iterator_tag>::value));
+    static_assert(std::is_convertible<category, std::input_iterator_tag>::value);
 }
 
 template <class I> inline
 void Assert_output_category( const I &/*i*/) {
   typedef typename std::iterator_traits<I>::iterator_category category;
   CGAL_USE_TYPE(category);
-  CGAL_static_assertion((std::is_convertible<category, std::output_iterator_tag>::value));
+  static_assert(std::is_convertible<category, std::output_iterator_tag>::value);
 }
 template <class IC> inline
 void Assert_forward_category( const IC &/*ic*/) {
   typedef typename std::iterator_traits<IC>::iterator_category category;
   CGAL_USE_TYPE(category);
-  CGAL_static_assertion((std::is_convertible<category, std::forward_iterator_tag>::value));
+  static_assert(std::is_convertible<category, std::forward_iterator_tag>::value);
 }
 template <class IC> inline
 void Assert_bidirectional_category( const IC &/*ic*/) {
   typedef typename std::iterator_traits<IC>::iterator_category category;
   CGAL_USE_TYPE(category);
-  CGAL_static_assertion((std::is_convertible<category, std::bidirectional_iterator_tag>::value));
+  static_assert(std::is_convertible<category, std::bidirectional_iterator_tag>::value);
 }
 template <class IC> inline
 void Assert_random_access_category( const IC &/*ic*/) {
   typedef typename std::iterator_traits<IC>::iterator_category category;
   CGAL_USE_TYPE(category);
-  CGAL_static_assertion((std::is_convertible<category, std::random_access_iterator_tag>::value));
+  static_assert(std::is_convertible<category, std::random_access_iterator_tag>::value);
 }
 // The assert at-least-category functions use the following
 // functions to resolve properly. Note the proper order of the

Classification/include/CGAL/Classification/ETHZ/internal/random-forest/forest.hpp

@@ -164,7 +164,7 @@ public:
           f (seed_start, sample_idxes, trees, samples, labels, params.n_in_bag_samples, split_generator);
 
 #ifndef CGAL_LINKED_WITH_TBB
-        CGAL_static_assertion_msg (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+        static_assert (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
                                    "Parallel_tag is enabled but TBB is unavailable.");
 #else
         if (std::is_convertible<ConcurrencyTag,Parallel_tag>::value)

Classification/include/CGAL/Classification/Local_eigen_analysis.h

@@ -265,7 +265,7 @@ public:
     out.m_content->mean_range = 0.;
 
 #ifndef CGAL_LINKED_WITH_TBB
-    CGAL_static_assertion_msg (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+    static_assert (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
                                "Parallel_tag is enabled but TBB is unavailable.");
 #else
     if (std::is_convertible<ConcurrencyTag,Parallel_tag>::value)
@@ -353,7 +353,7 @@ public:
     out.m_content->mean_range = 0.;
 
 #ifndef CGAL_LINKED_WITH_TBB
-    CGAL_static_assertion_msg (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+    static_assert (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
                                "Parallel_tag is enabled but TBB is unavailable.");
 #else
     if (std::is_convertible<ConcurrencyTag,Parallel_tag>::value)
@@ -431,7 +431,7 @@ public:
 
 
 #ifndef CGAL_LINKED_WITH_TBB
-    CGAL_static_assertion_msg (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+    static_assert (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
                                "Parallel_tag is enabled but TBB is unavailable.");
 #else
     if (std::is_convertible<ConcurrencyTag,Parallel_tag>::value)

Classification/include/CGAL/Classification/Sum_of_weighted_features_classifier.h

@@ -898,7 +898,7 @@ private:
       std::size_t gt = j;
 
 #ifndef CGAL_LINKED_WITH_TBB
-      CGAL_static_assertion_msg (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+      static_assert (!(std::is_convertible<ConcurrencyTag, Parallel_tag>::value),
                                  "Parallel_tag is enabled but TBB is unavailable.");
 #else
       if (std::is_convertible<ConcurrencyTag,Parallel_tag>::value)

Combinatorial_map/include/CGAL/Cell_iterators.h

@@ -82,8 +82,8 @@ namespace CGAL {
       Ite(amap, adart, amap.get_new_mark()),
       mcell_mark_number(amap.get_new_mark())
     {
-      CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
+      static_assert(std::is_same<typename Ite::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       CGAL_assertion(amap.is_whole_map_unmarked(mcell_mark_number));
 
       mark_cell<Map,i,dim>(amap, adart, mcell_mark_number);
@@ -196,8 +196,8 @@ namespace CGAL {
       Ite(amap, adart),
       mmark_number(amap.get_new_mark())
     {
-      CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
+      static_assert(std::is_same<typename Ite::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
       mark_cell<Map,i,dim>(amap, adart, mmark_number);
     }
@@ -303,8 +303,8 @@ namespace CGAL {
       Base(amap),
       mmark_number(amap.get_new_mark())
     {
-      CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
+      static_assert(std::is_same<typename Base::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
       mark_cell<Map,i,dim>(amap, (*this), mmark_number);
     }

Combinatorial_map/include/CGAL/Combinatorial_map.h

@@ -185,7 +185,7 @@ namespace CGAL {
      */
     Combinatorial_map_base()
     {
-      CGAL_static_assertion_msg(Helper::nb_attribs<=dimension+1,
+      static_assert(Helper::nb_attribs<=dimension+1,
                   "Too many attributes in the tuple Attributes_enabled");
       this->init_storage();
 
@@ -803,7 +803,7 @@ namespace CGAL {
     void restricted_set_dart_attribute(Dart_descriptor dh,
                                        typename Attribute_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "set_dart_attribute<i> called but i-attributes are disabled.");
 
       if ( this->template attribute<i>(dh)==ah ) return;
@@ -826,7 +826,7 @@ namespace CGAL {
     void set_dart_attribute(Dart_descriptor dh,
                             typename Attribute_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "set_dart_attribute<i> called but i-attributes are disabled.");
 
       if ( this->template attribute<i>(dh)==ah ) return;
@@ -1524,8 +1524,8 @@ namespace CGAL {
     template < class Ite >
     std::ostream& display_orbits(std::ostream & aos) const
     {
-      CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
+      static_assert(std::is_same<typename Ite::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       unsigned int nb = 0;
       size_type amark = get_new_mark();
       for ( typename Dart_range::const_iterator it1(darts().begin()),
@@ -1584,7 +1584,7 @@ namespace CGAL {
     template<unsigned int i, typename ...Args>
     typename Attribute_descriptor<i>::type create_attribute(const Args&... args)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "create_attribute<i> but i-attributes are disabled");
      typename Attribute_descriptor<i>::type res=
        std::get<Helper::template Dimension_index<i>::value>
@@ -1602,7 +1602,7 @@ namespace CGAL {
     template<unsigned int i>
     void erase_attribute(typename Attribute_descriptor<i>::type h)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "erase_attribute<i> but i-attributes are disabled");
       std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers).erase(h);
@@ -1612,7 +1612,7 @@ namespace CGAL {
     template<unsigned int i>
     bool is_attribute_used(typename Attribute_const_descriptor< i >::type ah) const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                                 "is_attribute_used<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers).is_used(ah);
@@ -1622,7 +1622,7 @@ namespace CGAL {
     template <unsigned int i>
     size_type number_of_attributes() const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "number_of_attributes<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers).size();
@@ -1636,8 +1636,8 @@ namespace CGAL {
     void set_attribute(Dart_descriptor dh,
                        typename Attribute_descriptor<i>::type ah)
     {
-      CGAL_static_assertion(i<=dimension);
+      static_assert(i<=dimension);
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "set_attribute<i> but i-attributes are disabled");
       for ( typename Dart_of_cell_range<i>::iterator it(*this, dh);
             it.cont(); ++it)
@@ -1651,7 +1651,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_range<i>::type & attributes()
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                                 "attributes<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers);
@@ -1660,7 +1660,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_const_range<i>::type & attributes() const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                                 "attributes<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers);
@@ -1673,7 +1673,7 @@ namespace CGAL {
                          typename Attribute_type<i>::type&)>&
     onsplit_functor()
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");
@@ -1689,7 +1689,7 @@ namespace CGAL {
                                typename Attribute_type<i>::type&)>&
     onsplit_functor() const
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");
@@ -1705,7 +1705,7 @@ namespace CGAL {
                                typename Attribute_type<i>::type&)>&
     onmerge_functor()
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");
@@ -1720,7 +1720,7 @@ namespace CGAL {
                                typename Attribute_type<i>::type&)>&
     onmerge_functor() const
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");

Combinatorial_map/include/CGAL/Combinatorial_map/internal/Combinatorial_map_group_functors.h

@@ -64,9 +64,9 @@ struct Group_nonvoid_attribute_functor_of_dart_run
                   typename CMap::Dart_descriptor dh1,
                   typename CMap::Dart_descriptor dh2)
   {
-    CGAL_static_assertion( 1<=i && i<=CMap::dimension );
+    static_assert( 1<=i && i<=CMap::dimension );
-    CGAL_static_assertion( i!=j && (i!=1 || j!=0) );
+    static_assert( i!=j && (i!=1 || j!=0) );
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "Group_attribute_functor_of_dart_run<i> but "
                               "i-attributes are disabled");
@@ -90,8 +90,8 @@ struct Group_nonvoid_attribute_functor_of_dart_run<CMap, 0, j, T>
                   typename CMap::Dart_descriptor dh1,
                   typename CMap::Dart_descriptor dh2)
   {
-    CGAL_static_assertion(j!=0 && j!=1);
+    static_assert(j!=0 && j!=1);
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<0>::value>=0,
                               "Group_attribute_functor_of_dart_run<0> but "
                               "0-attributes are disabled");
@@ -127,7 +127,7 @@ struct Group_nonvoid_attribute_functor_of_dart_run<CMap, 0, 0, T>
                   typename CMap::Dart_descriptor dh1,
                   typename CMap::Dart_descriptor dh2)
   {
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<0>::value>=0,
                               "Group_attribute_functor_of_dart_run<0> but "
                               "0-attributes are disabled");
@@ -152,7 +152,7 @@ struct Group_nonvoid_attribute_functor_of_dart_run<CMap, 0, 1, T>
                   typename CMap::Dart_descriptor dh1,
                   typename CMap::Dart_descriptor dh2)
   {
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<0>::value>=0,
                               "Group_attribute_functor_of_dart_run<0> but "
                               "0-attributes are disabled");
@@ -240,9 +240,9 @@ struct Group_nonvoid_attribute_functor_run
                   typename CMap::Dart_descriptor adart1,
                   typename CMap::Dart_descriptor adart2)
   {
-    CGAL_static_assertion( 1<=i && i<=CMap::dimension );
+    static_assert( 1<=i && i<=CMap::dimension );
-    CGAL_static_assertion( i!=j );
+    static_assert( i!=j );
-    CGAL_static_assertion_msg
+    static_assert
         ( CMap::Helper::template Dimension_index<i>::value>=0,
           "Group_attribute_functor_run<i> but i-attributes are disabled" );
     typename CMap::template Attribute_descriptor<i>::type
@@ -279,10 +279,10 @@ struct Group_nonvoid_attribute_functor_run<CMap, 0, j, T>
                    typename CMap::Dart_descriptor dh1,
                    typename CMap::Dart_descriptor dh2 )
   {
-    CGAL_static_assertion_msg
+    static_assert
         ( CMap::Helper::template Dimension_index<0>::value>=0,
           "Group_attribute_functor_run<0> but 0-attributes are disabled" );
-    CGAL_static_assertion(j!=0 && j!=1);
+    static_assert(j!=0 && j!=1);
 
     typename CMap::template Attribute_descriptor<0>::type
         a1=CMap::null_descriptor, a2=CMap::null_descriptor;
@@ -340,7 +340,7 @@ struct Group_nonvoid_attribute_functor_run<CMap, 0, 0, T>
                    typename CMap::Dart_descriptor dh1,
                    typename CMap::Dart_descriptor dh2 )
   {
-    CGAL_static_assertion_msg
+    static_assert
         ( CMap::Helper::template Dimension_index<0>::value>=0,
           "Group_attribute_functor_run<0> but 0-attributes are disabled" );
     typename CMap::Dart_descriptor od=amap.other_extremity(dh2);
@@ -377,7 +377,7 @@ struct Group_nonvoid_attribute_functor_run<CMap, 0, 1, T>
                    typename CMap::Dart_descriptor dh1,
                    typename CMap::Dart_descriptor dh2 )
   {
-    CGAL_static_assertion_msg
+    static_assert
         ( CMap::Helper::template Dimension_index<0>::value>=0,
           "Group_attribute_functor_run<0> but 0-attributes are disabled" );
     typename CMap::Dart_descriptor od =amap.other_extremity(dh1);
@@ -474,9 +474,9 @@ struct Degroup_nonvoid_attribute_functor_run
                   typename CMap::Dart_descriptor adart1,
                   typename CMap::Dart_descriptor adart2)
   {
-    CGAL_static_assertion( i<=CMap::dimension );
+    static_assert( i<=CMap::dimension );
-    CGAL_static_assertion( i!=j );
+    static_assert( i!=j );
-    CGAL_static_assertion_msg
+    static_assert
         ( CMap::Helper::template Dimension_index<i>::value>=0,
           "Degroup_attribute_functor_run<i> but i-attributes are disabled" );
 
@@ -549,7 +549,7 @@ void test_split_attribute_functor_one_dart
                         unsigned int, typename CMap::Hash_function> &
   found_attributes, typename CMap::size_type mark )
 {
-  CGAL_static_assertion_msg(CMap::Helper::template
+  static_assert(CMap::Helper::template
                             Dimension_index<i>::value>=0,
                             "Test_split_attribute_functor_one_dart<i> but "
                             "i-attributes are disabled");
@@ -615,9 +615,9 @@ struct Test_split_nonvoid_attribute_functor_run
                    &modified_darts,
                    typename CMap::size_type mark_modified_darts=CMap::INVALID_MARK)
   {
-    CGAL_static_assertion( 1<=i && i<=CMap::dimension );
+    static_assert( 1<=i && i<=CMap::dimension );
     CGAL_assertion( i!=j );
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "Test_split_attribute_functor_run<i> but "
                               "i-attributes are disabled");
@@ -658,9 +658,9 @@ struct Test_split_nonvoid_attribute_functor_run
                    &modified_darts2,
                    typename CMap::size_type mark_modified_darts=CMap::INVALID_MARK)
   {
-    CGAL_static_assertion( 1<=i && i<=CMap::dimension );
+    static_assert( 1<=i && i<=CMap::dimension );
     CGAL_assertion( i!=j );
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "Test_split_attribute_functor_run<i> but "
                               "i-attributes are disabled");
@@ -720,7 +720,7 @@ struct Test_split_nonvoid_attribute_functor_run<CMap, 0, j, T>
                    typename CMap::size_type mark_modified_darts=CMap::INVALID_MARK)
   {
     CGAL_assertion( j!=0 && j!=1 );
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<0>::value>=0,
                               "Test_split_attribute_functor_run<0> but "
                               "0-attributes are disabled");
@@ -772,7 +772,7 @@ struct Test_split_nonvoid_attribute_functor_run<CMap, 0, j, T>
                    typename CMap::size_type mark_modified_darts=CMap::INVALID_MARK)
   {
     CGAL_assertion( j!=0 && j!=1 );
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<0>::value>=0,
                               "Test_split_attribute_functor_run<0> but "
                               "0-attributes are disabled");
@@ -858,7 +858,7 @@ struct Test_split_nonvoid_attribute_functor_run<CMap, 0, 0, T>
                    &modified_darts2,
                    typename CMap::size_type mark_modified_darts=CMap::INVALID_MARK)
   {
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<0>::value>=0,
                               "Test_split_attribute_functor_run<0> but "
                               "0-attributes are disabled");

Combinatorial_map/include/CGAL/Combinatorial_map/internal/Combinatorial_map_internal_functors.h

@@ -220,7 +220,7 @@ struct Test_is_valid_attribute_functor
                   typename CMap::Dart_const_descriptor adart,
                   std::vector<size_type>& marks, bool& ares)
   {
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "Test_is_valid_attribute_functor<i> but "
                               " i-attributes are disabled");
@@ -304,7 +304,7 @@ struct Correct_invalid_attributes_functor
                   typename CMap::Dart_descriptor adart,
                   std::vector<size_type>& marks)
   {
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "Correct_invalid_attributes_functor<i> but "
                               " i-attributes are disabled");
@@ -362,7 +362,7 @@ struct Cleanup_useless_attributes
   template <unsigned int i>
   static void run(CMap& amap)
   {
-    CGAL_static_assertion_msg(CMap::Helper::template
+    static_assert(CMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "Cleanup_useless_attributes<i> but "
                               " i-attributes are disabled");
@@ -707,7 +707,7 @@ struct Test_is_same_attribute_point_functor
                   typename Map1::Dart_const_descriptor dh1,
                   typename Map2::Dart_const_descriptor dh2)
   {
-    CGAL_static_assertion( Withpoint1==true && Withpoint2==true );
+    static_assert( Withpoint1==true && Withpoint2==true );
     if (m1.template attribute<i>(dh1)==Map1::null_descriptor &&
         m2.template attribute<i>(dh2)==Map2::null_descriptor)
       return true;

Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h

@@ -34,8 +34,8 @@ namespace CGAL
                             typename Map::Dart_const_descriptor adart1,
                             typename Map::Dart_const_descriptor adart2)
   {
-    CGAL_static_assertion( (std::is_same<typename Iterator::Basic_iterator,
+    static_assert(std::is_same<typename Iterator::Basic_iterator,
-                                           Tag_false>::value) );
+                                           Tag_false>::value);
     bool found=false;
 
     for (Iterator it(amap, adart1); !found && it.cont(); ++it)
@@ -57,8 +57,8 @@ namespace CGAL
                              typename Map::Dart_const_descriptor adart,
                              typename Map::size_type amark)
   {
-    CGAL_static_assertion( (std::is_same<typename Iterator::Basic_iterator,
+    static_assert(std::is_same<typename Iterator::Basic_iterator,
-                                           Tag_false>::value) );
+                                           Tag_false>::value);
     bool res=true;
 
     for ( Iterator it(amap, adart); res && it.cont(); ++it )
@@ -98,8 +98,8 @@ namespace CGAL
                                      typename Map::Dart_const_descriptor adart,
                                      typename Map::size_type amark)
   {
-    CGAL_static_assertion( (std::is_same<typename Iterator::Basic_iterator,
+    static_assert(std::is_same<typename Iterator::Basic_iterator,
-                            Tag_true>::value) );
+                            Tag_true>::value);
     CGAL_assertion( (is_whole_orbit_unmarked<Map,
                      CMap_non_basic_iterator<Map,Iterator> >
                      (amap, adart, amark)) );
@@ -305,8 +305,8 @@ namespace CGAL
                                               typename Map::size_type amark,
                                               typename Map::size_type amark2=Map::INVALID_MARK)
   {
-    CGAL_static_assertion( (std::is_same<typename Iterator::Basic_iterator,
+    static_assert(std::is_same<typename Iterator::Basic_iterator,
-                            Tag_true>::value) );
+                            Tag_true>::value);
     CGAL_assertion( (is_whole_orbit_unmarked<Map,
                      CMap_non_basic_iterator<Map,Iterator> >
                      (amap, adart, amark)) );

Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h

@@ -305,8 +305,8 @@ namespace CGAL {
 
     typedef typename Map::size_type size_type;
 
-    CGAL_static_assertion( (Bi<=Map::dimension &&
+    static_assert(Bi<=Map::dimension &&
-                            std::is_same<Ite_has_stack,Tag_false>::value) );
+                            std::is_same<Ite_has_stack,Tag_false>::value);
 
   public:
     /// Main constructor.
@@ -493,8 +493,8 @@ namespace CGAL {
 
     typedef typename Map::size_type size_type;
 
-    CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
+    static_assert(std::is_same<typename Base::Basic_iterator,
-                            Tag_true>::value) );
+                            Tag_true>::value);
 
     /// Main constructor.
     CMap_non_basic_iterator(Map& amap, Dart_descriptor adart1):
@@ -579,8 +579,8 @@ namespace CGAL {
     /// True iff this iterator is basic
     typedef Tag_false Basic_iterator;
 
-    CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
+    static_assert(std::is_same<typename Base::Basic_iterator,
-                            Tag_true>::value) );
+                            Tag_true>::value);
 
     /// Main constructor.
     CMap_non_basic_iterator(Map& amap, Dart_descriptor adart):

Combinatorial_map/include/CGAL/Combinatorial_map_operations.h

@@ -77,7 +77,7 @@ namespace CGAL
     static size_t run(CMap& amap, typename CMap::Dart_descriptor adart,
                       bool update_attributes)
     {
-      CGAL_static_assertion ( 1<=i && i<CMap::dimension );
+      static_assert ( 1<=i && i<CMap::dimension );
       CGAL_assertion( (amap.template is_removable<i>(adart)) );
 
       size_t res = 0;
@@ -493,7 +493,7 @@ namespace CGAL
     static size_t run(CMap& amap, typename CMap::Dart_descriptor adart,
                       bool update_attributes)
     {
-      CGAL_static_assertion ( 2<=i && i<=CMap::dimension );
+      static_assert ( 2<=i && i<=CMap::dimension );
       CGAL_assertion( (amap.template is_contractible<i>(adart)) );
 
       size_t res = 0;

Combinatorial_map/include/CGAL/Combinatorial_map_storages.h

@@ -64,7 +64,7 @@ namespace CGAL {
     typedef typename Dart_container::size_type             size_type;
 
     typedef std::nullptr_t Null_descriptor_type;
-    CGAL_CPP17_INLINE static constexpr Null_descriptor_type null_descriptor=nullptr;
+    inline static constexpr Null_descriptor_type null_descriptor=nullptr;
 
     using Type_for_compact_container=void*;
 
@@ -107,7 +107,7 @@ namespace CGAL {
     template<int i>
     using Attribute_const_handle=Attribute_const_descriptor<i>;
 
-    CGAL_CPP17_INLINE static constexpr Null_descriptor_type null_handle=null_descriptor;
+    inline static constexpr Null_descriptor_type null_handle=null_descriptor;
 
     /// Number of marks
     static const size_type NB_MARKS = 32;
@@ -232,7 +232,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_descriptor<i>::type attribute(Dart_descriptor ADart)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (ADart->mattribute_descriptors);
@@ -241,7 +241,7 @@ namespace CGAL {
     typename Attribute_const_descriptor<i>::type
     attribute(Dart_const_descriptor ADart) const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (ADart->mattribute_descriptors);
@@ -252,7 +252,7 @@ namespace CGAL {
     typename Attribute_descriptor<i>::type copy_attribute
     (typename Attribute_const_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "copy_attribute<i> called but i-attributes are disabled.");
       typename Attribute_descriptor<i>::type res=
         std::get<Helper::template Dimension_index<i>::value>
@@ -467,16 +467,6 @@ namespace CGAL {
     typename Helper::Attribute_containers mattribute_containers;
   };
 
-#ifndef CGAL_CXX17
-  template<unsigned int d_, class Items_, class Alloc_>
-  constexpr typename Combinatorial_map_storage_1<d_, Items_, Alloc_>::Null_descriptor_type
-  Combinatorial_map_storage_1<d_, Items_, Alloc_>::null_descriptor;
-
-  template<unsigned int d_, class Items_, class Alloc_>
-  constexpr typename Combinatorial_map_storage_1<d_, Items_, Alloc_>::Null_descriptor_type
-  Combinatorial_map_storage_1<d_, Items_, Alloc_>::null_handle;
-#endif
-
 } // namespace CGAL
 
 #if defined(BOOST_GCC)

Combinatorial_map/include/CGAL/Combinatorial_map_storages_with_index.h

@@ -266,7 +266,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_descriptor<i>::type attribute(Dart_descriptor ADart)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (mdarts[ADart].mattribute_descriptors);
@@ -275,7 +275,7 @@ namespace CGAL {
     typename Attribute_const_descriptor<i>::type
     attribute(Dart_const_descriptor ADart) const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (mdarts[ADart].mattribute_descriptors);
@@ -286,7 +286,7 @@ namespace CGAL {
     typename Attribute_descriptor<i>::type copy_attribute
     (typename Attribute_const_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "copy_attribute<i> called but i-attributes are disabled.");
       // We need to do a reserve before the emplace in order to avoid a bug of
       // invalid reference when the container is reallocated.

Combinatorial_map/include/CGAL/Dart.h

@@ -226,7 +226,7 @@ namespace CGAL {
     template<int i>
     typename Attribute_descriptor<i>::type attribute()
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_descriptors);
@@ -234,7 +234,7 @@ namespace CGAL {
     template<int i>
     typename Attribute_const_descriptor<i>::type attribute() const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_descriptors);

Combinatorial_map/include/CGAL/Dart_iterators.h

@@ -295,13 +295,13 @@ namespace CGAL {
     /// Main constructor.
     CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_descriptor adart):
       Base(amap, adart)
-    { CGAL_static_assertion( Bi>=2 && Bi<=Map::dimension ); }
+    { static_assert( Bi>=2 && Bi<=Map::dimension ); }
 
     /// Main constructor.
     CMap_dart_iterator_basic_of_orbit_generic(Map& amap, Dart_descriptor adart,
                                               size_type /*amark*/):
       Base(amap, adart)
-    { CGAL_static_assertion( Bi>=2 && Bi<=Map::dimension ); }
+    { static_assert( Bi>=2 && Bi<=Map::dimension ); }
 
     /// Prefix ++ operator.
     Self& operator++()
@@ -346,7 +346,7 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
-    CGAL_static_assertion( Bi>1 && delta>1 && Bi+delta<=Map::dimension );
+    static_assert( Bi>1 && delta>1 && Bi+delta<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -460,7 +460,7 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
-    CGAL_static_assertion( 2<=Map::dimension );
+    static_assert( 2<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -493,7 +493,7 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
-    CGAL_static_assertion( 2<=Map::dimension );
+    static_assert( 2<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -524,7 +524,7 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
-    CGAL_static_assertion( delta>1 && delta<=Map::dimension );
+    static_assert( delta>1 && delta<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -625,7 +625,7 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
-    CGAL_static_assertion( delta>1 && delta+1<=Map::dimension );
+    static_assert( delta>1 && delta+1<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -726,7 +726,7 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;
 
-    CGAL_static_assertion( Bi>1 && Bi+1<=Map::dimension );
+    static_assert( Bi>1 && Bi+1<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -1026,7 +1026,7 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
-    CGAL_static_assertion( i>1 && i<=Map::dimension+1 );
+    static_assert( i>1 && i<=Map::dimension+1 );
 
   public:
     /// Main constructor.

Convex_hull_3/test/Convex_hull_3/quick_hull_default_traits.cpp

@@ -23,12 +23,12 @@ using namespace CGAL::Convex_hull_3::internal;
 
 int main()
 {
-  CGAL_static_assertion( (std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value) );
+  static_assert(std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value);
-  CGAL_static_assertion( (std::is_same<SCD,Default_traits_for_Chull_3<SCD::Point_3>::type>::value) );
+  static_assert(std::is_same<SCD,Default_traits_for_Chull_3<SCD::Point_3>::type>::value);
-  CGAL_static_assertion( (std::is_same<SHD,Default_traits_for_Chull_3<SHD::Point_3>::type>::value) );
+  static_assert(std::is_same<SHD,Default_traits_for_Chull_3<SHD::Point_3>::type>::value);
-  CGAL_static_assertion( (std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value) );
+  static_assert(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) );
+  static_assert(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) );
+  static_assert(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>, std::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value) );
+  static_assert(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;
 }

Documentation/doc/Documentation/Preliminaries.txt

@@ -39,10 +39,9 @@ If you are using CMake, then you can set the CMake option `CGAL_HAS_NO_THREADS`
 `TRUE`. In addition to defining the preprocessor macro `CGAL_HAS_NO_THREADS`, it will
 also avoid CMake to link with the native threads support library on your system.
 
-\section Preliminaries_cc0x C++14 Support
+\section Preliminaries_cc0x C++17 Support
 
-After being based on the \CC standard released in 1998 (and later refined in 2003) for a long time,
+\cgal is based on the version C++17 of the C++ standard.
-\cgal is now based on a newer major version of the standard, <a href="https://isocpp.org/wiki/faq/cpp14">C++14</a>.
 
 \section preliminaries_secchecks Checks
 

Documentation/doc/Documentation/Third_party.txt

@@ -6,7 +6,7 @@
 \section seccompilers Supported Compilers
 
 In order to build a program using \cgal, you need a \cpp compiler
-supporting <a href="https://isocpp.org/wiki/faq/cpp14">C++14</a> or later.
+supporting C++17 or later.
 \cgal \cgalReleaseNumber is supported (continuously tested) for the following compilers/operating systems:
 
 | Operating System | Compiler |
@@ -14,9 +14,9 @@ supporting <a href="https://isocpp.org/wiki/faq/cpp14">C++14</a> or later.
 | Linux            | \gnu `g++` 11.3.0 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
 |                  | `Clang` \cgalFootnote{<A HREF="https://clang.llvm.org/">\cgalFootnoteCode{https://clang.llvm.org/}</A>} compiler version 15.0.7 |
 | \ms Windows      | \gnu `g++` 10.2.1 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
-|                  | \ms Visual `C++` 14.0, 15.9, 16.10, 17.0 (\visualstudio 2015, 2017, 2019, and 2022)\cgalFootnote{<A HREF="https://visualstudio.microsoft.com/">\cgalFootnoteCode{https://visualstudio.microsoft.com/}</A>} |
+|                  | \ms Visual `C++` 15.9, 16.10, 17.0 (\visualstudio 2017, 2019, and 2022)\cgalFootnote{<A HREF="https://visualstudio.microsoft.com/">\cgalFootnoteCode{https://visualstudio.microsoft.com/}</A>} |
 | MacOS X          | \gnu `g++` 11.3.0 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
-|                  | Apple `Clang` compiler versions 10.0.1, and 12.0.5. |
+|                  | Apple `Clang` compiler versions 10.0.1, 12.0.5, and 13.0.0 |
 
 <!-- Windows supported version are also listed on windows.html (must change both) -->
 

Documentation/doc/Documentation/windows.txt

@@ -3,7 +3,7 @@
 \cgalAutoToc
 
 \cgal \cgalReleaseNumber is supported for the following \ms Visual `C++` compilers:
-14.0, 15.9, 16.0, 17.0 (\visualstudio 2015, 2017, 2019, and 2022).
+15.9, 16.0, 17.0 (\visualstudio 2017, 2019, and 2022).
 
 \cgal is a library that has mandatory dependencies that must be first installed:
 \ref thirdpartyBoost and \ref thirdpartyMPFR.

Generalized_map/include/CGAL/GMap_cell_iterators.h

@@ -70,8 +70,8 @@ namespace CGAL {
       Base(amap),
       mmark_number(amap.get_new_mark())
     {
-      CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
+      static_assert(std::is_same<typename Base::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
       mark_cell<Map,i,dim>(amap, (*this), mmark_number);
     }
@@ -183,8 +183,8 @@ namespace CGAL {
       Base(amap),
       mmark_number(amap.get_new_mark())
     {
-      CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
+      static_assert(std::is_same<typename Base::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
       mark_cell<Map,i,dim>(amap, (*this), mmark_number);
     }

Generalized_map/include/CGAL/GMap_dart_iterators.h

@@ -96,7 +96,7 @@ namespace CGAL {
 
     typedef Tag_false Use_mark;      ///< True iff this iterator uses mark
 
-    CGAL_static_assertion( Ai>=0 && Ai<=Map::dimension );
+    static_assert( Ai>=0 && Ai<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -154,7 +154,7 @@ namespace CGAL {
     typedef Tag_false Use_mark;      ///< True iff this iterator uses mark
     typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
 
-    CGAL_static_assertion( (0<=Ai && Ai+delta<=Map::dimension && delta>1) );
+    static_assert(0<=Ai && Ai+delta<=Map::dimension && delta>1);
 
   public:
     /// Main constructor.
@@ -269,7 +269,7 @@ namespace CGAL {
     typedef Tag_false Use_mark;      ///< True iff this iterator uses mark
     typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
 
-    CGAL_static_assertion(0<=Ai && Ai+1<=Map_::dimension);
+    static_assert(0<=Ai && Ai+1<=Map_::dimension);
 
   public:
     /// Main constructor.
@@ -468,9 +468,9 @@ namespace CGAL {
     typedef Tag_false Use_mark;      ///< True iff this iterator uses mark
     typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
 
-    CGAL_static_assertion( (0<=Ai && delta1<delta2 &&
+    static_assert(0<=Ai && delta1<delta2 &&
                             Ai+delta2<=Map::dimension &&
-                            delta1>1) );
+                            delta1>1);
 
   public:
     /// Main constructor.
@@ -508,7 +508,7 @@ namespace CGAL {
 
     typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
 
-    CGAL_static_assertion( Ai<Aj && Aj<Ak && Ak<=Map::dimension );
+    static_assert( Ai<Aj && Aj<Ak && Ak<=Map::dimension );
 
   public:
     /// Main constructor.
@@ -590,7 +590,7 @@ namespace CGAL {
     typedef Tag_true Use_mark; ///< True iff this iterator uses mark
     typedef Tag_true Basic_iterator; ///< True iff this iterator is basic
 
-    CGAL_static_assertion( i>=0 && i<=Map::dimension+1 );
+    static_assert( i>=0 && i<=Map::dimension+1 );
 
   public:
     /// Main constructor.

Generalized_map/include/CGAL/Generalized_map.h

@@ -161,7 +161,7 @@ namespace CGAL {
      */
     Generalized_map_base()
     {
-      CGAL_static_assertion_msg(Helper::nb_attribs<=dimension+1,
+      static_assert(Helper::nb_attribs<=dimension+1,
                   "Too many attributes in the tuple Attributes_enabled");
       this->init_storage();
 
@@ -689,7 +689,7 @@ namespace CGAL {
     void restricted_set_dart_attribute(Dart_descriptor dh,
                                        typename Attribute_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "set_dart_attribute<i> called but i-attributes are disabled.");
 
       if ( this->template attribute<i>(dh)==ah ) return;
@@ -712,7 +712,7 @@ namespace CGAL {
     void set_dart_attribute(Dart_descriptor dh,
                             typename Attribute_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "set_dart_attribute<i> called but i-attributes are disabled.");
 
       if ( this->template attribute<i>(dh)==ah ) return;
@@ -1347,8 +1347,8 @@ namespace CGAL {
     template < class Ite >
     std::ostream& display_orbits(std::ostream & aos) const
     {
-      CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
+      static_assert(std::is_same<typename Ite::Basic_iterator,
-                              Tag_true>::value) );
+                              Tag_true>::value);
       unsigned int nb = 0;
       size_type amark = get_new_mark();
       for ( typename Dart_range::const_iterator it1(darts().begin()),
@@ -1409,7 +1409,7 @@ namespace CGAL {
     template<unsigned int i, typename ...Args>
     typename Attribute_descriptor<i>::type create_attribute(const Args&... args)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "create_attribute<i> but i-attributes are disabled");
      typename Attribute_descriptor<i>::type res=
        std::get<Helper::template Dimension_index<i>::value>
@@ -1427,7 +1427,7 @@ namespace CGAL {
     template<unsigned int i>
     void erase_attribute(typename Attribute_descriptor<i>::type h)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "erase_attribute<i> but i-attributes are disabled");
       std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers).erase(h);
@@ -1437,7 +1437,7 @@ namespace CGAL {
     template<unsigned int i>
     bool is_attribute_used(typename Attribute_const_descriptor< i >::type ah) const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                                 "is_attribute_used<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers).is_used(ah);
@@ -1447,7 +1447,7 @@ namespace CGAL {
     template <unsigned int i>
     size_type number_of_attributes() const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "number_of_attributes<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers).size();
@@ -1461,8 +1461,8 @@ namespace CGAL {
     void set_attribute(Dart_descriptor dh,
                        typename Attribute_descriptor<i>::type ah)
     {
-      CGAL_static_assertion(i<=dimension);
+      static_assert(i<=dimension);
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                   "set_attribute<i> but i-attributes are disabled");
       for ( typename Dart_of_cell_range<i>::iterator it(*this, dh);
             it.cont(); ++it)
@@ -1476,7 +1476,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_range<i>::type & attributes()
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                                 "attributes<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers);
@@ -1485,7 +1485,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_const_range<i>::type & attributes() const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                                 "attributes<i> but i-attributes are disabled");
       return std::get<Helper::template Dimension_index<i>::value>
         (mattribute_containers);
@@ -1498,7 +1498,7 @@ namespace CGAL {
                          typename Attribute_type<i>::type&)>&
     onsplit_functor()
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");
@@ -1514,7 +1514,7 @@ namespace CGAL {
                                typename Attribute_type<i>::type&)>&
     onsplit_functor() const
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");
@@ -1530,7 +1530,7 @@ namespace CGAL {
                                typename Attribute_type<i>::type&)>&
     onmerge_functor()
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");
@@ -1545,7 +1545,7 @@ namespace CGAL {
                                typename Attribute_type<i>::type&)>&
     onmerge_functor() const
     {
-      CGAL_static_assertion_msg
+      static_assert
           (Helper::template Dimension_index<i>::value>=0,
            "onsplit_functor<i> but "
            "i-attributes are disabled");

Generalized_map/include/CGAL/Generalized_map/internal/Generalized_map_group_functors.h

@@ -65,9 +65,9 @@ struct GMap_group_attribute_functor_of_dart_run
                   typename GMap::Dart_descriptor dh1,
                   typename GMap::Dart_descriptor dh2)
   {
-    CGAL_static_assertion( i<=GMap::dimension );
+    static_assert( i<=GMap::dimension );
-    CGAL_static_assertion( i!=j );
+    static_assert( i!=j );
-    CGAL_static_assertion_msg(GMap::Helper::template
+    static_assert(GMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "GMap_group_attribute_functor_of_dart_run<i> but "
                               "i-attributes are disabled");
@@ -134,9 +134,9 @@ struct GMap_group_attribute_functor_run
                   typename GMap::Dart_descriptor adart1,
                   typename GMap::Dart_descriptor adart2)
   {
-    CGAL_static_assertion( i<=GMap::dimension );
+    static_assert( i<=GMap::dimension );
-    CGAL_static_assertion( i!=j );
+    static_assert( i!=j );
-    CGAL_static_assertion_msg
+    static_assert
         ( GMap::Helper::template Dimension_index<i>::value>=0,
           "GMap_group_attribute_functor_run<i> but i-attributes are disabled" );
     typename GMap::template Attribute_descriptor<i>::type
@@ -212,9 +212,9 @@ struct GMap_degroup_attribute_functor_run
                   typename GMap::Dart_descriptor adart1,
                   typename GMap::Dart_descriptor adart2)
   {
-    CGAL_static_assertion( i<=GMap::dimension );
+    static_assert( i<=GMap::dimension );
-    CGAL_static_assertion( i!=j );
+    static_assert( i!=j );
-    CGAL_static_assertion_msg
+    static_assert
         ( GMap::Helper::template Dimension_index<i>::value>=0,
           "GMap_degroup_attribute_functor_run<i> but i-attributes are disabled" );
 
@@ -276,7 +276,7 @@ void GMap_test_split_attribute_functor_one_dart
                         unsigned int, typename GMap::Hash_function> &
   found_attributes, typename GMap::size_type mark )
 {
-  CGAL_static_assertion_msg(GMap::Helper::template
+  static_assert(GMap::Helper::template
                             Dimension_index<i>::value>=0,
                             "GMap_test_split_attribute_functor_one_dart<i> but "
                             "i-attributes are disabled");
@@ -340,9 +340,9 @@ struct GMap_test_split_attribute_functor_run
                    &modified_darts,
                    typename GMap::size_type mark_modified_darts=GMap::INVALID_MARK)
   {
-    CGAL_static_assertion( i<=GMap::dimension );
+    static_assert( i<=GMap::dimension );
     CGAL_assertion( i!=j );
-    CGAL_static_assertion_msg(GMap::Helper::template
+    static_assert(GMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "GMap_test_split_attribute_functor_run<i> but "
                               "i-attributes are disabled");
@@ -383,9 +383,9 @@ struct GMap_test_split_attribute_functor_run
                    &modified_darts2,
                    typename GMap::size_type mark_modified_darts=GMap::INVALID_MARK)
   {
-    CGAL_static_assertion( i<=GMap::dimension );
+    static_assert( i<=GMap::dimension );
     CGAL_assertion( i!=j );
-    CGAL_static_assertion_msg(GMap::Helper::template
+    static_assert(GMap::Helper::template
                               Dimension_index<i>::value>=0,
                               "GMap_test_split_attribute_functor_run<i> but "
                               "i-attributes are disabled");

Generalized_map/include/CGAL/Generalized_map_iterators_base.h

@@ -59,8 +59,8 @@ namespace CGAL {
 
     typedef Tag_true Use_mark;
 
-    CGAL_static_assertion( (Ai<=Map::dimension &&
+    static_assert(Ai<=Map::dimension &&
-                            std::is_same<Ite_has_stack,Tag_false>::value) );
+                            std::is_same<Ite_has_stack,Tag_false>::value);
 
   public:
     /// Main constructor.

Generalized_map/include/CGAL/Generalized_map_operations.h

@@ -73,7 +73,7 @@ namespace CGAL
     static size_t run(GMap& amap, typename GMap::Dart_descriptor adart,
                       bool update_attributes)
     {
-      CGAL_static_assertion ( i<GMap::dimension );
+      static_assert ( i<GMap::dimension );
       CGAL_assertion( (amap.template is_removable<i>(adart)) );
 
       size_t res = 0;
@@ -292,7 +292,7 @@ namespace CGAL
     static size_t run(GMap& amap, typename GMap::Dart_descriptor adart,
                       bool update_attributes)
     {
-      CGAL_static_assertion ( 1<=i && i<=GMap::dimension );
+      static_assert ( 1<=i && i<=GMap::dimension );
       CGAL_assertion( (amap.template is_contractible<i>(adart)) );
 
       size_t res = 0;

Generalized_map/include/CGAL/Generalized_map_storages.h

@@ -64,7 +64,7 @@ namespace CGAL {
     typedef typename Dart_container::size_type            size_type;
 
     typedef std::nullptr_t Null_descriptor_type;
-    CGAL_CPP17_INLINE static constexpr Null_descriptor_type null_descriptor=nullptr;
+    inline static constexpr Null_descriptor_type null_descriptor=nullptr;
 
     using Type_for_compact_container=void*;
 
@@ -107,7 +107,7 @@ namespace CGAL {
     template<int i>
     using Attribute_const_handle=Attribute_const_descriptor<i>;
 
-    CGAL_CPP17_INLINE static constexpr Null_descriptor_type null_handle=null_descriptor;
+    inline static constexpr Null_descriptor_type null_handle=null_descriptor;
 
     /// Number of marks
     static const size_type NB_MARKS = 32;
@@ -229,7 +229,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_descriptor<i>::type attribute(Dart_descriptor ADart)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (ADart->mattribute_descriptors);
@@ -238,7 +238,7 @@ namespace CGAL {
     typename Attribute_const_descriptor<i>::type
     attribute(Dart_const_descriptor ADart) const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (ADart->mattribute_descriptors);
@@ -249,7 +249,7 @@ namespace CGAL {
     typename Attribute_descriptor<i>::type copy_attribute
     (typename Attribute_const_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "copy_attribute<i> called but i-attributes are disabled.");
       typename Attribute_descriptor<i>::type res=
         std::get<Helper::template Dimension_index<i>::value>
@@ -457,17 +457,6 @@ namespace CGAL {
     /// Tuple of attributes containers
     typename Helper::Attribute_containers mattribute_containers;
   };
-
-#ifndef CGAL_CXX17
-  template<unsigned int d_, class Items_, class Alloc_>
-  constexpr typename Generalized_map_storage_1<d_, Items_, Alloc_>::Null_descriptor_type
-  Generalized_map_storage_1<d_, Items_, Alloc_>::null_descriptor;
-
-  template<unsigned int d_, class Items_, class Alloc_>
-  constexpr typename Generalized_map_storage_1<d_, Items_, Alloc_>::Null_descriptor_type
-  Generalized_map_storage_1<d_, Items_, Alloc_>::null_handle;
-#endif
-
 } // namespace CGAL
 
 #if defined(BOOST_GCC)

Generalized_map/include/CGAL/Generalized_map_storages_with_index.h

@@ -220,7 +220,7 @@ namespace CGAL {
     template<unsigned int i>
     typename Attribute_descriptor<i>::type attribute(Dart_descriptor ADart)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (mdarts[ADart].mattribute_descriptors);
@@ -229,7 +229,7 @@ namespace CGAL {
     typename Attribute_const_descriptor<i>::type
     attribute(Dart_const_descriptor ADart) const
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "attribute<i> called but i-attributes are disabled.");
       return std::get<Helper::template Dimension_index<i>::value>
         (mdarts[ADart].mattribute_descriptors);
@@ -240,7 +240,7 @@ namespace CGAL {
     typename Attribute_descriptor<i>::type copy_attribute
     (typename Attribute_const_descriptor<i>::type ah)
     {
-      CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
+      static_assert(Helper::template Dimension_index<i>::value>=0,
                      "copy_attribute<i> called but i-attributes are disabled.");
       // We need to do a reserve before the emplace in order to avoid a bug of
       // invalid reference when the container is reallocated.

Heat_method_3/include/CGAL/Heat_method_3/Surface_mesh_geodesic_distances_3.h

@@ -752,8 +752,8 @@ class Surface_mesh_geodesic_distances_3
     >
 #endif
 {
-  CGAL_static_assertion((std::is_same<Mode, Direct>::value) ||
+  static_assert(std::is_same<Mode, Direct>::value ||
-                        (std::is_same<Mode, Intrinsic_Delaunay>::value));
+                std::is_same<Mode, Intrinsic_Delaunay>::value);
 
   // extract real types from Default
 #ifdef CGAL_EIGEN3_ENABLED

Installation/CHANGES.md

@@ -1,6 +1,17 @@
 Release History
 ===============
 
+[Release 6.0](https://github.com/CGAL/cgal/releases/tag/v6.0)
+-----------
+
+Release date: October 2023
+
+### General Changes
+
+- **Breaking change**: C++17 is now required
+- Support for Visual `C++` 14.0 (Visual studio 2015) is dropped.
+
+
 [Release 5.6](https://github.com/CGAL/cgal/releases/tag/v5.6)
 -----------
 

Installation/CMakeLists.txt

@@ -946,7 +946,7 @@ ${Qt5Widgets_DEFINITIONS} ${Qt5OpenGL_DEFINITIONS} ${Qt5Gui_DEFINITIONS} \
 ${Qt5OpenGL_EXECUTABLE_COMPILE_FLAGS} -fPIC \
 ${Qt5Gui_EXECUTABLE_COMPILE_FLAGS} \
 ${CGAL_3RD_PARTY_DEFINITIONS} ${CGAL_Qt5_3RD_PARTY_DEFINITIONS} \
-${CGAL_DEFINITIONS}")
+${CGAL_DEFINITIONS} -std=c++17")
     message("COMPILATION OPTIONS ARE :  ${compile_options}")
 
     if(NOT RS_FOUND AND NOT RS3_FOUND)

Installation/cmake/modules/CGAL_SetupCGALDependencies.cmake

@@ -97,9 +97,6 @@ function(CGAL_setup_CGAL_dependencies target)
     target_compile_definitions(${target} INTERFACE CGAL_TEST_SUITE=1)
   endif()
 
-  # CGAL now requires C++14. `decltype(auto)` is used as a marker of C++14.
-  target_compile_features(${target} INTERFACE cxx_decltype_auto)
-
   use_CGAL_Boost_support(${target} INTERFACE)
 
   # Make CGAL depend on threads-support (for Epeck and Epeck_d)
@@ -119,6 +116,13 @@ function(CGAL_setup_CGAL_dependencies target)
     target_link_options(${target} INTERFACE -fsanitize=address)
   endif()
   # Now setup compilation flags
+  CGAL_setup_CGAL_flags(${target})
+endfunction()
+
+function(CGAL_setup_CGAL_flags target)
+  # CGAL now requires C++17
+  target_compile_features(${target} INTERFACE cxx_std_17)
+
   if(MSVC)
     target_compile_options(${target} INTERFACE
       "-D_SCL_SECURE_NO_DEPRECATE;-D_SCL_SECURE_NO_WARNINGS")
@@ -127,11 +131,6 @@ function(CGAL_setup_CGAL_dependencies target)
       $<$<COMPILE_LANGUAGE:CXX>:/fp:except->
       $<$<COMPILE_LANGUAGE:CXX>:/bigobj>  # Use /bigobj by default
       )
-    if(MSVC_TOOLSET_VERSION VERSION_LESS_EQUAL 140) # for MSVC 2015
-      target_compile_options(${target} INTERFACE
-        $<$<COMPILE_LANGUAGE:CXX>:/wd4503>  # Suppress warnings C4503 about "decorated name length exceeded"
-        )
-    endif()
   elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang")
     if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 11.0.3)
       message(STATUS "Apple Clang version ${CMAKE_CXX_COMPILER_VERSION} compiler detected")

Installation/include/CGAL/Installation/internal/deprecation_warning.h

@@ -71,7 +71,7 @@
 #endif
 
 #if defined(CGAL_NO_DEPRECATED_CODE) // No deprecated code.
-CGAL_static_assertion_msg(false, CGAL_INTERNAL_DEPRECATED_MESSAGE);
+static_assert(false, CGAL_INTERNAL_DEPRECATED_MESSAGE);
 #elif !defined(CGAL_NO_DEPRECATION_WARNINGS) // don't trigger on NO_DEPRECATION_WARNINGS
 #  if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
 #    pragma message (CGAL_INTERNAL_DEPRECATED_MESSAGE)

Installation/include/CGAL/config.h

@@ -36,11 +36,6 @@
 #  define WIN64
 #endif
 
-#ifdef _MSC_VER
-#define _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING 1
-#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING 1
-#endif
-
 #ifdef CGAL_INCLUDE_WINDOWS_DOT_H
 // Mimic users including this file which defines min max macros
 // and other names leading to name clashes
@@ -147,8 +142,8 @@
 #endif
 
 // Same for C++17
-#if __cplusplus >= 201703L || _MSVC_LANG >= 201703L
+#if !(__cplusplus >= 201703L || _MSVC_LANG >= 201703L)
-#  define CGAL_CXX17 1
+#error "CGAL requires C++ 17"
 #endif
 // Same for C++20
 #if __cplusplus >= 202002L || _MSVC_LANG >= 202002L
@@ -491,12 +486,6 @@ namespace cpp11{
 #  define CGAL_FALLTHROUGH while(false){}
 #endif
 
-#if CGAL_CXX17
-#  define CGAL_CPP17_INLINE inline
-#else
-#  define CGAL_CPP17_INLINE
-#endif
-
 #ifndef CGAL_NO_ASSERTIONS
 #  define CGAL_NO_ASSERTIONS_BOOL false
 #else

Installation/test/Installation/test_configuration_qt5.cpp

@@ -13,7 +13,7 @@ template <typename A, typename B>
 typename CGAL::Coercion_traits<A,B>::Type
 binary_func(const A& a , const B& b){
   typedef CGAL::Coercion_traits<A,B> CT;
-  CGAL_static_assertion((CT::Are_explicit_interoperable::value));
+  static_assert(CT::Are_explicit_interoperable::value);
   typename CT::Cast cast;
   return cast(a)*cast(b);
 }

Intersections_2/include/CGAL/Intersection_traits.h

@@ -181,8 +181,8 @@ do_intersect_impl(const A& a, const B& b, Dynamic_dimension_tag) {
 // inline
 // typename Intersection_traits< typename Kernel_traits<A>::Kernel, A, B>::result_type >::type
 // intersection(const A& a, const B& b) {
-//   CGAL_static_assertion_msg( (std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value),
+//   static_assert(std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value),
-//                               "intersection with objects of different dimensions not supported");
+//                               "intersection with objects of different dimensions not supported";
 //   return internal::intersection_impl(a, b, typename A::Ambient_dimension());
 // }
 
@@ -190,7 +190,7 @@ do_intersect_impl(const A& a, const B& b, Dynamic_dimension_tag) {
 // inline
 // auto // K::Boolean
 // do_intersect(const A& a, const B& b) {
-//   CGAL_static_assertion_msg((std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value),
+//   static_assert(std::is_same<typename A::Ambient_dimension, typename B::Ambient_dimension>::value,
 //                         "do_intersect with objects of different dimensions not supported");
 //   return internal::do_intersect_impl(a, b, typename A::Ambient_dimension());
 // }

Intersections_3/include/CGAL/Intersections_3/internal/Bbox_3_Segment_3_do_intersect.h

@@ -66,7 +66,7 @@ class Do_intersect_bbox_segment_aux_is_greater<FT, bounded_0, true>
   double dmax;
 
 public:
-  CGAL_static_assertion((std::is_same<FT, double>::value));
+  static_assert(std::is_same<FT, double>::value);
 
   Do_intersect_bbox_segment_aux_is_greater() : error(0.), tmax(0.), dmax(0.) {}
 

Interval_support/include/CGAL/Test/_test_bigfloat_interval_traits.h

@@ -41,7 +41,7 @@ void test_bigfloat_interval_traits() {
   typedef typename BFIT::Is_bigfloat_interval Is_bigfloat_interval;
   CGAL_USE_TYPE(Is_bigfloat_interval);
   // using CGAL::Tag_true;
-  CGAL_static_assertion(( ::std::is_same< Is_bigfloat_interval, CGAL::Tag_true>::value));
+  static_assert(::std::is_same< Is_bigfloat_interval, CGAL::Tag_true>::value);
 
   const typename BFIT::Construct construct = typename BFIT::Construct();
   const typename BFIT::Set_precision set_precision = typename BFIT::Set_precision();

Interval_support/include/CGAL/Test/_test_convert_to_bfi.h

@@ -41,7 +41,7 @@ template <typename BFI, typename From>
 void test_convert_to_bfi_from(BFI,From){
   typedef typename CGAL::Coercion_traits<BFI,From>::Type CT_type;
   CGAL_USE_TYPE(CT_type);
-  CGAL_static_assertion(( ::std::is_same<CT_type, BFI>::value));
+  static_assert(::std::is_same<CT_type, BFI>::value);
   assert(CGAL::convert_to_bfi(From(0))  == BFI(0));
   assert(CGAL::convert_to_bfi(From(1))  == BFI(1));
   assert(CGAL::convert_to_bfi(From(2))  == BFI(2));

Interval_support/include/CGAL/Test/_test_interval_traits.h

@@ -36,7 +36,7 @@ void test_with_empty_interval(CGAL::Tag_false) {
     typedef CGAL::Interval_traits<Interval> IT;
     typedef typename IT::Empty Empty;
     CGAL_USE_TYPE(Empty);
-    CGAL_static_assertion(
+    static_assert(
             (::std::is_same< Empty, CGAL::Null_functor>::value));
 
     // this part changes in case we allow empty intersection
@@ -74,8 +74,8 @@ void test_interval_traits() {
     typedef typename IT::With_empty_interval With_empty_interval;
     CGAL_USE_TYPE(Is_interval);
     using CGAL::Tag_true;
-    CGAL_static_assertion(( ::std::is_same< Is_interval, Tag_true>::value));
+    static_assert(::std::is_same< Is_interval, Tag_true>::value);
-    CGAL_static_assertion(( ::std::is_same< Interval_, Interval>::value));
+    static_assert(::std::is_same< Interval_, Interval>::value);
 
     test_with_empty_interval<Interval>(With_empty_interval());
 

Kernel_23/include/CGAL/Circle_2.h

@@ -35,7 +35,7 @@ class Circle_2 : public R_::Kernel_base::Circle_2
   typedef typename R_::Aff_transformation_2  Aff_transformation_2;
 
   typedef Circle_2                           Self;
-  CGAL_static_assertion((std::is_same<Self, typename R_::Circle_2>::value));
+  static_assert(std::is_same<Self, typename R_::Circle_2>::value);
 
 public:
 

Kernel_23/include/CGAL/Circle_3.h

@@ -43,7 +43,7 @@ template <class R_>
   typedef typename R_::Direction_3           Direction_3;
 
   typedef Circle_3                           Self;
-  CGAL_static_assertion((std::is_same<Self, typename R_::Circle_3>::value));
+  static_assert(std::is_same<Self, typename R_::Circle_3>::value);
 
 public:
 

Kernel_23/include/CGAL/Direction_2.h

@@ -38,7 +38,7 @@ class Direction_2 : public R_::Kernel_base::Direction_2
   typedef typename R_::Kernel_base::Direction_2      RDirection_2;
 
   typedef Direction_2                        Self;
-  CGAL_static_assertion((std::is_same<Self, typename R_::Direction_2>::value));
+  static_assert(std::is_same<Self, typename R_::Direction_2>::value);
 
 public:
 

Kernel_23/include/CGAL/Direction_3.h

@@ -37,7 +37,7 @@ class Direction_3 : public R_::Kernel_base::Direction_3
   typedef typename R_::Aff_transformation_3  Aff_transformation_3;
 
   typedef Direction_3                        Self;
-  CGAL_static_assertion((std::is_same<Self, typename R_::Direction_3>::value));
+  static_assert(std::is_same<Self, typename R_::Direction_3>::value);
 
 public:
 

Kernel_23/include/CGAL/Has_conversion.h

@@ -23,9 +23,9 @@ namespace internal {
 template<typename K1, typename K2, typename Rep = typename K1::Rep_tag /* Cartesian_tag */>
 struct Converter_selector
 {
-  CGAL_static_assertion_msg((std::is_same<typename K1::Rep_tag,
+  static_assert(std::is_same<typename K1::Rep_tag,
-                                            typename K2::Rep_tag>::value),
+                             typename K2::Rep_tag>::value,
-                            "Kernels must have the same representation");
+                             "Kernels must have the same representation");
 
   typedef CGAL::Cartesian_converter<K1, K2> type;
 };
@@ -33,9 +33,9 @@ struct Converter_selector
 template<typename K1, typename K2>
 struct Converter_selector<K1, K2, Homogeneous_tag>
 {
-  CGAL_static_assertion_msg((std::is_same<typename K1::Rep_tag,
+  static_assert(std::is_same<typename K1::Rep_tag,
-                                            typename K2::Rep_tag>::value),
+                             typename K2::Rep_tag>::value,
-                            "Kernels must have the same representation");
+                             "Kernels must have the same representation");
 
   typedef CGAL::Homogeneous_converter<K1, K2> type;
 };

Kernel_23/include/CGAL/Iso_cuboid_3.h

@@ -35,7 +35,7 @@ class Iso_cuboid_3 : public R_::Kernel_base::Iso_cuboid_3
   typedef typename R_::Aff_transformation_3  Aff_transformation_3;
 
   typedef Iso_cuboid_3                    Self;
-  CGAL_static_assertion((std::is_same<Self, typename R_::Iso_cuboid_3>::value));
+  static_assert(std::is_same<Self, typename R_::Iso_cuboid_3>::value);
 
 public:
 

Kernel_23/include/CGAL/Iso_rectangle_2.h

@@ -33,7 +33,7 @@ class Iso_rectangle_2 : public R_::Kernel_base::Iso_rectangle_2
   typedef typename R_::Aff_transformation_2  Aff_transformation_2;
 
   typedef Iso_rectangle_2                    Self;
-  CGAL_static_assertion((std::is_same<Self, typename R_::Iso_rectangle_2>::value));
+  static_assert(std::is_same<Self, typename R_::Iso_rectangle_2>::value);
 
 public: