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

remove CGAL_static_assertion*

This commit is contained in:
Sébastien Loriot 2023-04-28 22:55:14 +02:00
parent e54408370b
commit c8a88b9014
221 changed files with 658 additions and 664 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;

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

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

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

@ -35,7 +35,7 @@
#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)); \
\

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

52
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,12 @@ void test_algebraic_structure_intern( const CGAL::Integral_domain_tag& ) {
CGAL_SNAP_AST_FUNCTORS(AST);
using CGAL::Null_functor;
CGAL_static_assertion(
static_assert(
(!::std::is_same< Integral_division, Null_functor >::value));
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< 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 +206,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 +268,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 +387,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 +613,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 +649,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 +675,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 +803,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 +816,14 @@ void test_algebraic_structure(){
using CGAL::Integral_domain_without_division_tag;
using CGAL::Null_functor;
// Test for desired exactness
CGAL_static_assertion(
static_assert(
( ::std::is_same< typename AST::Is_exact, Is_exact >::value));
CGAL_static_assertion(( ::boost::is_convertible< Tag,
static_assert(( ::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< 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 +943,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);

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

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

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

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

@ -7,32 +7,32 @@
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(
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(
static_assert(
(::std::is_same<int, second_argument_type>::value));
}

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

@ -481,16 +481,16 @@ public:
Curve_analysis_2 _construct_defining_polynomial_from(Bound b) const {
typedef CGAL::Fraction_traits<Bound> FT;
// We rely on the fact that the Bound is a fraction
CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
static_assert((::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value));
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));
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 Num_coercion::Cast num_cast;
@ -2541,16 +2541,16 @@ public:
Polynomial_1 operator() (const Polynomial_2& f, Bound b) const {
typedef CGAL::Fraction_traits<Bound> FT;
// We rely on the fact that the Bound is a fraction
CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
static_assert((::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value));
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));
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 Num_coercion::Cast num_cast;

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

6
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,12 +224,12 @@ template<typename Poly_coer_1,typename Polynomial_1>
void cast_back_utcf(const Poly_coer_1& p,Polynomial_1& q) {
// We can assume that both template arguments are polynomial types
typedef CGAL::Fraction_traits<Poly_coer_1> FT;
CGAL_static_assertion((::std::is_same<typename FT::Is_fraction,
static_assert((::std::is_same<typename FT::Is_fraction,
CGAL::Tag_true>::value));
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));
Numerator p_num;

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

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

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

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

16
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,13 +104,13 @@ 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));
@ -118,7 +118,7 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
CGAL_CHECK_UFUNCTION(Make_square_free_2,Polynomial_2,Polynomial_2);
// TODO: missing check for Square_free_factorize_2
CGAL_CHECK_BFUNCTION(Is_coprime_2,Polynomial_2,Polynomial_2,bool);
CGAL_static_assertion(( ::std::is_same
static_assert(( ::std::is_same
<bool,typename Make_coprime_2::result_type>::value));
CGAL_CHECK_BFUNCTION(Number_of_solutions_2,Polynomial_2,Polynomial_2,
size_type);
@ -128,7 +128,7 @@ void test_algebraic_kernel_2(const AlgebraicKernel_2& ak_2) {
CGAL_CHECK_UFUNCTION(Compute_polynomial_y_2,Algebraic_real_2,Polynomial_1);
CGAL_CHECK_BFUNCTION(Isolate_x_2,Algebraic_real_2,Polynomial_1,BInterval);
CGAL_CHECK_BFUNCTION(Isolate_y_2,Algebraic_real_2,Polynomial_1,BInterval);
CGAL_static_assertion(( ::std::is_same
static_assert(( ::std::is_same
< BArray,typename Isolate_2::result_type>::value));
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);

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;

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

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

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;

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

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

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((boost::is_convertible<A_point, Res_point>::value));
static_assert((boost::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((boost::is_convertible<A_xcv, Res_xcv>::value));
static_assert((boost::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>

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

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

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

@ -100,8 +100,8 @@ public:
typedef Algebraic_point_2 Point_2;
CGAL_static_assertion((std::is_same<Integer, Coefficient>::value));
CGAL_static_assertion((std::is_same<Polynomial_1,
static_assert((std::is_same<Integer, Coefficient>::value));
static_assert((std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value));
public:

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

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

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

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

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

@ -77,7 +77,7 @@ 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));

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

@ -67,7 +67,7 @@ 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));

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

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

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

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
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_agg_meta_traits.h
View File

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

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

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

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)

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

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

32
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,7 +1524,7 @@ namespace CGAL {
template < class Ite >
std::ostream& display_orbits(std::ostream & aos) const
{
CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
static_assert( (std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) );
unsigned int nb = 0;
size_type amark = get_new_mark();
@ -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;

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

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

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

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

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;

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

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

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.

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

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

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

12
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,7 +468,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 && delta1<delta2 &&
static_assert( (0<=Ai && delta1<delta2 &&
Ai+delta2<=Map::dimension &&
delta1>1) );
@ -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.

32
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,7 +1347,7 @@ namespace CGAL {
template < class Ite >
std::ostream& display_orbits(std::ostream & aos) const
{
CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
static_assert( (std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) );
unsigned int nb = 0;
size_type amark = get_new_mark();
@ -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");

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

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

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;

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

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

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.

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

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

2
Installation/include/CGAL/Installation/internal/deprecation_warning.h
View File

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

2
Installation/test/Installation/test_configuration_qt5.cpp
View File

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

4
Intersections_2/include/CGAL/Intersection_traits.h
View File

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

2
Intersections_3/include/CGAL/Intersections_3/internal/Bbox_3_Segment_3_do_intersect.h
View File

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

2
Interval_support/include/CGAL/Test/_test_bigfloat_interval_traits.h
View File

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

2
Interval_support/include/CGAL/Test/_test_convert_to_bfi.h
View File

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

6
Interval_support/include/CGAL/Test/_test_interval_traits.h
View File

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

2
Kernel_23/include/CGAL/Circle_2.h
View File

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

2
Kernel_23/include/CGAL/Circle_3.h
View File

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

2
Kernel_23/include/CGAL/Direction_2.h
View File

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

2
Kernel_23/include/CGAL/Direction_3.h
View File

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

4
Kernel_23/include/CGAL/Has_conversion.h
View File

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

2
Kernel_23/include/CGAL/Iso_cuboid_3.h
View File

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

2
Kernel_23/include/CGAL/Iso_rectangle_2.h
View File

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

2
Kernel_23/include/CGAL/Line_2.h
View File

@ -41,7 +41,7 @@ class Line_2 : public R_::Kernel_base::Line_2
typedef typename R_::Kernel_base::Line_2 RLine_2;
typedef Line_2 Self;
CGAL_static_assertion((std::is_same<Self, typename R_::Line_2>::value));
static_assert((std::is_same<Self, typename R_::Line_2>::value));
public:

2
Kernel_23/include/CGAL/Line_3.h
View File

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

2
Kernel_23/include/CGAL/Plane_3.h
View File

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

2
Kernel_23/include/CGAL/Point_2.h
View File

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

2
Kernel_23/include/CGAL/Point_3.h
View File

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

2
Kernel_23/include/CGAL/Ray_2.h
View File

@ -42,7 +42,7 @@ class Ray_2 : public R_::Kernel_base::Ray_2
typedef typename R_::Kernel_base::Ray_2 RRay_2;
typedef Ray_2 Self;
CGAL_static_assertion((std::is_same<Self, typename R_::Ray_2>::value));
static_assert((std::is_same<Self, typename R_::Ray_2>::value));
public:

2
Kernel_23/include/CGAL/Ray_3.h
View File

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

2
Kernel_23/include/CGAL/Segment_2.h
View File

@ -40,7 +40,7 @@ class Segment_2 : public R_::Kernel_base::Segment_2
typedef typename R_::Kernel_base::Segment_2 RSegment_2;
typedef Segment_2 Self;
CGAL_static_assertion((std::is_same<Self, typename R_::Segment_2>::value));
static_assert((std::is_same<Self, typename R_::Segment_2>::value));
public:

2
Kernel_23/include/CGAL/Segment_3.h
View File

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

2
Kernel_23/include/CGAL/Sphere_3.h
View File

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

2
Kernel_23/include/CGAL/Tetrahedron_3.h
View File

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

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