songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

merge cgal/master

This commit is contained in:
Andreas Fabri 2023-06-24 10:24:15 +01:00
parent 518c32e193 f7a78677fc
commit 0f4f903f60
358 changed files with 4651 additions and 3572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
AABB_tree/include/CGAL/AABB_tree/internal/AABB_ray_intersection.h
View File

@ -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

8
AABB_tree/test/AABB_tree/aabb_test_is_ray_intersection_geomtraits.cpp
View File

@ -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");

4
Algebraic_foundations/examples/Algebraic_foundations/fraction_traits.cpp
View File

@ -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));
CGAL_static_assertion((std::is_same<Denominator_type,CGAL::Gmpz>::value));
static_assert(std::is_same<Numerator_type,CGAL::Gmpz>::value);
static_assert(std::is_same<Denominator_type,CGAL::Gmpz>::value);
Numerator_type numerator;
Denominator_type denominator;

2
Algebraic_foundations/examples/Algebraic_foundations/interoperable.cpp
View File

@ -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;

3
Algebraic_foundations/include/CGAL/Algebraic_structure_traits.h
View File

@ -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((
::std::is_same<Coercion_type_NT1_NT2 , Type >::value));
static_assert(::std::is_same<Coercion_type_NT1_NT2 , Type >::value);
typename Coercion_traits< NT1, NT2 >::Cast cast;
operator()( cast(x), cast(y), q, r );

4
Algebraic_foundations/include/CGAL/Coercion_traits.h
View File

@ -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) ); \

4
Algebraic_foundations/include/CGAL/Scalar_factor_traits.h
View File

@ -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());
}

57
Algebraic_foundations/include/CGAL/Test/_test_algebraic_structure.h
View File

@ -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(
(!::std::is_same< Integral_division, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Divides, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Is_zero, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Is_one, Null_functor >::value));
CGAL_static_assertion((!::std::is_same< Square, Null_functor >::value));
static_assert(!::std::is_same< Integral_division, Null_functor >::value);
static_assert(!::std::is_same< Divides, Null_functor >::value);
static_assert(!::std::is_same< Is_zero, Null_functor >::value);
static_assert(!::std::is_same< Is_one, Null_functor >::value);
static_assert(!::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));
CGAL_static_assertion((!::std::is_same< Mod, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Div_mod, Null_functor>::value));
static_assert(!::std::is_same< Div, Null_functor>::value);
static_assert(!::std::is_same< 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));
CGAL_static_assertion(( ::std::is_same< AS , Result_type>::value));
static_assert(::std::is_same< AS , Argument_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(
( ::std::is_same< typename AST::Is_exact, Is_exact >::value));
CGAL_static_assertion(( ::boost::is_convertible< Tag,
Integral_domain_without_division_tag >::value ));
CGAL_static_assertion(( ::std::is_same< Tag, Algebraic_category>::value));
CGAL_static_assertion((!::std::is_same< Simplify, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Unit_part, Null_functor>::value));
static_assert(::std::is_same< typename AST::Is_exact, Is_exact >::value);
static_assert(::std::is_convertible< Tag,
Integral_domain_without_division_tag >::value );
static_assert(::std::is_same< Tag, Algebraic_category>::value);
static_assert(!::std::is_same< Simplify, Null_functor>::value);
static_assert(!::std::is_same< Unit_part, Null_functor>::value);
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);
}

8
Algebraic_foundations/include/CGAL/Test/_test_coercion_traits.h
View File

@ -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));
CGAL_static_assertion((::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<result_type,Type>::value);
static_assert(::std::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value);
static_assert(::std::is_same<Type,RT>::value);
typename CT::Cast cast;
A a(3);

10
Algebraic_foundations/include/CGAL/Test/_test_fraction_traits.h
View File

@ -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));
CGAL_static_assertion( (::std::is_same<Is_fraction,Tag_true>::value));
CGAL_static_assertion(!(::std::is_same<Common_factor,Null_functor>::value));
CGAL_static_assertion(!(::std::is_same<Decompose,Null_functor>::value));
CGAL_static_assertion(!(::std::is_same<Compose,Null_functor>::value));
static_assert(::std::is_same<Type,T>::value);
static_assert(::std::is_same<Is_fraction,Tag_true>::value);
static_assert(!::std::is_same<Common_factor,Null_functor>::value);
static_assert(!::std::is_same<Decompose,Null_functor>::value);
static_assert(!::std::is_same<Compose,Null_functor>::value);
// Decompose

2
Algebraic_foundations/include/CGAL/Test/_test_rational_traits.h
View File

@ -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));

16
Algebraic_foundations/include/CGAL/Test/_test_real_embeddable.h
View File

@ -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 );

24
Algebraic_foundations/test/Algebraic_foundations/Algebraic_extension_traits.cpp
View File

@ -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);

10
Algebraic_foundations/test/Algebraic_foundations/Algebraic_structure_traits.cpp
View File

@ -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);

19
Algebraic_foundations/test/Algebraic_foundations/Coercion_traits.cpp
View File

@ -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));
CGAL_static_assertion(
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
CGAL_static_assertion(
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
static_assert( std::is_same<CT::Type,int>::value);
static_assert( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value);
static_assert( 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));
CGAL_static_assertion(
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion(
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion(
( std::is_same<CT::Cast,CGAL::Null_functor>::value));
// static_assert( std::is_same<CT::Type,CGAL::Null_type>::value);
static_assert(std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value);
static_assert(std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value);
static_assert(std::is_same<CT::Cast,CGAL::Null_functor>::value);
}
}

6
Algebraic_foundations/test/Algebraic_foundations/Real_embeddable_traits.cpp
View File

@ -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);

16
Algebraic_foundations/test/Algebraic_foundations/Scalar_factor_traits.cpp
View File

@ -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));
CGAL_static_assertion((::std::is_same<int, SFT::Scalar>::value));
static_assert(::std::is_same<int, SFT::Type>::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(
(::std::is_same<int&, first_argument_type>::value));
static_assert(::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(
(::std::is_same<int, second_argument_type>::value));
static_assert(::std::is_same<int, second_argument_type>::value);
}
int i;

24
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Algebraic_curve_kernel_2.h
View File

@ -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,
CGAL::Tag_true>::value));
static_assert(::std::is_same<typename FT::Is_fraction,
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,
CGAL::Tag_true>::value));
static_assert(::std::is_same<typename FT::Is_fraction,
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;

2
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Algebraic_real_d_1.h
View File

@ -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));

10
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/algebraic_curve_kernel_2_tools.h
View File

@ -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,
CGAL::Tag_true>::value));
static_assert(::std::is_same<typename FT::Is_fraction,
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);

16
Algebraic_kernel_d/test/Algebraic_kernel_d/Real_embeddable_traits_extension.cpp
View File

@ -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));
CGAL_static_assertion(( ::std::is_same<Integer, Result_type>::value));
static_assert(::std::is_same<NT, Argument_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));
CGAL_static_assertion(( ::std::is_same<long, Result_type>::value));
static_assert(::std::is_same<NT, Argument_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));
CGAL_static_assertion(( ::std::is_same<Integer, Result_type>::value));
static_assert(::std::is_same<NT, Argument_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));
CGAL_static_assertion(( ::std::is_same<long, Result_type>::value));
static_assert(::std::is_same<NT, Argument_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)));

16
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_curve_kernel_2.h
View File

@ -62,20 +62,20 @@ void test_algebraic_curve_kernel_2() {
typedef AlgebraicCurveKernel_2 AK_2;
/* CGAL_static_assertion( (::std::is_same<
Algebraic_real_1, typename AK::Algebraic_real_1 >::value) );
/* static_assert(::std::is_same<
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;

10
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_1.h
View File

@ -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));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT,AT_>::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));} \
{CGAL_static_assertion(( ::std::is_same<AT2,AT2_>::value));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT1,AT1_>::value);} \
{static_assert(::std::is_same<AT2,AT2_>::value);} \
{static_assert(::std::is_same<RT,RT_>::value);} \
}
// TODO: missing check for Construct_algebraic_real_1

22
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_algebraic_kernel_2.h
View File

@ -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));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT,AT_>::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));} \
{CGAL_static_assertion(( ::std::is_same<AT2,AT2_>::value));} \
{CGAL_static_assertion(( ::std::is_same<RT,RT_>::value));} \
{static_assert(::std::is_same<AT1,AT1_>::value);} \
{static_assert(::std::is_same<AT2,AT2_>::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
<bool,typename Make_coprime_2::result_type>::value));
static_assert(::std::is_same
<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
< BArray,typename Isolate_2::result_type>::value));
static_assert(::std::is_same
< 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);

16
Algebraic_kernel_d/test/Algebraic_kernel_d/include/CGAL/_test_real_comparable.h
View File

@ -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));
CGAL_static_assertion((::std::is_same<double, Result_type>::value));
static_assert(::std::is_same<NT, Argument_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));
CGAL_static_assertion((::std::is_same< typename Argument_type::Interval, Result_type>::value));
static_assert(::std::is_same<NT, Argument_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 );

6
Alpha_shapes_2/include/CGAL/Alpha_shape_2.h
View File

@ -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) );
CGAL_static_assertion( (std::is_same<NT, typename Dt::Vertex::NT>::value) );
static_assert(std::is_same<NT, typename Dt::Face::NT>::value);
static_assert(std::is_same<NT, typename Dt::Vertex::NT>::value);
typedef typename Dt::Point Point;

1
Alpha_shapes_2/include/CGAL/Alpha_shape_vertex_base_2.h
View File

@ -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 {

8
Alpha_shapes_2/include/CGAL/Alpha_shapes_2/internal/Lazy_alpha_nt_2.h
View File

@ -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<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_2<
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<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_2<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_exact converter;
return converter(wp);

1
Alpha_shapes_2/package_info/Alpha_shapes_2/dependencies
View File

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

6
Alpha_shapes_3/include/CGAL/Alpha_shape_3.h
View File

@ -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) );
CGAL_static_assertion( (std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value) );
static_assert(std::is_same<NT,typename Dt::Cell::NT>::value);
static_assert(std::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value);
typedef typename Dt::Point Point;

8
Alpha_shapes_3/include/CGAL/Alpha_shapes_3/internal/Lazy_alpha_nt_3.h
View File

@ -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<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_3<
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<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value));
static_assert(Is_traits_point_convertible_3<
Input_traits, Kernel_approx, Kernel_exact, Weighted_tag>::value);
To_exact converter;
return converter(wp);

2
Alpha_wrap_3/examples/Alpha_wrap_3/mixed_inputs_wrap.cpp
View File

@ -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

4
Alpha_wrap_3/examples/Alpha_wrap_3/point_set_wrap.cpp
View File

@ -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;

3
Alpha_wrap_3/examples/Alpha_wrap_3/triangle_mesh_wrap.cpp
View File

@ -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;

3
Alpha_wrap_3/examples/Alpha_wrap_3/wrap_from_cavity.cpp
View File

@ -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;

2
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h
View File

@ -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:

2
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Triangle_mesh_oracle.h
View File

@ -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));

2
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Triangle_soup_oracle.h
View File

@ -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());

6
Arithmetic_kernel/test/Arithmetic_kernel/Get_arithmetic_kernel.cpp
View File

@ -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;
}

8
Arrangement_on_surface_2/include/CGAL/Arr_bounded_planar_topology_traits_2.h
View File

@ -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));
CGAL_static_assertion((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));
CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value));
static_assert(std::is_same< Left_side_category, Arr_oblivious_side_tag >::value);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value);
static_assert(std::is_same< Top_side_category, Arr_oblivious_side_tag >::value);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value);
//@}
/*! \struct

2
Arrangement_on_surface_2/include/CGAL/Arr_dcel_base.h
View File

@ -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);

8
Arrangement_on_surface_2/include/CGAL/Arr_overlay_2.h
View File

@ -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));
CGAL_static_assertion((boost::is_convertible<B_point, Res_point>::value));
static_assert(std::is_convertible<A_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));
CGAL_static_assertion((boost::is_convertible<B_xcv, Res_xcv>::value));
static_assert(std::is_convertible<A_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>

6
Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Base_rational_arc_ds_1.h
View File

@ -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));
CGAL_static_assertion((std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value));
static_assert(std::is_same<Integer,Coefficient>::value);
static_assert(std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value);
public:

6
Arrangement_on_surface_2/include/CGAL/Arr_rat_arc/Rational_arc_d_1.h
View File

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

16
Arrangement_on_surface_2/include/CGAL/Arr_spherical_topology_traits_2.h
View File

@ -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 ||
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 ||
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 ||
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 ||
std::is_same< Right_side_category, Arr_identified_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);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_contracted_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);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_identified_side_tag >::value);
//@}
/*! \struct

16
Arrangement_on_surface_2/include/CGAL/Arr_unb_planar_topology_traits_2.h
View File

@ -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 ||
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 ||
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 ||
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 ||
std::is_same< Right_side_category, Arr_open_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);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_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);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value);
//@}
/*! \struct

4
Arrangement_on_surface_2/include/CGAL/Arrangement_on_surface_2.h
View File

@ -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>

4
Arrangement_on_surface_2/include/CGAL/Arrangement_zone_2.h
View File

@ -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;

16
Arrangement_on_surface_2/test/Arrangement_on_surface_2/test_tags.cpp
View File

@ -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)
);

8
BGL/include/CGAL/boost/graph/IO/Generic_facegraph_builder.h
View File

@ -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,
// typename boost::property_traits<VPM>::value_type>::value));
// CGAL_static_assertion((std::is_same<typename Kernel::Point_3,
// typename boost::range_value<Point_container>::type>::value));
// static_assert(std::is_same<typename Kernel::Point_3,
// typename boost::property_traits<VPM>::value_type>::value);
// static_assert(std::is_same<typename Kernel::Point_3,
// typename boost::range_value<Point_container>::type>::value);
typedef typename internal_np::Lookup_named_param_def<
internal_np::vertex_normal_map_t, NamedParameters,

2
BGL/include/CGAL/boost/graph/internal/Has_member_clear.h
View File

@ -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

8
BGL/test/BGL/test_Has_member_clear.cpp
View File

@ -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;
}

18
BGL/test/BGL/test_Has_member_id.cpp
View File

@ -28,17 +28,17 @@ int main()
{
using namespace CGAL::internal;
CGAL_static_assertion(!Has_member_id<StructNoId>::value);
CGAL_static_assertion(Has_member_id<StructWithId>::value);
CGAL_static_assertion(!Has_member_id<Polyhedron::Face>::value);
CGAL_static_assertion(Has_member_id<Polyhedron_with_ids::Facet>::value);
CGAL_static_assertion(Has_member_id<Polyhedron_with_ids::FBase>::value);
CGAL_static_assertion(
static_assert(!Has_member_id<StructNoId>::value);
static_assert(Has_member_id<StructWithId>::value);
static_assert(!Has_member_id<Polyhedron::Face>::value);
static_assert(Has_member_id<Polyhedron_with_ids::Facet>::value);
static_assert(Has_member_id<Polyhedron_with_ids::FBase>::value);
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);
CGAL_static_assertion(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_2<K> >::value);
static_assert(Has_member_id<CGAL::Triangulation_vertex_base_with_id_2<K> >::value);
static_assert(Has_member_id<CGAL::Triangulation_face_base_with_id_2<K> >::value);
return 0;
}

8
BGL/test/BGL/test_Properties.cpp
View File

@ -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);

16
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_meta_traits.h
View File

@ -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 ||
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 ||
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 ||
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 ||
std::is_same<Right_side_category, Arr_open_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);
static_assert(std::is_same<Bottom_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Bottom_side_category, Arr_open_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);
static_assert(std::is_same<Right_side_category, Arr_oblivious_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;

16
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_traits_decorator.h
View File

@ -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 ||
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 ||
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 ||
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 ||
std::is_same< Right_side_category, Arr_open_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);
static_assert(std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_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);
static_assert(std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value);
class Ex_point_2
{

2
Box_intersection_d/include/CGAL/Box_intersection_d/segment_tree.h
View File

@ -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

2
Box_intersection_d/include/CGAL/box_intersection_d.h
View File

@ -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)

6
Box_intersection_d/test/Box_intersection_d/test_Has_member_report.cpp
View File

@ -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);
CGAL_static_assertion(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<S>::value);
static_assert(Has_member_report<With_report>::value);
static_assert(Has_member_report<With_report_as_a_template_member_function>::value);
return EXIT_SUCCESS;
}

14
Circulator/include/CGAL/circulator.h
View File

@ -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

2
Classification/include/CGAL/Classification/ETHZ/internal/random-forest/forest.hpp
View File

@ -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)

6
Classification/include/CGAL/Classification/Local_eigen_analysis.h
View File

@ -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)

2
Classification/include/CGAL/Classification/Sum_of_weighted_features_classifier.h
View File

@ -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)

12
Combinatorial_map/include/CGAL/Cell_iterators.h
View File

@ -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,
Tag_true>::value) );
static_assert(std::is_same<typename Ite::Basic_iterator,
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,
Tag_true>::value) );
static_assert(std::is_same<typename Ite::Basic_iterator,
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,
Tag_true>::value) );
static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value);
CGAL_assertion(amap.is_whole_map_unmarked(mmark_number));
mark_cell<Map,i,dim>(amap, (*this), mmark_number);
}

34
Combinatorial_map/include/CGAL/Combinatorial_map.h
View File

@ -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,
Tag_true>::value) );
static_assert(std::is_same<typename Ite::Basic_iterator,
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);
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
static_assert(i<=dimension);
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");

50
Combinatorial_map/include/CGAL/Combinatorial_map/internal/Combinatorial_map_group_functors.h
View File

@ -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 );
CGAL_static_assertion( i!=j && (i!=1 || j!=0) );
CGAL_static_assertion_msg(CMap::Helper::template
static_assert( 1<=i && i<=CMap::dimension );
static_assert( i!=j && (i!=1 || j!=0) );
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);
CGAL_static_assertion_msg(CMap::Helper::template
static_assert(j!=0 && j!=1);
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 );
CGAL_static_assertion( i!=j );
CGAL_static_assertion_msg
static_assert( 1<=i && i<=CMap::dimension );
static_assert( i!=j );
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 );
CGAL_static_assertion( i!=j );
CGAL_static_assertion_msg
static_assert( i<=CMap::dimension );
static_assert( i!=j );
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");

8
Combinatorial_map/include/CGAL/Combinatorial_map/internal/Combinatorial_map_internal_functors.h
View File

@ -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;

16
Combinatorial_map/include/CGAL/Combinatorial_map_basic_operations.h
View File

@ -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,
Tag_false>::value) );
static_assert(std::is_same<typename Iterator::Basic_iterator,
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,
Tag_false>::value) );
static_assert(std::is_same<typename Iterator::Basic_iterator,
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,
Tag_true>::value) );
static_assert(std::is_same<typename Iterator::Basic_iterator,
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,
Tag_true>::value) );
static_assert(std::is_same<typename Iterator::Basic_iterator,
Tag_true>::value);
CGAL_assertion( (is_whole_orbit_unmarked<Map,
CMap_non_basic_iterator<Map,Iterator> >
(amap, adart, amark)) );

12
Combinatorial_map/include/CGAL/Combinatorial_map_iterators_base.h
View File

@ -305,8 +305,8 @@ namespace CGAL {
typedef typename Map::size_type size_type;
CGAL_static_assertion( (Bi<=Map::dimension &&
std::is_same<Ite_has_stack,Tag_false>::value) );
static_assert(Bi<=Map::dimension &&
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,
Tag_true>::value) );
static_assert(std::is_same<typename Base::Basic_iterator,
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,
Tag_true>::value) );
static_assert(std::is_same<typename Base::Basic_iterator,
Tag_true>::value);
/// Main constructor.
CMap_non_basic_iterator(Map& amap, Dart_descriptor adart):

4
Combinatorial_map/include/CGAL/Combinatorial_map_operations.h
View File

@ -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;

20
Combinatorial_map/include/CGAL/Combinatorial_map_storages.h
View File

@ -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)

6
Combinatorial_map/include/CGAL/Combinatorial_map_storages_with_index.h
View File

@ -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.

4
Combinatorial_map/include/CGAL/Dart.h
View File

@ -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);

18
Combinatorial_map/include/CGAL/Dart_iterators.h
View File

@ -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.

3
Convex_hull_3/include/CGAL/Convex_hull_vertex_base_2.h
View File

@ -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

14
Convex_hull_3/test/Convex_hull_3/quick_hull_default_traits.cpp
View File

@ -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) );
CGAL_static_assertion( (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) );
CGAL_static_assertion( (std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value) );
CGAL_static_assertion( (std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value) );
CGAL_static_assertion( (std::is_same<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>,Default_traits_for_Chull_3<EPIC::Point_3>::type>::value) );
CGAL_static_assertion( (std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, boost::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value) );
static_assert(std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value);
static_assert(std::is_same<SCD,Default_traits_for_Chull_3<SCD::Point_3>::type>::value);
static_assert(std::is_same<SHD,Default_traits_for_Chull_3<SHD::Point_3>::type>::value);
static_assert(std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value);
static_assert(std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::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);
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;
}

2
Documentation/doc/Documentation/Developer_manual/cmakelist_script.txt
View File

@ -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

5
Documentation/doc/Documentation/Preliminaries.txt
View File

@ -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 now based on a newer major version of the standard, <a href="https://isocpp.org/wiki/faq/cpp14">C++14</a>.
\cgal is based on the version C++17 of the C++ standard.
\section preliminaries_secchecks Checks

10
Documentation/doc/Documentation/Third_party.txt
View File

@ -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>} |
| | `Clang` \cgalFootnote{<A HREF="https://clang.llvm.org/">\cgalFootnoteCode{https://clang.llvm.org/}</A>} compiler version 13.0.1 |
| Linux | \gnu `g++` 11.3.0 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
| | `Clang` \cgalFootnote{<A HREF="https://clang.llvm.org/">\cgalFootnoteCode{https://clang.llvm.org/}</A>} compiler version 15.0.7 |
| \ms Windows | \gnu `g++` 10.2.1 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
| | \ms Visual `C++` 14.0, 15.9, 16.10, 17.0 (\visualstudio 2015, 2017, 2019, and 2022)\cgalFootnote{<A HREF="https://visualstudio.microsoft.com/">\cgalFootnoteCode{https://visualstudio.microsoft.com/}</A>} |
| MacOS X | \gnu `g++` 10.2.1 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
| | \ms Visual `C++` 15.9, 16.10, 17.0 (\visualstudio 2017, 2019, and 2022)\cgalFootnote{<A HREF="https://visualstudio.microsoft.com/">\cgalFootnoteCode{https://visualstudio.microsoft.com/}</A>} |
| MacOS X | \gnu `g++` 11.3.0 or later\cgalFootnote{<A HREF="https://gcc.gnu.org/">\cgalFootnoteCode{https://gcc.gnu.org/}</A>} |
| | Apple `Clang` compiler versions 10.0.1, 12.0.5, and 13.0.0 |
<!-- Windows supported version are also listed on windows.html (must change both) -->

2
Documentation/doc/Documentation/Tutorials/Tutorial_reconstruction.txt
View File

@ -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

2
Documentation/doc/Documentation/windows.txt
View File

@ -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.

3
Documentation/doc/resources/1.8.13/menu_version.js
View File

@ -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',

3
Documentation/doc/resources/1.9.6/menu_version.js
View File

@ -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',

4
Filtered_kernel/include/CGAL/Filtered_kernel.h
View File

@ -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>

1
Filtered_kernel/include/CGAL/Lazy_kernel.h
View File

@ -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)

8
Generalized_map/include/CGAL/GMap_cell_iterators.h
View File

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

14
Generalized_map/include/CGAL/GMap_dart_iterators.h
View File

@ -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.

34
Generalized_map/include/CGAL/Generalized_map.h
View File

@ -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,
Tag_true>::value) );
static_assert(std::is_same<typename Ite::Basic_iterator,
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);
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
static_assert(i<=dimension);
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");

28
Generalized_map/include/CGAL/Generalized_map/internal/Generalized_map_group_functors.h
View File

@ -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 );
CGAL_static_assertion( i!=j );
CGAL_static_assertion_msg(GMap::Helper::template
static_assert( i<=GMap::dimension );
static_assert( i!=j );
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 );
CGAL_static_assertion( i!=j );
CGAL_static_assertion_msg
static_assert( i<=GMap::dimension );
static_assert( i!=j );
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 );
CGAL_static_assertion( i!=j );
CGAL_static_assertion_msg
static_assert( i<=GMap::dimension );
static_assert( i!=j );
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");

4
Generalized_map/include/CGAL/Generalized_map_iterators_base.h
View File

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

4
Generalized_map/include/CGAL/Generalized_map_operations.h
View File

@ -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;

21
Generalized_map/include/CGAL/Generalized_map_storages.h
View File

@ -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)

6
Generalized_map/include/CGAL/Generalized_map_storages_with_index.h
View File

@ -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.

4
Heat_method_3/include/CGAL/Heat_method_3/Surface_mesh_geodesic_distances_3.h
View File

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

331
Installation/CHANGES.md
View File

@ -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)
- 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.
### [Shape Detection](https://doc.cgal.org/5.6/Manual/packages.html#PkgShapeDetection) (major changes)
### [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)
- 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`.
### [Polygon Mesh Processing](https://doc.cgal.org/5.6/Manual/packages.html#PkgPolygonMeshProcessing)
- **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.
- **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`
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` now returns 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](https://doc.cgal.org/latest/BGL/group__bgl__namedparameters.html) 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)
- 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)
### [2D Straight Skeleton and Polygon Offsetting](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)
- Exposed all required member functions of the `GeneralPolygonWithHoles_2` concept (e.g., `clear_outer_boundary()`, `clear_holes()`, and `clear()`).
See also the [news entry](https://www.cgal.org/2023/05/09/improved_straight_skeleton/).
### [Polygon](https://doc.cgal.org/5.6/Manual/packages.html#PkgPolygon2)
- 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.
### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.6/Manual/packages.html#PkgKernel23)
- 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

2
Installation/CMakeLists.txt
View File

@ -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)

9
Installation/cmake/modules/CGAL_Eigen3_support.cmake
View File

@ -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()

15
Installation/cmake/modules/CGAL_SetupCGALDependencies.cmake
View File

@ -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")

2
Installation/cmake/modules/CGAL_pointmatcher_support.cmake
View File

@ -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()

52
Installation/cmake/modules/FindTBB.cmake
View File

@ -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.")
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()

Some files were not shown because too many files have changed in this diff Show More