merge cgal/master

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,11 @@ 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));
-        CGAL_static_assertion(
+        static_assert(
                 ( ::std::is_same< AS& , Second_argument_type>::value));
-        //CGAL_static_assertion(( ::std::is_same< bool , Result_type>::value));
+        //static_assert(::std::is_same< bool , Result_type>::value);
         bool b = Result_type(true); CGAL_USE(b);
 
         AS test_number = AS(3)*AS(3);
@@ -649,8 +648,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,11 +674,11 @@ 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));
-        CGAL_static_assertion(
+        static_assert(
                 ( ::std::is_same< AS , Second_argument_type>::value));
-        CGAL_static_assertion(
+        static_assert(
                 ( ::std::is_same< AS , Result_type>::value));
          AS  epsilon(1);
         assert( test_equality_epsilon(  AS (2),
@@ -803,7 +802,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 +815,12 @@ 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 );
-    CGAL_static_assertion(( ::boost::is_convertible< Tag,
+    static_assert(::std::is_same< Tag, Algebraic_category>::value);
-                    Integral_domain_without_division_tag >::value ));
+    static_assert(!::std::is_same< Simplify, Null_functor>::value);
-    CGAL_static_assertion(( ::std::is_same< Tag, Algebraic_category>::value));
+    static_assert(!::std::is_same< Unit_part, Null_functor>::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,7 +940,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));
     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_2/package_info/Alpha_shapes_2/dependencies

@@ -2,7 +2,6 @@ Algebraic_foundations
 Alpha_shapes_2
 Arithmetic_kernel
 Cartesian_kernel
-Filtered_kernel
 Hash_map
 Homogeneous_kernel
 Installation

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/examples/Alpha_wrap_3/mixed_inputs_wrap.cpp

@@ -25,8 +25,6 @@ using Mesh = CGAL::Surface_mesh<Point_3>;
 
 int main(int argc, char** argv)
 {
-  std::cout.precision(17);
-
   // Read the inputs
   const std::string ts_filename = (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/armadillo.off"); // triangle soup
   const std::string ss_filename = (argc > 2) ? argv[2] : CGAL::data_file_path("images/420.polylines.txt"); // segment soup

Alpha_wrap_3/examples/Alpha_wrap_3/point_set_wrap.cpp

@@ -8,8 +8,6 @@
 #include <iostream>
 #include <string>
 
-namespace AW3 = CGAL::Alpha_wraps_3;
-
 using K = CGAL::Exact_predicates_inexact_constructions_kernel;
 using Point_3 = K::Point_3;
 
@@ -18,8 +16,6 @@ using Mesh = CGAL::Surface_mesh<Point_3>;
 
 int main(int argc, char** argv)
 {
-  std::cout.precision(17);
-
   // Read the input
   const std::string filename = (argc > 1) ? argv[1] : CGAL::data_file_path("points_3/oni.pwn");
   std::cout << "Reading " << filename << "..." << std::endl;

Alpha_wrap_3/examples/Alpha_wrap_3/triangle_mesh_wrap.cpp

@@ -9,7 +9,6 @@
 #include <iostream>
 #include <string>
 
-namespace AW3 = CGAL::Alpha_wraps_3;
 namespace PMP = CGAL::Polygon_mesh_processing;
 
 using K = CGAL::Exact_predicates_inexact_constructions_kernel;
@@ -19,8 +18,6 @@ using Mesh = CGAL::Surface_mesh<Point_3>;
 
 int main(int argc, char** argv)
 {
-  std::cout.precision(17);
-
   // Read the input
   const std::string filename = (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/armadillo.off");
   std::cout << "Reading " << filename << "..." << std::endl;

Alpha_wrap_3/examples/Alpha_wrap_3/wrap_from_cavity.cpp

@@ -8,7 +8,6 @@
 #include <iostream>
 #include <string>
 
-namespace AW3 = CGAL::Alpha_wraps_3;
 namespace PMP = CGAL::Polygon_mesh_processing;
 
 using K = CGAL::Exact_predicates_inexact_constructions_kernel;
@@ -18,8 +17,6 @@ using Mesh = CGAL::Surface_mesh<Point_3>;
 
 int main(int argc, char** argv)
 {
-  std::cout.precision(17);
-
   // Read the input
   const std::string filename = (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/armadillo.off");
   std::cout << "Reading " << filename << "..." << std::endl;

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((boost::is_convertible<A_point, Res_point>::value));
+  static_assert(std::is_convertible<A_point, Res_point>::value);
-  CGAL_static_assertion((boost::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((boost::is_convertible<A_xcv, Res_xcv>::value));
+  static_assert(std::is_convertible<A_xcv, Res_xcv>::value);
-  CGAL_static_assertion((boost::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,7 +63,7 @@ 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 (!(boost::is_convertible<ConcurrencyTag, Parallel_tag>::value),
+  static_assert (!(boost::is_convertible<ConcurrencyTag, Parallel_tag>::value),
                              "Parallel_tag is enabled but TBB is unavailable.");
 #else // CGAL_LINKED_WITH_TBB
   if(boost::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

@@ -193,45 +193,45 @@ template <class C> inline
 void Assert_circulator( const C &) {
     typedef typename Circulator_traits<C>::category category;
     CGAL_USE_TYPE(category);
-    CGAL_static_assertion((boost::is_convertible<category, Circulator_tag>::value));
+    static_assert(boost::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((boost::is_convertible<category, Iterator_tag>::value));
+    static_assert(boost::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((boost::is_convertible<category, std::input_iterator_tag>::value));
+    static_assert(boost::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((boost::is_convertible<category, std::output_iterator_tag>::value));
+  static_assert(boost::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((boost::is_convertible<category, std::forward_iterator_tag>::value));
+  static_assert(boost::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((boost::is_convertible<category, std::bidirectional_iterator_tag>::value));
+  static_assert(boost::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((boost::is_convertible<category, std::random_access_iterator_tag>::value));
+  static_assert(boost::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/include/CGAL/Convex_hull_vertex_base_2.h

@@ -18,6 +18,7 @@
 #include <CGAL/license/Convex_hull_3.h>
 
 #include <CGAL/Triangulation_ds_vertex_base_2.h>
+#include <CGAL/IO/io.h>
 
 #include <iostream>
 
@@ -77,7 +78,7 @@ template <typename GT, typename Vb>
 std::ostream&
 operator<<(std::ostream &os, const Convex_hull_vertex_base_2<GT, Vb>& v)
 {
-  return os << static_cast<const Vb&>(v) << v.point();
+  return os << static_cast<const Vb&>(v) << IO::serialize(v.point());
 }
 
 } //namespace CGAL

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>, boost::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>, boost::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value);
   return 0;
 }

Documentation/doc/Documentation/Developer_manual/cmakelist_script.txt

@@ -31,7 +31,7 @@ linked. Valid options are, for instance, "filesystem" or "program_options".
 
 </DL>
 
-This options should suffice to create `CMakeLists.txt` script
+These options should suffice to create a `CMakeLists.txt` script
 for most directories containing programs. However, in some special
 cases, it might still be required to create the script manually, for
 instance, if some source files/executables need a different linking than

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,16 +6,16 @@
 \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 |
 | :----------      | :--------------- |
-| Linux            | \gnu `g++` 10.2.1 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
+| 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 13.0.1 |
+|                  | `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++` 10.2.1 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</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, 12.0.5, and 13.0.0 |
 
 <!-- Windows supported version are also listed on windows.html (must change both) -->

Documentation/doc/Documentation/Tutorials/Tutorial_reconstruction.txt

@@ -290,7 +290,7 @@ by the user at runtime with the second argument.
 
 \section TutorialsReconstruction_pipeline Full Pipeline Images
 
-The following figure an example of a full reconstruction pipeline
+The following figures show a full reconstruction pipeline
 applied to a bear statue (courtesy _EPFL Computer Graphics and
 Geometry Laboratory_ \cgalCite{cgal:e-esmr}). Two mesh processing
 algorithms (hole filling and isotropic remeshing) are also applied

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.

Documentation/doc/resources/1.8.13/menu_version.js

@@ -6,7 +6,8 @@
   var current_version_local = 'master'
   var all_versions = [
       'master',
-      '5.6-beta1',
+      '6.0-beta1',
+      '5.6',
       'latest',
       '5.5.2',
       '5.4.4',

Documentation/doc/resources/1.9.6/menu_version.js

@@ -6,7 +6,8 @@
   var current_version_local = 'master'
   var all_versions = [
       'master',
-      '5.6-beta1',
+      '6.0-beta1',
+      '5.6',
       'latest',
       '5.5.2',
       '5.4.4',

Filtered_kernel/include/CGAL/Filtered_kernel.h

@@ -21,10 +21,6 @@
 #include <CGAL/Kernel/Type_equality_wrapper.h>
 #include <CGAL/Exact_kernel_selector.h>
 
-#include <CGAL/MP_Float.h>
-#include <CGAL/Quotient.h>
-#include <CGAL/Number_types/internal/Exact_type_selector.h>
-
 #include <CGAL/Filtered_kernel/internal/Static_filters/Static_filters.h>
 #include <boost/type_traits.hpp>
 

Filtered_kernel/include/CGAL/Lazy_kernel.h

@@ -31,6 +31,7 @@
 #include <boost/mpl/or.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/remove_cv.hpp>
+#include <CGAL/Lazy_exact_nt.h>
 
 #if defined(BOOST_MSVC)
 #  pragma warning(push)

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.
+
 ### [3D Mesh Generation](https://doc.cgal.org/6.0/Manual/packages.html#PkgMesh3)
 
 -   **Breaking change**: Removed the concept `TriangleAccessor`, the template parameter `TriangleAccessor`, as well
@@ -10,6 +21,7 @@ Release History
     which are deprecated since CGAL-4.13.
 
 
+
 [Release 5.6](https://github.com/CGAL/cgal/releases/tag/v5.6)
 -----------
 
@@ -17,129 +29,31 @@ Release date: June 2023
 
 ### General Changes
 
-- **Breaking change**: The per package assertions, pre- and postconditions are no longer supported.
+-   **Breaking change**: Package-specific assertions, preconditions, and postconditions (such as
+    `CGAL_triangulation_assertion`) have been removed. Corresponding CGAL-wide versions (such as
+    `CGAL_assertion`) should be used instead.
 
-### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.6/Manual/packages.html#PkgKernel23)
+### [Shape Detection](https://doc.cgal.org/5.6/Manual/packages.html#PkgShapeDetection) (major changes)
--   Added the functor
-    [`CompareAngle_3`](https://doc.cgal.org/5.6/Kernel_23/classKernel_1_1CompareAngle__3.html)
-    to the concept [`Kernel`](https://doc.cgal.org/5.6/Kernel_23/classKernel.html) to compare
-    an angle defined by three points to the cosinus of another angle.
 
-### [Combinatorial Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgCombinatorialMaps) [Generalized Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgGeneralizedMaps) [Linear Cell Complex](https://doc.cgal.org/5.6/Manual/packages.html#PkgLinearCellComplex)
+-   **Breaking change**: The region growing part of the package have been reworked to fix design
-
+    issues introduced with the handling of `FaceGraph` models. In particular, the notion of `Item`
-- Added a version that uses indices instead of handles as dart and attribute descriptors. As the indices are integers convertible from and to `std::size_t`, they can be used as index into vectors which store properties. To use the index version,  `Use_index` must be defined and be equal to `CGAL::Tag_true` in the item class.
+    has been introduced to reference an element in the input range of elements. Region maps now
-
+    operates on `Item` and no longer on the value type of the input range.
-### [Linear Cell Complex](https://doc.cgal.org/5.6/Manual/packages.html#PkgLinearCellComplex)
+-   **Breaking change**: The method `update()` in the concept `RegionType` now returns a `Boolean`
-- Added the class `Linear_cell_complex_incremental_builder_3`.
+    instead of `void`, that is used inside the class `Region_growing` for detecting if the input
-
+    conditions for the new region are satisfied. This change affects only user-defined types of regions.
-### [Polygon Mesh Processing](https://doc.cgal.org/5.6/Manual/packages.html#PkgPolygonMeshProcessing)
+-   **Breaking change**: The constructors of all models used together with the region growing algorithm
-
+    now enable users to provide parameters through the [named parameters](https://doc.cgal.org/latest/BGL/group__bgl__namedparameters.html) mechanism.
-- **Breaking change**: Deprecated the overloads of functions `CGAL::Polygon_mesh_processing::triangulate_hole()`,
-  `CGAL::Polygon_mesh_processing::triangulate_and_refine_hole()`, and `CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole()`
-  which have output iterators for vertices and faces as parameter. They are replaced by overloads with two additional named parameters.
-
-- added functions `CGAL::Polygon_mesh_processing::region_growing_of_planes_on_faces()` and `CGAL::Polygon_mesh_processing::detect_corners_of_regions()`
-  that allow to have a partition into planar regions of a mesh using the region growing algorithm from the [Shape Detection](https://doc.cgal.org/5.6/Manual/packages.html#PkgShapeDetection) package.
-
--   Added the function `CGAL::Polygon_mesh_processing::surface_Delaunay_remeshing()`, that remeshes a surface triangle mesh following the
-CGAL tetrahedral Delaunay refinement algorithm.
-
--   Added the function `CGAL::Polygon_mesh_processing::surface_Delaunay_remeshing()`, that remeshes a surface triangle mesh using
-  the Delaunay refinement algorithm from the 3D Mesh Generation package.
-
--   Added the function `CGAL::Polygon_mesh_processing::remove_almost_degenerate_faces()` to remove badly shaped triangles faces in a mesh.
-
--   Added the function `CGAL::Polygon_mesh_processing::triangulate_polygons()`, which allows users to triangulate polygon soups.
-
--   Added the functions `CGAL::Polygon_mesh_processing::remesh_planar_patches()` and
-    `CGAL::Polygon_mesh_processing::remesh_almost_coplanar_patches()` to retriangulate patches of coplanar faces in a mesh.
-
--   Added a named parameter to `CGAL::Polygon_mesh_processing::smooth_shape()` to disable scaling to compensate volume loss.
-
--   Added the functions `CGAL::Polygon_mesh_processing::does_triangle_soup_self_intersect()` and `CGAL::Polygon_mesh_processing::triangle_soup_self_intersections()` to identify and report self-intersections in a triangle soup, similarly to existing functions on triangle meshes.
-
-### [3D Simplicial Mesh Data Structure](https://doc.cgal.org/5.6/Manual/packages.html#PkgSMDS3) (new package)
-
--   This new package wraps all the existing code that deals with a `MeshComplex_3InTriangulation_3` to describe 3D simplicial meshes, and makes the data structure independent from the tetrahedral mesh generation package.
-
-### [Shape Detection](https://doc.cgal.org/5.6/Manual/packages.html#PkgShapeDetection) (breaking change, major changes)
-
--   **Breaking change**: The region growing part of the package have been reworked to fix design issues introduced with the handling `FaceGraph` models.
-    In particular, the notion of `Item` has been introduced to reference an element in the input range of elements. Region maps now operates on `Item` and no longer on the value type
-    of the input range.
--   **Breaking change**: The method `update()` in the concept `RegionType` returns now
-    a `boolean` instead of  `void` that is used inside the class `Region_growing` for detecting if
-    the input conditions for the new region are satisfied. This change affects only user-defined
-    types of regions.
--   **Breaking change**: The constructors of all models used together with the region growing algorithm now enable users
-    to provide parameters through the named parameters mechanism.
 -   All fitting classes in the region growing framework are now using better versions of the region
     conditions, more precise and faster, including the correct normal orientations.
 -   Added new models of the concept `RegionType` for getting linear regions in a set of 2D and 3D
     segments and on 2D and 3D polylines.
--   Added the `Polyline_graph` class for extracting a set of polylines from a face graph, which splits
+-   Added the class `Polyline_graph` for extracting a set of polylines from a face graph, which splits
     this graph into a set of user-defined regions.
 -   Added new shapes to the Region Growing algorithm on a point set: circles in 2D, spheres in 3D,
     and cylinders in 3D.
 
-### [2D Arrangements](https://doc.cgal.org/5.6/Manual/packages.html#PkgArrangementOnSurface2)
+### [2D Straight Skeleton and Polygon Offsetting](https://doc.cgal.org/5.6/Manual/packages.html#PkgStraightSkeleton2) (major changes)
-
--   Fixed some code that handles geodesic-curves on spheres that compare x- and y-coordinates on the boundary of the parameter space. It mainly effected the naive point-location.
--   Introduced an overload function template, namely `draw(arr)`, that renders arrangements based on the `Basic_viewer_qt` class template. At this point only 2D arrangements on the plane induced by (i) segments, (ii) conics, and (iii) circular arcs or (linear) segments are supported.
--   Improved the traits class template that handles conics, namely `Arr_conic_traits_2`. This includes the following:
-    1. Fixed a couple of bugs and slightly optimized some functions.
-    2. Introduced functionality that approximates conics with polylines. (This is used to draw conic curves.)
-    3. **Breaking change**: Changed the interface to generate conic curves. In the past, curves where generated directly using the constructors of the conic and x-monotone conic constructs. Now, they are constructed via function objects provided by the traits. This eliminates the constructions of temporary kernels. The old functionality is obsolete, but still supported for a limited number of versions. It depends on a static member function of the traits. In a future version this function will no longer be static, implying that the old functionality will no longer be supported.
-- Introduced functionality that approximates circular segments with polylines. (This is used to draw conic curves.)
-
-### [2D Convex Hulls](https://doc.cgal.org/5.6/Manual/packages.html#PkgConvexHull2)
-
--   **Breaking change**: The concept `ConvexHullTraits_2` no longer requires the functor
-    `Less_signed_distance_to_line_2`, but requires the functor `Compare_signed_distance_to_line_2` instead.
--   The long-deprecated classes `Convex_hull_projective_xy_traits_2`, `Convex_hull_projective_xz_traits_2`,
-    and `Convex_hull_projective_yz_traits_2` have been removed. Users should use `Projection_traits_xy_3`,
-    `Projection_traits_xz_3`, and `Projection_traits_yz_3` instead.
-
-### [2D Triangulations](https://doc.cgal.org/5.6/Manual/packages.html#PkgTriangulation2)
-
--   Added function `mark_domains_in_triangulation()` to mark faces connected with non constrained edges as inside of the domain based on the nesting level.
-
-### [2D Conforming Triangulations and Meshes](https://doc.cgal.org/5.6/Manual/packages.html#PkgMesh2)
-
--   Deprecated usage of boost parameters in favor of function named parameters in `CGAL::lloyd_optimize_mesh_2()`.
--   Deprecated two overloads of Function `refine_Delaunay_mesh()` and replaced them with versions using function named parameters.
--   Add overloads of function `write_VTU()` with property maps for specifying the domain.
-
-### [3D Mesh Generation](https://doc.cgal.org/5.6/Manual/packages.html#PkgMesh3)
--   Deprecated usage of boost parameters in favor of function named parameters.
--   Added two new named parameters to the named constructor `CGAL::create_labeled_image_mesh_domain()`
-for automatic detection and protection
-of 1D-curves that lie at the intersection of three or more subdomains,
-extracted from labeled images.
--   Added `CGAL::Sizing_field_with_aabb_tree`, a geometry-aware sizing field for feature edges in polyhedral domains.
--   Added new meshing criterion `edge_min_size` to avoid subdividing sharp edges that are shorter than the prescribed size bound.
--   Added new meshing criteria `facet_min_size` and `cell_min_size` to prevent Delaunay refinement from creating simplices smaller than the prescribed bound.
-
-### [3D Periodic Mesh Generation](https://doc.cgal.org/5.6/Manual/packages.html#PkgPeriodic3Mesh3)
--   Periodic Mesh Generation now supports non-cubic domains.
--   Deprecated usage of boost parameters in favor of function named parameters.
-
-### [2D Hyperbolic Triangulations](https://doc.cgal.org/5.6/Manual/packages.html#PkgHyperbolicTriangulation2)
-
--   **Breaking change**: the concept `HyperbolicTriangulationFaceBase_2` has been modified to
-    better reflect the triangulation's requirements and avoid a conflict with the requirements
-    described by the concept `TriangulationDataStructure_2::Face`. The model `CGAL::Hyperbolic_triangulation_face_base_2`
-    has been adapted correspondingly.
-
-### [Surface Mesh Simplification](https://doc.cgal.org/5.6/Manual/packages.html#PkgSurfaceMeshSimplification)
--   The stop predicates `Count_stop_predicate` and `Count_ratio_stop_predicate` are renamed to `Edge_count_stop_predicate` and `Edge_count_ratio_stop_predicate`. Older versions have been deprecated.
--   Introduce `Face_count_stop_predicate` and `Face_count_ratio_stop_predicate` that can be used to stop the simplification algorithm based on a desired number of faces in the output, or a ratio between input and output face numbers.
-
-### [2D Minkowski Sums](https://doc.cgal.org/5.6/Manual/packages.html#PkgMinkowskiSum2)
--   Fixed a bug that made holes in the Minkowski sum disappear
--   Fixed hole filtering. The code used to erroneously remove holes from the container of holes of polygons with holes that did not affect the minkowsi sum. Now it simply adds those that do affect it.
-
-### [2D Straight Skeleton and Polygon Offsetting (breaking change)](https://doc.cgal.org/5.6/Manual/packages.html#PkgStraightSkeleton2) (major changes)
 -   Added weighted straight skeletons: weighted straight skeletons are a generalization of
     straight skeletons. Contour edges are assigned a positive weight, which can be understood
     as assigning a speed to the wavefront spawned from the contour edge.
@@ -147,18 +61,197 @@ extracted from labeled images.
     straight skeletons of polygons with holes. The output is a closed, combinatorially 2-manifold
     surface triangle mesh.
 
-### [2D Regularized Boolean Set Operations](https://doc.cgal.org/5.6/Manual/packages.html#PkgBooleanSetOperations2)
+    See also the [news entry](https://www.cgal.org/2023/05/09/improved_straight_skeleton/).
--   Exposed all required member functions of the `GeneralPolygonWithHoles_2` concept (e.g., `clear_outer_boundary()`, `clear_holes()`, and `clear()`).
 
-### [Polygon](https://doc.cgal.org/5.6/Manual/packages.html#PkgPolygon2)
+### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.6/Manual/packages.html#PkgKernel23)
--   Fixed the function `draw(const CGAL::Polygon_with_holes_2<T, C>& pwh, const char* title)` to enable the correct drawing of unbounded polygons with holes.
+
+-   Added the functor
+    [`CompareAngle_3`](https://doc.cgal.org/5.6/Kernel_23/classKernel_1_1CompareAngle__3.html)
+    to the concept
+    [`Kernel`](https://doc.cgal.org/5.6/Kernel_23/classKernel.html) to compare
+    an angle defined by three points to the cosinus of another angle.
+
+### [Combinatorial Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgCombinatorialMaps), [Generalized Maps](https://doc.cgal.org/5.6/Manual/packages.html#PkgGeneralizedMaps), and [Linear Cell Complex](https://doc.cgal.org/5.6/Manual/packages.html#PkgLinearCellComplex)
+
+-   Added a version that uses indices instead of handles as dart and attribute descriptors.
+    As the indices are integers convertible from and to `std::size_t`, they can be used as index
+    into vectors which store properties. To use the index version, `Use_index` must be defined
+    and be equal to `CGAL::Tag_true` in the item class.
+
+### [Linear Cell Complex](https://doc.cgal.org/5.6/Manual/packages.html#PkgLinearCellComplex)
+
+-   Added the class
+    [`Linear_cell_complex_incremental_builder_3`](https://doc.cgal.org/5.6/Linear_cell_complex/classCGAL_1_1Linear__cell__complex__incremental__builder__3.html).
+
+### [2D Arrangements](https://doc.cgal.org/5.6/Manual/packages.html#PkgArrangementOnSurface2)
+
+-   Introduced an overload function template, namely `draw(arr)`, that renders arrangements based
+    on the `Basic_viewer_qt` class template. As of now, only 2D arrangements on the plane induced
+    by (i) segments, (ii) conics, and (iii) circular arcs or (linear) segments are supported.
+-   Improved the traits class template that handles conics, namely
+    [`Arr_conic_traits_2`](https://doc.cgal.org/5.6/Arrangement_on_surface_2/classCGAL_1_1Arr__conic__traits__2.html).
+    This includes the following:
+    1. Fixed a couple of bugs and slightly optimized some functions.
+    2. Introduced functionality that approximates conics with polylines. (This is used to draw conic curves.)
+    3. **Breaking change**: Changed the interface to generate conic curves. In the past, curves where
+    generated directly using the constructors of the conic and x-monotone conic constructs. Now,
+    they are constructed via function objects provided by the traits. This eliminates the constructions
+    of temporary kernels. The old functionality is obsolete, but still supported for a limited number
+    of versions. It depends on a static member function of the traits. In a future version this function
+    will no longer be static, implying that the old functionality will no longer be supported.
+- Introduced functionality that approximates circular segments with polylines. (This is used to draw conic curves.)
+
+### [Polygon Mesh Processing](https://doc.cgal.org/5.6/Manual/packages.html#PkgPolygonMeshProcessing)
+
+-   Added functions
+    [`CGAL::Polygon_mesh_processing::region_growing_of_planes_on_faces()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PkgPolygonMeshProcessingRef.html#ga50dcd2f6295f584d2e378b57290ae2af)
+    and
+    [`CGAL::Polygon_mesh_processing::detect_corners_of_regions()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PkgPolygonMeshProcessingRef.html#gac8e445730d718a2fc49604e865017d2e),
+    which enable partitioning a mesh into planar regions using the region growing algorithm
+    from the [Shape Detection](https://doc.cgal.org/5.6/Manual/packages.html#PkgShapeDetection) package.
+
+-   Added the functions
+    [`CGAL::Polygon_mesh_processing::remesh_planar_patches()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__meshing__grp.html#ga7fca6fa2db94560ab6d32e6a77fc35b6)
+    and
+    [`CGAL::Polygon_mesh_processing::remesh_almost_planar_patches()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__meshing__grp.html#ga0e6da479548199a5d82c3cf0ed36e8a0),
+    which can be used to remesh patches of coplanar faces in a mesh.
+
+-   Added the function
+    [`CGAL::Polygon_mesh_processing::surface_Delaunay_remeshing()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__meshing__grp.html#gaff62f9415d2fe96d1d3095351f156ced),
+    which can be used to remesh a surface triangle mesh using the Delaunay refinement algorithm
+    from the [3D Mesh Generation](https://doc.cgal.org/5.6/Manual/packages.html#PkgMesh3) package.
+
+-   Added the function
+    [`CGAL::Polygon_mesh_processing::remove_almost_degenerate_faces()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__geometric__repair__grp.html#ga48008d2b66de8a68a7068f29db15dad6),
+    which can be used to remove badly shaped triangles faces in a mesh.
+
+-   Added the functions
+    [`CGAL::Polygon_mesh_processing::does_triangle_soup_self_intersect()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__intersection__grp.html#ga4909920dc48b8285e69feb845feb1e53)
+    and
+    [`CGAL::Polygon_mesh_processing::triangle_soup_self_intersections()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__intersection__grp.html#ga1c5fee17bd0d92d5a2fba77ed94d4b4d)
+    to identify and report self-intersections in a triangle soup, similarly to existing functions on triangle meshes.
+
+-   Added the function
+    [`CGAL::Polygon_mesh_processing::triangulate_polygons()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__meshing__grp.html#ga8b7db6aa8c3e79526b594739ba926d82),
+    which allows users to triangulate polygon soups.
+
+-   Added a named parameter to
+    [`CGAL::Polygon_mesh_processing::smooth_shape()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__meshing__grp.html#ga57fa999abe8dc557003482444df2a189)
+    to disable the scaling, which otherwise aims to compensate volume loss during smoothing.
+
+-   Deprecated the overloads of functions
+    [`CGAL::Polygon_mesh_processing::triangulate_hole()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__hole__filling__grp.html#ga3abdf2d0558822e85f060966b69cae98),
+    [`CGAL::Polygon_mesh_processing::triangulate_and_refine_hole()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__hole__filling__grp.html#ga9868fac4d9dca77462ad7828bc99d8a1),
+    and
+    [`CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole()`](https://doc.cgal.org/5.6/Polygon_mesh_processing/group__PMP__hole__filling__grp.html#ga18eac756a8f8e5d5f73e645fd4e26cad)
+    which have output iterators for vertices and faces as parameter. They are replaced by overloads
+    with two additional named parameters.
+
+### [2D Convex Hulls](https://doc.cgal.org/5.6/Manual/packages.html#PkgConvexHull2)
+
+-   **Breaking change**: The concept
+    [`ConvexHullTraits_2`](https://doc.cgal.org/5.6/Convex_hull_2/classConvexHullTraits__2.html)
+    no longer requires the functor `Less_signed_distance_to_line_2`, but requires the functor
+    `Compare_signed_distance_to_line_2`
+    instead.
+-   The long-deprecated classes `Convex_hull_projective_xy_traits_2`, `Convex_hull_projective_xz_traits_2`,
+    and `Convex_hull_projective_yz_traits_2` have been removed. Users should use
+    [`Projection_traits_xy_3`](https://doc.cgal.org/5.6/Kernel_23/classCGAL_1_1Projection__traits__xy__3.html),
+    [`Projection_traits_xz_3`](https://doc.cgal.org/5.6/Kernel_23/classCGAL_1_1Projection__traits__xz__3.html),
+    and
+    [`Projection_traits_yz_3`](https://doc.cgal.org/5.6/Kernel_23/classCGAL_1_1Projection__traits__yz__3.html)
+    instead.
+
+### [2D Triangulations](https://doc.cgal.org/5.6/Manual/packages.html#PkgTriangulation2)
+
+-   Added the function
+    [`CGAL::mark_domain_in_triangulation()`](https://doc.cgal.org/5.6/Triangulation_2/group__PkgTriangulation2Miscellaneous.html#ga0409755d0eb89100810230443a85e7eb)
+    to mark faces connected with non-constrained edges as inside of the domain based on the nesting level.
+
+### [2D Conforming Triangulations and Meshes](https://doc.cgal.org/5.6/Manual/packages.html#PkgMesh2)
+
+-   Added new overloads to the function
+    [`write_VTU()`](https://doc.cgal.org/5.6/Mesh_2/group__PkgMesh2IO.html),
+    with property maps for specifying the domain.
+-   Deprecated usage of boost parameters in favor of function named parameters in
+    [`CGAL::lloyd_optimize_mesh_2()`](https://doc.cgal.org/5.6/Mesh_2/group__PkgMesh2Functions.html#gafeaf59d3fa014da287f8514913b38d05).
+-   Deprecated two overloads of the function
+    [`refine_Delaunay_mesh()`](https://doc.cgal.org/5.6/Mesh_2/group__PkgMesh2Functions.html),
+    and replaced them with versions using function named parameters.
+
+### [2D Hyperbolic Triangulations](https://doc.cgal.org/5.6/Manual/packages.html#PkgHyperbolicTriangulation2)
+
+-   **Breaking change**: the concept
+    [`HyperbolicTriangulationFaceBase_2`](https://doc.cgal.org/5.6/Hyperbolic_triangulation_2/classHyperbolicTriangulationFaceBase__2.html)
+    has been modified to
+    better reflect the triangulation's requirements and avoid a conflict with the requirements
+    described by the concept `TriangulationDataStructure_2::Face`. The model
+    [`CGAL::Hyperbolic_triangulation_face_base_2`](https://doc.cgal.org/5.6/Hyperbolic_triangulation_2/classCGAL_1_1Hyperbolic__triangulation__face__base__2.html)
+    has been adapted correspondingly.
+
+### [3D Simplicial Mesh Data Structure](https://doc.cgal.org/5.6/Manual/packages.html#PkgSMDS3) (new package)
+
+-   This new package wraps all the existing code that deals with a
+    [`MeshComplex_3InTriangulation_3`](https://doc.cgal.org/5.6/SMDS_3/classMeshComplex__3InTriangulation__3.html)
+    to describe 3D simplicial meshes, and makes the data structure independent
+    from the [tetrahedral mesh generation](https://doc.cgal.org/5.6/Manual/packages.html#PkgMesh3) package.
+
+### [3D Mesh Generation](https://doc.cgal.org/5.6/Manual/packages.html#PkgMesh3)
+
+-   Added two new named parameters to the named constructor
+    [`CGAL::create_labeled_image_mesh_domain()`](https://doc.cgal.org/5.6/Mesh_3/classCGAL_1_1Labeled__mesh__domain__3.html#aec3f58e9883a8036a1b3e379df7d8fa9)
+    for automatic detection and protection of 1D-curves that lie at the intersection of
+    three or more subdomains extracted from labeled images.
+-   Added
+    [`CGAL::Sizing_field_with_aabb_tree`](https://doc.cgal.org/5.6/Mesh_3/structCGAL_1_1Sizing__field__with__aabb__tree.html),
+    a geometry-aware sizing field for feature edges in polyhedral domains.
+-   Added new meshing criterion
+    [`edge_min_size`](https://doc.cgal.org/5.6/Mesh_3/classCGAL_1_1Mesh__criteria__3.html#a5f1c2649cb7ea346a3b6a2a8724b4df1)
+    to avoid subdividing sharp edges that are shorter than a prescribed size bound.
+-   Added new meshing criteria
+    [`facet_min_size`](https://doc.cgal.org/5.6/Mesh_3/classCGAL_1_1Mesh__criteria__3.html#a5f1c2649cb7ea346a3b6a2a8724b4df1)
+    and
+    [`cell_min_size`](https://doc.cgal.org/5.6/Mesh_3/classCGAL_1_1Mesh__criteria__3.html#a5f1c2649cb7ea346a3b6a2a8724b4df1)
+    to prevent Delaunay refinement from creating simplices smaller than a prescribed bound.
+-   Deprecated usage of boost parameters in favor of function named parameters.
+
+### [3D Periodic Mesh Generation](https://doc.cgal.org/5.6/Manual/packages.html#PkgPeriodic3Mesh3)
+
+-   Periodic Mesh Generation now supports non-cubic domains.
+-   Deprecated usage of boost parameters in favor of function named parameters.
+
+### [Surface Mesh Simplification](https://doc.cgal.org/5.6/Manual/packages.html#PkgSurfaceMeshSimplification)
+-   The stop predicates
+    [`Count_stop_predicate`](https://doc.cgal.org/5.6/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Count__stop__predicate.html)
+    and
+    [`Count_ratio_stop_predicate`](https://doc.cgal.org/5.6/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Count__ratio__stop__predicate.html)
+    are renamed to
+    [`Edge_count_stop_predicate`](https://doc.cgal.org/5.6/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Edge__count__stop__predicate.html)
+    and
+    [`Edge_count_ratio_stop_predicate`](https://doc.cgal.org/5.6/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Edge__count__ratio__stop__predicate.html).
+    Older versions have been deprecated.
+-   Introduced
+    [`Face_count_stop_predicate`](https://doc.cgal.org/5.6/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Face__count__stop__predicate.html)
+    and
+    [`Face_count_ratio_stop_predicate`](https://doc.cgal.org/5.6/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Face__count__ratio__stop__predicate.html),
+    which can be used to stop the simplification algorithm based on a desired number of faces in the output, or a ratio between input and output face numbers.
+
+### [2D Regularized Boolean Set Operations](https://doc.cgal.org/5.6/Manual/packages.html#PkgBooleanSetOperations2)
+-   Exposed all required member functions of the
+    [`GeneralPolygonWithHoles_2`](https://doc.cgal.org/5.6/Polygon/classGeneralPolygonWithHoles__2.html)
+    concept (e.g.,
+    [`clear_outer_boundary()`](https://doc.cgal.org/5.6/Polygon/classGeneralPolygonWithHoles__2.html#a9f5f035047505a2ccab3e68770f51bc6),
+    [`clear_holes()`](https://cgal.geometryfactory.com/CGAL/doc/master/Polygon/classGeneralPolygonWithHoles__2.html#a2a507be648f127ac605da8c670ea2580),
+    and
+    [`clear()`](https://doc.cgal.org/5.6/Polygon/classGeneralPolygonWithHoles__2.html#a2ca4d9b43cc9216c1b2cdb080a915944)
+    ).
 
 [Release 5.5](https://github.com/CGAL/cgal/releases/tag/v5.5)
 -----------
 
 Release date: June 2022
 
-### [3D Alpha Wrapping (new package)](https://doc.cgal.org/5.5/Manual/packages.html#PkgAlphaWrap3)
+### [3D Alpha Wrapping](https://doc.cgal.org/5.5/Manual/packages.html#PkgAlphaWrap3) (new package)
 
 -   This component takes a 3D triangle mesh, soup, or point set as input, and generates a valid
     (watertight, intersection-free, and combinatorially 2-manifold) surface triangle mesh
@@ -172,7 +265,7 @@ Release date: June 2022
 
     See also the [announcement page](https://www.cgal.org/2022/05/18/alpha_wrap/).
 
-### [2D Straight Skeleton and Polygon Offsetting (breaking change)](https://doc.cgal.org/5.5/Manual/packages.html#PkgStraightSkeleton2)
+### [2D Straight Skeleton and Polygon Offsetting](https://doc.cgal.org/5.5/Manual/packages.html#PkgStraightSkeleton2) (breaking change)
 -   Fix the output of the function [CGAL::create_exterior_skeleton_and_offset_polygons_with_holes_2()](https://doc.cgal.org/5.5/Straight_skeleton_2/group__PkgStraightSkeleton2OffsetFunctions.html#gaa159f093e5d6d7fdb62c1660a44f95fe)
     to not take into account the offset of the outer frame.
 -   Fix the computation of the exterior offset of a polygon with holes that was not computing the offset of the holes

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_Eigen3_support.cmake

@@ -1,9 +1,14 @@
-if(EIGEN3_FOUND AND NOT TARGET CGAL::Eigen3_support)
+if((EIGEN3_FOUND OR Eigen3_FOUND) AND NOT TARGET CGAL::Eigen3_support)
   if(NOT TARGET Threads::Threads)
     find_package(Threads REQUIRED)
   endif()
   add_library(CGAL::Eigen3_support INTERFACE IMPORTED)
   set_target_properties(CGAL::Eigen3_support PROPERTIES
-    INTERFACE_COMPILE_DEFINITIONS "CGAL_EIGEN3_ENABLED"
+    INTERFACE_COMPILE_DEFINITIONS "CGAL_EIGEN3_ENABLED")
+  if(TARGET Eigen3::Eigen)
+    target_link_libraries(CGAL::Eigen3_support INTERFACE Eigen3::Eigen)
+  else()
+    set_target_properties(CGAL::Eigen3_support PROPERTIES
       INTERFACE_INCLUDE_DIRECTORIES "${EIGEN3_INCLUDE_DIR}")
+  endif()
 endif()

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/cmake/modules/CGAL_pointmatcher_support.cmake

@@ -9,7 +9,7 @@ if(libpointmatcher_FOUND AND NOT TARGET CGAL::pointmatcher_support)
     add_library(CGAL::pointmatcher_support INTERFACE IMPORTED)
     target_compile_definitions(CGAL::pointmatcher_support INTERFACE "CGAL_LINKED_WITH_POINTMATCHER")
     target_include_directories(CGAL::pointmatcher_support INTERFACE "${libpointmatcher_INCLUDE_DIR}")
-    target_link_libraries(CGAL::pointmatcher_support INTERFACE ${libpointmatcher_LIBRARIES})
+    target_link_libraries(CGAL::pointmatcher_support INTERFACE ${libpointmatcher_LIBRARIES} libnabo::nabo)
   else()
     message(STATUS "NOTICE: the libpointmatcher library requires the following boost components: thread filesystem system program_options date_time chrono.")
   endif()

Installation/cmake/modules/FindTBB.cmake

@@ -1,3 +1,5 @@
+# Copy of https://github.com/NVIDIA/thrust/blob/9f1cddc62b1bebbaeb8d07d4476c285be5aa0adc/thrust/cmake/FindTBB.cmake
+#
 # - Find ThreadingBuildingBlocks include dirs and libraries
 # Use this module by invoking find_package with the form:
 #  find_package(TBB
@@ -11,6 +13,7 @@
 #                  malloc proxy
 #  TBB::tbb - imported target for the TBB library
 #
+#  TBB_VERSION - Product Version Number ("MAJOR.MINOR")
 #  TBB_VERSION_MAJOR - Major Product Version Number
 #  TBB_VERSION_MINOR - Minor Product Version Number
 #  TBB_INTERFACE_VERSION - Engineering Focused Version Number
@@ -107,16 +110,17 @@ endfunction()
 # Do the final processing for the package find.
 #===============================================
 macro(findpkg_finish PREFIX TARGET_NAME)
-  # skip if already processed during this run
-  if (NOT ${PREFIX}_FOUND)
   if (${PREFIX}_INCLUDE_DIR AND ${PREFIX}_LIBRARY)
     set(${PREFIX}_FOUND TRUE)
     set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIR})
     set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARY})
   else ()
-      if (${PREFIX}_FIND_REQUIRED AND NOT ${PREFIX}_FIND_QUIETLY)
+    if (${PREFIX}_FIND_REQUIRED)
       message(FATAL_ERROR "Required library ${PREFIX} not found.")
-      endif ()
+    elseif (NOT ${PREFIX}_FIND_QUIETLY)
+      message("Library ${PREFIX} not found.")
+    endif()
+    return()
   endif ()
 
   if (NOT TARGET "TBB::${TARGET_NAME}")
@@ -148,7 +152,6 @@ macro(findpkg_finish PREFIX TARGET_NAME)
                    ${PREFIX}_LIBRARY
                    ${PREFIX}_LIBRARY_DEBUG
                    ${PREFIX}_LIBRARY_RELEASE)
-  endif ()
 endmacro()
 
 #===============================================
@@ -188,6 +191,10 @@ endmacro()
 #=============================================================================
 #  Now to actually find TBB
 #
+
+# Get path, convert backslashes as ${ENV_${var}}
+getenv_path(TBB_ROOT)
+
 #start with looking for TBB_DIR and TBB_ROOT
 if((TBB_ROOT OR "$ENV{TBB_ROOT}" OR "$ENV{TBB_DIR}" ) AND NOT TBB_FOUND)
   find_package(TBB QUIET NO_MODULE NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH)
@@ -202,9 +209,6 @@ if(TBB_FOUND)
   return()
 endif()#TBB_FOUND
 
-# Get path, convert backslashes as ${ENV_${var}}
-getenv_path(TBB_ROOT)
-
 if(NOT ENV_TBB_ROOT)
   getenv_path(TBBROOT)
   set(ENV_TBB_ROOT ${ENV_TBBROOT})
@@ -253,8 +257,26 @@ if (WIN32 AND MSVC)
     set(COMPILER_PREFIX "vc11")
   elseif(MSVC_VERSION EQUAL 1800)
     set(COMPILER_PREFIX "vc12")
-  elseif(MSVC_VERSION EQUAL 1900)
+  elseif(MSVC_VERSION GREATER_EQUAL 1900 AND MSVC_VERSION LESS_EQUAL 1939)
+      # 1900-1925 actually spans three Visual Studio versions:
+      # 1900      = VS 14.0 (v140 toolset) a.k.a. MSVC 2015
+      # 1910-1919 = VS 15.0 (v141 toolset) a.k.a. MSVC 2017
+      # 1920-1929 = VS 16.0 (v142 toolset) a.k.a. MSVC 2019
+      # 1930-1939 = VS 17.0 (v143 toolset) a.k.a. MSVC 2022
+      #
+      # But these are binary compatible and TBB's open source distribution only
+      # ships a single vs14 lib (as of 2020.0)
     set(COMPILER_PREFIX "vc14")
+  else()
+    # The next poor soul who finds themselves having to decode visual studio
+    # version conventions may find these helpful:
+    # - https://cmake.org/cmake/help/latest/variable/MSVC_VERSION.html
+    # - https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
+    message(AUTHOR_WARNING
+      "Unrecognized MSVC version (${MSVC_VERSION}). "
+      "Please update FindTBB.cmake. "
+      "Some TBB_* CMake variables may need to be set manually."
+    )
   endif ()
 
   # for each prefix path, add ia32/64\${COMPILER_PREFIX}\lib to the lib search path
@@ -351,7 +373,6 @@ endforeach ()
 set(TBB_LIBRARY_NAMES tbb)
 get_debug_names(TBB_LIBRARY_NAMES)
 
-
 find_path(TBB_INCLUDE_DIR
           NAMES tbb/tbb.h
           PATHS ${TBB_INC_SEARCH_PATH})
@@ -411,12 +432,18 @@ findpkg_finish(TBB_MALLOC_PROXY tbbmalloc_proxy)
 
 
 #=============================================================================
-#parse all the version numbers from tbb
+# Parse all the version numbers from tbb.
 if(NOT TBB_VERSION)
+  if(EXISTS "${TBB_INCLUDE_DIR}/tbb/version.h")
+    # The newer oneTBB provides tbb/version.h but no tbb/tbb_stddef.h.
+    set(version_file "${TBB_INCLUDE_DIR}/tbb/version.h")
+  else()
+    # Older TBB provides tbb/tbb_stddef.h but no tbb/version.h.
+    set(version_file "${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h")
+  endif()
 
- #only read the start of the file
   file(STRINGS
-      "${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h"
+      "${version_file}"
       TBB_VERSION_CONTENTS
       REGEX "VERSION")
 
@@ -436,4 +463,5 @@ if(NOT TBB_VERSION)
         ".*#define TBB_COMPATIBLE_INTERFACE_VERSION ([0-9]+).*" "\\1"
         TBB_COMPATIBLE_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
 
+  set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}")
 endif()