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

Merge branch 'CGAL:master' into Region_growing-revision-soesau

This commit is contained in:
Sven Oesau 2022-09-02 16:42:41 +02:00 committed by GitHub
parent 421c88d363 585d0dc3dd
commit 80eb8601e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
347 changed files with 1700 additions and 1592 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
AABB_tree/include/CGAL/AABB_halfedge_graph_segment_primitive.h
View File

@ -23,9 +23,8 @@
#include <iterator>
#include <boost/mpl/and.hpp>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/if.hpp>
#include <CGAL/Default.h>

9
AABB_tree/include/CGAL/AABB_polyhedron_segment_primitive.h
View File

@ -26,8 +26,7 @@
#define CGAL_REPLACEMENT_HEADER "<CGAL/AABB_halfedge_graph_segment_primitive.h>"
#include <CGAL/Installation/internal/deprecation_warning.h>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
namespace CGAL {
@ -80,9 +79,9 @@ namespace CGAL {
: m_halfedge_handle(*ptr) { };
template <class Iterator>
AABB_polyhedron_segment_primitive( Iterator it,
typename boost::enable_if<
boost::is_same<Id,typename Iterator::value_type>
>::type* =0
std::enable_if_t<
std::is_same<Id,typename Iterator::value_type>::value
>* =0
) : m_halfedge_handle(*it) { }
AABB_polyhedron_segment_primitive(const Self& primitive)

9
AABB_tree/include/CGAL/AABB_polyhedron_triangle_primitive.h
View File

@ -22,8 +22,7 @@
#define CGAL_REPLACEMENT_HEADER "<CGAL/AABB_face_graph_triangle_primitive.h>"
#include <CGAL/Installation/internal/deprecation_warning.h>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
namespace CGAL {
/// \ingroup PkgAABBTreeRef
@ -76,9 +75,9 @@ namespace CGAL {
: m_facet_handle(*ptr) { };
template <class Iterator>
AABB_polyhedron_triangle_primitive( Iterator it,
typename boost::enable_if<
boost::is_same<Id,typename Iterator::value_type>
>::type* =0
std::enable_if_t<
std::is_same<Id,typename Iterator::value_type>::value
>* =0
) : m_facet_handle(*it) { }

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

@ -18,8 +18,8 @@
#include <functional>
#include <type_traits>
#include <boost/optional.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/variant/apply_visitor.hpp>
# if defined(BOOST_MSVC)
# pragma warning(push)
@ -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((boost::is_same<Ray, typename AABBTraits::Ray_3>::value),
CGAL_static_assertion_msg((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

9
AABB_tree/include/CGAL/AABB_triangulation_3_triangle_primitive.h
View File

@ -18,8 +18,7 @@
#include <CGAL/disable_warnings.h>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
namespace CGAL {
// \ingroup PkgAABBTreeRef
@ -68,9 +67,9 @@ namespace CGAL {
: m_facet(*ptr) { }
template <class Iterator>
AABB_triangulation_3_triangle_primitive( Iterator it,
typename boost::enable_if<
boost::is_same<Id,typename Iterator::value_type>
>::type* =0
std::enable_if_t<
std::is_same<Id,typename Iterator::value_type>::value
>* =0
) : m_facet(*it) { }

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

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

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

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

@ -23,9 +23,9 @@
#define CGAL_COERCION_TRAITS_H 1
#include <iterator>
#include <type_traits>
#include <CGAL/boost/iterator/transform_iterator.hpp>
#include <boost/type_traits/is_same.hpp>
#include <CGAL/tags.h>
@ -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((::boost::is_same< \
CGAL_static_assertion((::std::is_same< \
typename Coercion_traits< CT_Type_1, CT_Type_2 >::Type, NT \
>::value)); \
\

11
Algebraic_foundations/include/CGAL/Rational_traits.h
View File

@ -21,7 +21,8 @@
#include <CGAL/number_type_basic.h>
#include <CGAL/Fraction_traits.h>
#include <CGAL/is_convertible.h>
#include <boost/utility/enable_if.hpp>
#include <type_traits>
namespace CGAL {
@ -79,11 +80,11 @@ public:
{ return make_rational(x.first, x.second); }
template<class N,class D>
Rational make_rational(const N& n, const D& d,typename boost::enable_if_c<is_implicit_convertible<N,RT>::value&&is_implicit_convertible<D,RT>::value,int>::type=0) const
Rational make_rational(const N& n, const D& d,std::enable_if_t<is_implicit_convertible<N,RT>::value&&is_implicit_convertible<D,RT>::value,int> = 0) const
{ return Compose()(n,d); }
template<class N,class D>
Rational make_rational(const N& n, const D& d,typename boost::enable_if_c<!is_implicit_convertible<N,RT>::value||!is_implicit_convertible<D,RT>::value,int>::type=0) const
Rational make_rational(const N& n, const D& d,std::enable_if_t<!is_implicit_convertible<N,RT>::value||!is_implicit_convertible<D,RT>::value,int> = 0) const
{ return n/d; } // Assume that n or d is already a fraction
};
}// namespace internal
@ -92,9 +93,9 @@ public:
template <class T>
class Rational_traits
: public internal::Rational_traits_base<T,
::boost::is_same<typename Fraction_traits<T>::Is_fraction,Tag_true>::value
::std::is_same<typename Fraction_traits<T>::Is_fraction,Tag_true>::value
&&
::boost::is_same<
::std::is_same<
typename Fraction_traits<T>::Numerator_type,
typename Fraction_traits<T>::Denominator_type
>::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(( ::boost::is_same< NT,Scalar >::value));
CGAL_static_assertion(( ::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(( ::boost::is_same< NT,Scalar >::value));
CGAL_static_assertion(( ::std::is_same< NT,Scalar >::value));
typedef typename Algebraic_structure_traits<NT>::Algebraic_category SAT;
return scalar_factor(a,d,SAT());
}

50
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((::boost::is_same<result_type,ResultType>::value));
CGAL_static_assertion((::std::is_same<result_type,ResultType>::value));
CGAL_USE_TYPE(result_type);
}
// check nothing for CGAL::Null_functor
@ -123,11 +123,11 @@ void test_algebraic_structure_intern( const CGAL::Integral_domain_tag& ) {
using CGAL::Null_functor;
CGAL_static_assertion(
(!::boost::is_same< Integral_division, Null_functor >::value));
CGAL_static_assertion((!::boost::is_same< Divides, Null_functor >::value));
CGAL_static_assertion((!::boost::is_same< Is_zero, Null_functor >::value));
CGAL_static_assertion((!::boost::is_same< Is_one, Null_functor >::value));
CGAL_static_assertion((!::boost::is_same< Square, Null_functor >::value));
(!::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));
// 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((!::boost::is_same< Gcd, Null_functor>::value));
CGAL_static_assertion((!::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((!::boost::is_same< Div, Null_functor>::value));
CGAL_static_assertion((!::boost::is_same< Mod, Null_functor>::value));
CGAL_static_assertion((!::boost::is_same< Div_mod, Null_functor>::value));
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));
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((!::boost::is_same< Sqrt, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Sqrt, Null_functor>::value));
const Sqrt sqrt =Sqrt();
AS a(4);
@ -614,10 +614,10 @@ class Test_is_square {
CGAL_USE_TYPE(Second_argument_type);
CGAL_static_assertion(
( ::boost::is_same< AS , First_argument_type>::value));
( ::std::is_same< AS , First_argument_type>::value));
CGAL_static_assertion(
( ::boost::is_same< AS& , Second_argument_type>::value));
//CGAL_static_assertion(( ::boost::is_same< bool , Result_type>::value));
( ::std::is_same< AS& , Second_argument_type>::value));
//CGAL_static_assertion(( ::std::is_same< bool , Result_type>::value));
bool b = Result_type(true); CGAL_USE(b);
AS test_number = AS(3)*AS(3);
@ -649,8 +649,8 @@ public:
typedef typename Sqrt::result_type Result_type;
CGAL_USE_TYPE(Argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(( ::boost::is_same< AS , Argument_type>::value));
CGAL_static_assertion(( ::boost::is_same< AS , Result_type>::value));
CGAL_static_assertion(( ::std::is_same< AS , Argument_type>::value));
CGAL_static_assertion(( ::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)));
@ -676,11 +676,11 @@ public:
CGAL_USE_TYPE(Second_argument_type);
CGAL_USE_TYPE(Result_type);
CGAL_static_assertion(
( ::boost::is_same<int, First_argument_type>::value));
( ::std::is_same<int, First_argument_type>::value));
CGAL_static_assertion(
( ::boost::is_same< AS , Second_argument_type>::value));
( ::std::is_same< AS , Second_argument_type>::value));
CGAL_static_assertion(
( ::boost::is_same< AS , Result_type>::value));
( ::std::is_same< AS , Result_type>::value));
AS epsilon(1);
assert( test_equality_epsilon( AS (2),
root( 4, AS (16) ), epsilon ) );
@ -803,7 +803,7 @@ void test_algebraic_structure(){
typedef CGAL::Algebraic_structure_traits< AS > AST;
CGAL_SNAP_AST_FUNCTORS(AST);
CGAL_static_assertion((::boost::is_same<AS,typename AST::Type>::value));
CGAL_static_assertion((::std::is_same<AS,typename AST::Type>::value));
typedef typename AST::Boolean Boolean;
assert(!Boolean());
@ -817,13 +817,13 @@ void test_algebraic_structure(){
using CGAL::Null_functor;
// Test for desired exactness
CGAL_static_assertion(
( ::boost::is_same< typename AST::Is_exact, Is_exact >::value));
( ::std::is_same< typename AST::Is_exact, Is_exact >::value));
CGAL_static_assertion(( ::boost::is_convertible< Tag,
Integral_domain_without_division_tag >::value ));
CGAL_static_assertion(( ::boost::is_same< Tag, Algebraic_category>::value));
CGAL_static_assertion((!::boost::is_same< Simplify, Null_functor>::value));
CGAL_static_assertion((!::boost::is_same< Unit_part, Null_functor>::value));
CGAL_static_assertion(( ::std::is_same< Tag, Algebraic_category>::value));
CGAL_static_assertion((!::std::is_same< Simplify, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< Unit_part, Null_functor>::value));
const Simplify simplify=Simplify();;
const Unit_part unit_part= Unit_part();
@ -944,7 +944,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(
!(::boost::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
!(::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
CGAL_USE_TYPE(Is_numerical_sensitive);
}

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

@ -327,8 +327,8 @@ void test_implicit_interoperable_one_way() {
typedef typename CT::Are_implicit_interoperable Are_implicit_interoperable;
CGAL_static_assertion(
(::boost::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
assert((::boost::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
(::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
assert((::std::is_same<Are_implicit_interoperable, CGAL::Tag_true>::value));
typename CGAL::Real_embeddable_traits<C>::Is_real_embeddable is_real_embeddable;
test_implicit_interoperable_for_real_embeddable<A,B>(is_real_embeddable);
@ -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((::boost::is_same<result_type,Type>::value));
CGAL_static_assertion((::boost::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
CGAL_static_assertion((::boost::is_same<Type,RT>::value));
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));
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( (::boost::is_same<Type,T>::value));
CGAL_static_assertion( (::boost::is_same<Is_fraction,Tag_true>::value));
CGAL_static_assertion(!(::boost::is_same<Common_factor,Null_functor>::value));
CGAL_static_assertion(!(::boost::is_same<Decompose,Null_functor>::value));
CGAL_static_assertion(!(::boost::is_same<Compose,Null_functor>::value));
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));
// 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((::boost::is_same<RT,RT>::value));
CGAL_static_assertion((::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(( ::boost::is_same<Type, Argument_type>::value));
CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
CGAL_USE_TYPE(Argument_type);
CGAL_static_assertion(( ::boost::is_same<double, Result_type>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same<Type, Argument_type>::value));
CGAL_static_assertion(( ::std::is_same<Type, Argument_type>::value));
CGAL_USE_TYPE(Argument_type);
CGAL_static_assertion(( ::boost::is_same<Interval_type, Result_type>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same< Is_real_embeddable, Tag_true>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same< Is_real_embeddable, Tag_false>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same< CeilLog2Abs, Null_functor>::value));
// CGAL_static_assertion(( ::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((!::boost::is_same< CeilLog2Abs, Null_functor>::value));
// CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
//
// assert( fl_log(Type( 7)) == 2 );
// assert( cl_log(Type( 7)) == 3 );

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

@ -195,7 +195,7 @@ template< class Number_type >
inline
// select a Is_zero functor
typename boost::mpl::if_c<
::boost::is_same< typename Algebraic_structure_traits< Number_type >::Is_zero,
::std::is_same< typename Algebraic_structure_traits< Number_type >::Is_zero,
Null_functor >::value ,
typename Real_embeddable_traits< Number_type >::Is_zero,
typename Algebraic_structure_traits< Number_type >::Is_zero
@ -204,7 +204,7 @@ is_zero( const Number_type& x ) {
// We take the Algebraic_structure_traits<>::Is_zero functor by default. If it
// is not available, we take the Real_embeddable_traits functor
typename ::boost::mpl::if_c<
::boost::is_same<
::std::is_same<
typename Algebraic_structure_traits< Number_type >::Is_zero,
Null_functor >::value ,
typename Real_embeddable_traits< Number_type >::Is_zero,

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((::boost::is_same<int,Type>::value));
CGAL_static_assertion((::std::is_same<int,Type>::value));
typedef AET::Is_extended Is_extended;
CGAL_USE_TYPE(Is_extended);
CGAL_static_assertion(
(::boost::is_same<CGAL::Tag_false,Is_extended>::value));
(::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((::boost::is_same<argument_type,int>::value));
CGAL_static_assertion((::std::is_same<argument_type,int>::value));
typedef Normalization_factor::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::boost::is_same<result_type,int>::value));
CGAL_static_assertion((::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((::boost::is_same<argument_type,int>::value));
CGAL_static_assertion((::std::is_same<argument_type,int>::value));
typedef DFAI::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::boost::is_same<result_type,int>::value));
CGAL_static_assertion((::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((::boost::is_same<EXT,Type>::value));
CGAL_static_assertion((::std::is_same<EXT,Type>::value));
typedef AET::Is_extended Is_extended;
CGAL_USE_TYPE(Is_extended);
CGAL_static_assertion(
(::boost::is_same<CGAL::Tag_true,Is_extended>::value));
(::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((::boost::is_same<argument_type,EXT>::value));
CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
typedef Normalization_factor::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::boost::is_same<result_type,EXT>::value));
CGAL_static_assertion((::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((::boost::is_same<argument_type,EXT>::value));
CGAL_static_assertion((::std::is_same<argument_type,EXT>::value));
typedef DFAI::result_type result_type;
CGAL_USE_TYPE(result_type);
CGAL_static_assertion((::boost::is_same<result_type,EXT>::value));
CGAL_static_assertion((::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

@ -8,7 +8,7 @@
typedef AST::NAME NAME; \
CGAL_USE_TYPE(NAME); \
CGAL_static_assertion( \
(::boost::is_same<CGAL::Null_functor,NAME>::value)); \
(::std::is_same<CGAL::Null_functor,NAME>::value)); \
}
int main(){
@ -16,19 +16,19 @@ int main(){
typedef AST::Type Type;
CGAL_USE_TYPE(Type);
CGAL_static_assertion((::boost::is_same<void,Type>::value));
CGAL_static_assertion((::std::is_same<void,Type>::value));
typedef AST::Algebraic_category Algebraic_category;
CGAL_USE_TYPE(Algebraic_category);
CGAL_static_assertion(
(::boost::is_same<CGAL::Null_tag,Algebraic_category>::value));
(::std::is_same<CGAL::Null_tag,Algebraic_category>::value));
typedef AST::Is_exact Is_exact;
CGAL_USE_TYPE(Is_exact);
CGAL_static_assertion((::boost::is_same<CGAL::Null_tag,Is_exact>::value));
CGAL_static_assertion((::std::is_same<CGAL::Null_tag,Is_exact>::value));
typedef AST::Is_numerical_sensitive Is_sensitive;
CGAL_USE_TYPE(Is_sensitive);
CGAL_static_assertion((::boost::is_same<CGAL::Null_tag,Is_sensitive>::value));
CGAL_static_assertion((::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(( boost::is_same<CT::Type,int>::value));
CGAL_static_assertion(( std::is_same<CT::Type,int>::value));
CGAL_static_assertion(
( boost::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_true>::value));
CGAL_static_assertion(
( boost::is_same<CT::Are_explicit_interoperable,CGAL::Tag_true>::value));
( 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(( boost::is_same<CT::Type,CGAL::Null_type>::value));
// CGAL_static_assertion(( std::is_same<CT::Type,CGAL::Null_type>::value));
CGAL_static_assertion(
( boost::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
( std::is_same<CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion(
( boost::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
( std::is_same<CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion(
( boost::is_same<CT::Cast,CGAL::Null_functor>::value));
( std::is_same<CT::Cast,CGAL::Null_functor>::value));
}
}

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

@ -8,7 +8,7 @@
typedef RET::NAME NAME; \
CGAL_USE_TYPE(NAME); \
CGAL_static_assertion( \
(::boost::is_same<CGAL::Null_functor,NAME>::value)); \
(::std::is_same<CGAL::Null_functor,NAME>::value)); \
}
int main(){
@ -16,11 +16,11 @@ int main(){
typedef RET::Type Type;
CGAL_USE_TYPE(Type);
CGAL_static_assertion((::boost::is_same<void,Type>::value));
CGAL_static_assertion((::std::is_same<void,Type>::value));
typedef RET::Is_real_embeddable Is_real_embeddable;
CGAL_USE_TYPE(Is_real_embeddable);
CGAL_static_assertion((::boost::is_same<CGAL::Tag_false,Is_real_embeddable>::value));
CGAL_static_assertion((::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,33 +7,33 @@
int main(){
typedef CGAL::Scalar_factor_traits<int> SFT;
CGAL_USE_TYPE(SFT);
CGAL_static_assertion((::boost::is_same<int, SFT::Type>::value));
CGAL_static_assertion((::boost::is_same<int, SFT::Scalar>::value));
CGAL_static_assertion((::std::is_same<int, SFT::Type>::value));
CGAL_static_assertion((::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((::boost::is_same<int, result_type>::value));
CGAL_static_assertion((::std::is_same<int, result_type>::value));
typedef Scalar_factor::argument_type argument_type;
CGAL_USE_TYPE(argument_type);
CGAL_static_assertion((::boost::is_same<int, argument_type>::value));
CGAL_static_assertion((::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((::boost::is_same<void, result_type>::value));
CGAL_static_assertion((::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(
(::boost::is_same<int&, first_argument_type>::value));
(::std::is_same<int&, first_argument_type>::value));
typedef Scalar_div::second_argument_type second_argument_type;
CGAL_USE_TYPE(second_argument_type);
CGAL_static_assertion(
(::boost::is_same<int, second_argument_type>::value));
(::std::is_same<int, second_argument_type>::value));
}
int i;

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

@ -24,9 +24,9 @@
#define CGAL_ALGEBRAIC_CURVE_KERNEL_D_2_H
#include <limits>
#include <type_traits>
#include <CGAL/iterator.h>
#include <CGAL/assertions.h>
#include <boost/type_traits/is_same.hpp>
#include <boost/optional.hpp>
#include <CGAL/basic.h>
@ -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((::boost::is_same<typename FT::Is_fraction,
CGAL_static_assertion((::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((::boost::is_same
CGAL_static_assertion((::std::is_same
<Coefficient,
typename Num_coercion::Type>::value));
typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
CGAL_static_assertion((::boost::is_same
CGAL_static_assertion((::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((::boost::is_same<typename FT::Is_fraction,
CGAL_static_assertion((::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((::boost::is_same
CGAL_static_assertion((::std::is_same
<Coefficient,
typename Num_coercion::Type>::value));
typedef CGAL::Coercion_traits<Denominator,Coefficient> Denom_coercion;
CGAL_static_assertion((::boost::is_same
CGAL_static_assertion((::std::is_same
<Coefficient,
typename Denom_coercion::Type>::value));
typename Num_coercion::Cast num_cast;

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

@ -72,7 +72,7 @@ class Algebraic_real_d_1 :
// currently Rational is the only supported Bound type.
CGAL_static_assertion(
( ::boost::is_same <Rational_,
( ::std::is_same <Rational_,
typename Get_arithmetic_kernel<Coefficient_>::Arithmetic_kernel::Rational>::value));
@ -579,7 +579,7 @@ struct Coercion_traits<
typedef Type result_type;
Type operator()(const Type& a) const { return a; }
Type operator()(const Coefficient& a) const {
static const bool b = boost::is_same<Rational,typename CTCR::Type>::value;
static const bool b = std::is_same<Rational,typename CTCR::Type>::value;
return (*this)(a,Boolean_tag<b>());
}
};

3
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Curve_analysis_2.h
View File

@ -20,13 +20,12 @@
#include <vector>
#include <set>
#include <map>
#include <type_traits>
#include <boost/mpl/has_xxx.hpp>
#include <boost/type_traits/is_base_of.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/logical.hpp>
#include <boost/type_traits/is_same.hpp>
#include <CGAL/basic.h>
#include <CGAL/assertions.h>

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

@ -187,7 +187,7 @@ template<typename AlgebraicKernel_1,
InputIterator end,
OutputIterator output) {
CGAL_static_assertion
((::boost::is_same
((::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((::boost::is_same<typename FT::Is_fraction,
CGAL_static_assertion((::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((::boost::is_same
CGAL_static_assertion((::std::is_same
<Polynomial_1,
typename Num_coercion::Type>::value));
Numerator p_num;

3
Algebraic_kernel_d/include/CGAL/RS/rs2_calls.h
View File

@ -29,8 +29,7 @@
// the version of MPFR is one of those buggy versions, abort the compilation
// and instruct the user to update MPFR or don't use RS3.
#ifdef CGAL_USE_RS3
#include <boost/static_assert.hpp>
BOOST_STATIC_ASSERT_MSG(
static_assert(
MPFR_VERSION_MAJOR!=3 ||
MPFR_VERSION_MINOR!=1 ||
MPFR_VERSION_PATCHLEVEL<3 || MPFR_VERSION_PATCHLEVEL>6,

3
Algebraic_kernel_d/include/CGAL/RS/signat_1.h
View File

@ -14,7 +14,6 @@
#include <CGAL/Gmpfi.h>
#include <CGAL/Polynomial_traits_d.h>
#include "exact_signat_1.h"
//#include <boost/mpl/assert.hpp>
#include <gmp.h>
namespace CGAL{
@ -40,7 +39,7 @@ Signat_1<Polynomial_,Bound_>::operator()(const Bound_ &x)const{
//typedef Algebraic_structure_traits<Bound> AStraits;
// This generic signat works only when Bound_ is an exact type. For
// non-exact types, an implementation must be provided.
//BOOST_MPL_ASSERT((boost::is_same<AStraits::Is_exact,Tag_true>));
//static_assert(std::is_same<AStraits::Is_exact,Tag_true>::value);
int d=Degree()(pol);
Bound h(pol[d]);
for(int i=1;i<=d;++i)

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(( ::boost::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::boost::is_same<Integer, Result_type>::value));
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::boost::is_same<long, Result_type>::value));
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::boost::is_same<Integer, Result_type>::value));
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::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(( ::boost::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::boost::is_same<long, Result_type>::value));
CGAL_static_assertion(( ::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion(( ::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( (::boost::is_same<
/* CGAL_static_assertion( (::std::is_same<
Algebraic_real_1, typename AK::Algebraic_real_1 >::value) );
CGAL_static_assertion((::boost::is_same<
CGAL_static_assertion((::std::is_same<
Isolator,
typename AK::Isolator >::value) );
CGAL_static_assertion((::boost::is_same<
CGAL_static_assertion((::std::is_same<
Coefficient,
typename AK::Coefficient >::value));
CGAL_static_assertion((::boost::is_same<
CGAL_static_assertion((::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(( ::boost::is_same<AT,AT_>::value));} \
{CGAL_static_assertion(( ::boost::is_same<RT,RT_>::value));} \
{CGAL_static_assertion(( ::std::is_same<AT,AT_>::value));} \
{CGAL_static_assertion(( ::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(( ::boost::is_same<AT1,AT1_>::value));} \
{CGAL_static_assertion(( ::boost::is_same<AT2,AT2_>::value));} \
{CGAL_static_assertion(( ::boost::is_same<RT,RT_>::value));} \
{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));} \
}
// 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(( ::boost::is_same<AT,AT_>::value));} \
{CGAL_static_assertion(( ::boost::is_same<RT,RT_>::value));} \
{CGAL_static_assertion(( ::std::is_same<AT,AT_>::value));} \
{CGAL_static_assertion(( ::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(( ::boost::is_same<AT1,AT1_>::value));} \
{CGAL_static_assertion(( ::boost::is_same<AT2,AT2_>::value));} \
{CGAL_static_assertion(( ::boost::is_same<RT,RT_>::value));} \
{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));} \
}
CGAL_static_assertion(( ::boost::is_same
CGAL_static_assertion(( ::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(( ::boost::is_same
CGAL_static_assertion(( ::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(( ::boost::is_same
CGAL_static_assertion(( ::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((::boost::is_same<NT, Argument_type>::value));
CGAL_static_assertion((::boost::is_same<double, Result_type>::value));
CGAL_static_assertion((::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion((::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((::boost::is_same<NT, Argument_type>::value));
CGAL_static_assertion((::boost::is_same< typename Argument_type::Interval, Result_type>::value));
CGAL_static_assertion((::std::is_same<NT, Argument_type>::value));
CGAL_static_assertion((::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((::boost::is_same< Is_real_comparable, Tag_true>::value));
CGAL_static_assertion((::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((::boost::is_same< Is_real_comparable, Tag_false>::value));
CGAL_static_assertion((::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((::boost::is_same< CeilLog2Abs, Nulltype>::value));
CGAL_static_assertion((::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((!::boost::is_same< CeilLog2Abs, Null_functor>::value));
CGAL_static_assertion((!::std::is_same< CeilLog2Abs, Null_functor>::value));
assert( fl_log(NT( 7)) == 2 );
assert( cl_log(NT( 7)) == 3 );

2
Algebraic_kernel_for_circles/include/CGAL/Root_for_circles_2_2.h
View File

@ -22,10 +22,10 @@
#include <iostream>
#include <type_traits>
#include <CGAL/Bbox_2.h>
#include <CGAL/Root_of_traits.h>
#include <CGAL/Handle_for.h>
#include <boost/type_traits/is_same.hpp>
namespace CGAL {

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

@ -63,8 +63,8 @@ public:
// 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(
(boost::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
(boost::is_same<typename Dt::Periodic_tag, Tag_false>::value));
(std::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
(std::is_same<typename Dt::Periodic_tag, Tag_false>::value));
typedef typename internal::Alpha_nt_selector_2<
Gt, ExactAlphaComparisonTag, typename Dt::Weighted_tag>::Type_of_alpha Type_of_alpha;
@ -77,8 +77,8 @@ public:
typedef Type_of_alpha FT;
// check that simplices are correctly instantiated
CGAL_static_assertion( (boost::is_same<NT, typename Dt::Face::NT>::value) );
CGAL_static_assertion( (boost::is_same<NT, typename Dt::Vertex::NT>::value) );
CGAL_static_assertion( (std::is_same<NT, typename Dt::Face::NT>::value) );
CGAL_static_assertion( (std::is_same<NT, typename Dt::Vertex::NT>::value) );
typedef typename Dt::Point Point;

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

@ -26,8 +26,6 @@
#include <CGAL/Unique_hash_map.h>
#include <CGAL/Triangulation_utils_3.h>
#include <boost/type_traits/is_same.hpp>
#include <algorithm>
#include <iostream>
#include <map>
@ -35,6 +33,7 @@
#include <set>
#include <utility>
#include <vector>
#include <type_traits>
//-------------------------------------------------------------------
namespace CGAL {
@ -99,8 +98,8 @@ public:
// 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(
(boost::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
(boost::is_same<typename Dt::Periodic_tag, Tag_false>::value));
(std::is_same<ExactAlphaComparisonTag, Tag_false>::value) ||
(std::is_same<typename Dt::Periodic_tag, Tag_false>::value));
//extra the type used for representing alpha according to ExactAlphaComparisonTag
typedef typename internal::Alpha_nt_selector_3<Gt,ExactAlphaComparisonTag,typename Dt::Weighted_tag>::Type_of_alpha NT;
@ -109,8 +108,8 @@ public:
typedef typename Gt::FT Coord_type;
//checks whether tags are correctly set in Vertex and Cell classes
CGAL_static_assertion( (boost::is_same<NT,typename Dt::Cell::NT>::value) );
CGAL_static_assertion( (boost::is_same<NT,typename Dt::Vertex::Alpha_status::NT>::value) );
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) );
typedef typename Dt::Point Point;

6
Alpha_wrap_3/doc/Alpha_wrap_3/alpha_wrap_3.txt
View File

@ -359,6 +359,12 @@ and offset set to 1/30 of alpha (i.e., 1/600 of the bounding box diagonal edge l
\cgalExample{Alpha_wrap_3/triangle_mesh_wrap.cpp}
Some triangle soups might not be representable as a mesh due to non-manifoldness or incompatible orientations.
Such triangle soup is nevertheless a valid input for the wrapping algorithm, as illustrated
in the following example.
\cgalExample{Alpha_wrap_3/triangle_soup_wrap.cpp}
Here is an example with a point cloud.
\cgalExample{Alpha_wrap_3/point_set_wrap.cpp}

1
Alpha_wrap_3/doc/Alpha_wrap_3/examples.txt
View File

@ -1,4 +1,5 @@
/*!
\example Alpha_wrap_3/triangle_mesh_wrap.cpp
\example Alpha_wrap_3/triangle_soup_wrap.cpp
\example Alpha_wrap_3/point_set_wrap.cpp
*/

1
Alpha_wrap_3/examples/Alpha_wrap_3/CMakeLists.txt
View File

@ -8,6 +8,7 @@ find_package(CGAL REQUIRED)
# create a target per cppfile
create_single_source_cgal_program("triangle_mesh_wrap.cpp")
create_single_source_cgal_program("triangle_soup_wrap.cpp")
create_single_source_cgal_program("point_set_wrap.cpp")
create_single_source_cgal_program("wrap_from_cavity.cpp")
create_single_source_cgal_program("mixed_inputs_wrap.cpp")

76
Alpha_wrap_3/examples/Alpha_wrap_3/triangle_soup_wrap.cpp Normal file
View File

@ -0,0 +1,76 @@
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/alpha_wrap_3.h>
#include <CGAL/Polygon_mesh_processing/bbox.h>
#include <CGAL/IO/polygon_soup_io.h>
#include <CGAL/Real_timer.h>
#include <array>
#include <iostream>
#include <string>
#include <vector>
namespace AW3 = CGAL::Alpha_wraps_3;
using K = CGAL::Exact_predicates_inexact_constructions_kernel;
using Point_3 = K::Point_3;
using Mesh = CGAL::Surface_mesh<Point_3>;
int main(int argc, char** argv)
{
std::cout.precision(17);
// Read the input
const std::string filename = (argc > 1) ? argv[1] : CGAL::data_file_path("meshes/blobby-shuffled.off");
std::cout << "Reading " << filename << "..." << std::endl;
std::vector<Point_3> points;
std::vector<std::array<std::size_t, 3> > faces;
if(!CGAL::IO::read_polygon_soup(filename, points, faces) || faces.empty())
{
std::cerr << "Invalid input." << std::endl;
return EXIT_FAILURE;
}
std::cout << "Input: " << points.size() << " points, " << faces.size() << " faces" << std::endl;
// Compute the alpha and offset values
const double relative_alpha = (argc > 2) ? std::stod(argv[2]) : 20.;
const double relative_offset = (argc > 3) ? std::stod(argv[3]) : 600.;
CGAL::Bbox_3 bbox;
for(const Point_3& p : points)
bbox += p.bbox();
const double diag_length = std::sqrt(CGAL::square(bbox.xmax() - bbox.xmin()) +
CGAL::square(bbox.ymax() - bbox.ymin()) +
CGAL::square(bbox.zmax() - bbox.zmin()));
const double alpha = diag_length / relative_alpha;
const double offset = diag_length / relative_offset;
// Construct the wrap
CGAL::Real_timer t;
t.start();
Mesh wrap;
CGAL::alpha_wrap_3(points, faces, alpha, offset, wrap);
t.stop();
std::cout << "Result: " << num_vertices(wrap) << " vertices, " << num_faces(wrap) << " faces" << std::endl;
std::cout << "Took " << t.time() << " s." << std::endl;
// Save the result
std::string input_name = std::string(filename);
input_name = input_name.substr(input_name.find_last_of("/") + 1, input_name.length() - 1);
input_name = input_name.substr(0, input_name.find_last_of("."));
std::string output_name = input_name
+ "_" + std::to_string(static_cast<int>(relative_alpha))
+ "_" + std::to_string(static_cast<int>(relative_offset)) + ".off";
std::cout << "Writing to " << output_name << std::endl;
CGAL::IO::write_polygon_mesh(output_name, wrap, CGAL::parameters::stream_precision(17));
return EXIT_SUCCESS;
}

10
Alpha_wrap_3/include/CGAL/alpha_wrap_3.h
View File

@ -148,7 +148,7 @@ void alpha_wrap_3(const PointRange& points,
OutputMesh& alpha_wrap,
const CGAL::Named_function_parameters<T_I, Tag_I, Base_I>& in_np,
const CGAL::Named_function_parameters<T_O, Tag_O, Base_O>& out_np,
typename std::enable_if<boost::has_range_const_iterator<FaceRange>::value>::type* = nullptr)
std::enable_if_t<boost::has_range_const_iterator<FaceRange>::value>* = nullptr)
{
return alpha_wrap_3(points, faces, alpha, alpha / 30., alpha_wrap, in_np, out_np);
}
@ -160,7 +160,7 @@ void alpha_wrap_3(const PointRange& points,
const double alpha,
OutputMesh& alpha_wrap,
const CGAL_NP_CLASS& in_np,
typename std::enable_if<boost::has_range_const_iterator<FaceRange>::value>::type* = nullptr)
std::enable_if_t<boost::has_range_const_iterator<FaceRange>::value>* = nullptr)
{
return alpha_wrap_3(points, faces, alpha, alpha / 30., alpha_wrap, in_np,
CGAL::parameters::default_values());
@ -171,7 +171,7 @@ void alpha_wrap_3(const PointRange& points,
const FaceRange& faces,
const double alpha,
OutputMesh& alpha_wrap,
typename std::enable_if<boost::has_range_const_iterator<FaceRange>::value>::type* = nullptr)
std::enable_if_t<boost::has_range_const_iterator<FaceRange>::value>* = nullptr)
{
return alpha_wrap_3(points, faces, alpha, alpha / 30., alpha_wrap,
CGAL::parameters::default_values(), CGAL::parameters::default_values());
@ -245,7 +245,7 @@ void alpha_wrap_3(const TriangleMesh& tmesh,
const InputNamedParameters& in_np,
const OutputNamedParameters& out_np
#ifndef DOXYGEN_RUNNING
, typename std::enable_if<! boost::has_range_const_iterator<TriangleMesh>::value>::type* = nullptr
, std::enable_if_t<! boost::has_range_const_iterator<TriangleMesh>::value>* = nullptr
#endif
)
{
@ -338,7 +338,7 @@ void alpha_wrap_3(const PointRange& points,
#else
const CGAL::Named_function_parameters<T_I, Tag_I, Base_I>& in_np,
const CGAL::Named_function_parameters<T_O, Tag_O, Base_O>& out_np,
typename std::enable_if<boost::has_range_const_iterator<PointRange>::value>::type* = nullptr
std::enable_if_t<boost::has_range_const_iterator<PointRange>::value>* = nullptr
#endif
)
{

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((boost::is_same<AK,AK_>::value));
CGAL_static_assertion((std::is_same<AK,AK_>::value));
}
{
typedef CGAL::Get_arithmetic_kernel<Rational>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_);
CGAL_static_assertion((boost::is_same<AK,AK_>::value));
CGAL_static_assertion((std::is_same<AK,AK_>::value));
}
{
typedef CGAL::Get_arithmetic_kernel<BFI>::Arithmetic_kernel AK_;
CGAL_USE_TYPE(AK_);
CGAL_static_assertion((boost::is_same<AK,AK_>::value));
CGAL_static_assertion((std::is_same<AK,AK_>::value));
}
return 0;
}

6
Arrangement_on_surface_2/demo/Arrangement_on_surface_2/GraphicsViewCurveInput.cpp
View File

@ -25,14 +25,14 @@
#include <QKeyEvent>
template <std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if<I == sizeof...(Tp), void>::type
inline std::enable_if_t<I == sizeof...(Tp), void>
for_each(std::tuple<Tp...>&, FuncT)
{
}
template <std::size_t I = 0, typename FuncT, typename... Tp>
inline typename std::enable_if <
I<sizeof...(Tp), void>::type for_each(std::tuple<Tp...>& t, FuncT f)
inline std::enable_if_t <
I<sizeof...(Tp), void> for_each(std::tuple<Tp...>& t, FuncT f)
{
f(std::get<I>(t));
for_each<I + 1, FuncT, Tp...>(t, f);

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

@ -120,7 +120,7 @@ locate(const Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt2, Bgt2>, const Bgt2&, Bgt2>::type
typename boost::mpl::if_<std::is_same<Gt2, Bgt2>, const Bgt2&, Bgt2>::type
ex_traits(*geom_traits);
// Define the sweep-line visitor and perform the sweep.

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

@ -90,14 +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;
BOOST_MPL_ASSERT
((boost::is_same< Left_side_category, Arr_oblivious_side_tag >));
BOOST_MPL_ASSERT
((boost::is_same< Bottom_side_category, Arr_oblivious_side_tag >));
BOOST_MPL_ASSERT
((boost::is_same< Top_side_category, Arr_oblivious_side_tag >));
BOOST_MPL_ASSERT
((boost::is_same< Right_side_category, Arr_oblivious_side_tag >));
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));
//@}
/*! \struct

21
Arrangement_on_surface_2/include/CGAL/Arr_curve_data_traits_2.h
View File

@ -24,7 +24,6 @@
#include <list>
#include <boost/variant.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <CGAL/tags.h>
@ -32,6 +31,8 @@
#include <CGAL/Arr_tags.h>
#include <CGAL/Arr_geometry_traits/Curve_data_aux.h>
#include <type_traits>
namespace CGAL {
/*! \class
@ -258,8 +259,7 @@ public:
* has a nested type named Are_mergeable_2.
*/
template <typename GeomeTraits_2>
typename boost::enable_if_c<has_are_mergeable_2<GeomeTraits_2>::value,
bool>::type
std::enable_if_t<has_are_mergeable_2<GeomeTraits_2>::value,bool>
are_mergeable(const X_monotone_curve_2& cv1,
const X_monotone_curve_2& cv2) const
{
@ -277,8 +277,7 @@ public:
* This function should never be called!
*/
template <typename GeomeTraits_2>
typename boost::enable_if_c<!has_are_mergeable_2<GeomeTraits_2>::value,
bool>::type
std::enable_if_t<!has_are_mergeable_2<GeomeTraits_2>::value,bool>
are_mergeable(const X_monotone_curve_2& /* cv1 */,
const X_monotone_curve_2& /* cv2 */) const
{
@ -320,7 +319,7 @@ public:
* has a nested type named Merge_2.
*/
template <typename GeomeTraits_2>
typename boost::enable_if_c<has_merge_2<GeomeTraits_2>::value, void>::type
std::enable_if_t<has_merge_2<GeomeTraits_2>::value, void>
merge(const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2,
X_monotone_curve_2& c) const
{
@ -340,7 +339,7 @@ public:
* This function should never be called!
*/
template <typename GeomeTraits_2>
typename boost::enable_if_c<!has_merge_2<GeomeTraits_2>::value, void>::type
std::enable_if_t<!has_merge_2<GeomeTraits_2>::value, void>
merge(const X_monotone_curve_2& /* cv1 */,
const X_monotone_curve_2& /* cv2 */,
X_monotone_curve_2& /* c */) const
@ -407,8 +406,8 @@ public:
* has a nested type named Construct_opposite_2.
*/
template <typename GeomeTraits_2>
typename boost::enable_if_c<has_construct_opposite_2<GeomeTraits_2>::value,
X_monotone_curve_2>::type
std::enable_if_t<has_construct_opposite_2<GeomeTraits_2>::value,
X_monotone_curve_2>
construct_opposite(const X_monotone_curve_2& cv) const
{
X_monotone_curve_2 new_cv(m_base.construct_opposite_2_object()(cv),
@ -421,8 +420,8 @@ public:
* This function should never be called!
*/
template <typename GeomeTraits_2>
typename boost::enable_if_c<!has_construct_opposite_2<GeomeTraits_2>::value,
X_monotone_curve_2>::type
std::enable_if_t<!has_construct_opposite_2<GeomeTraits_2>::value,
X_monotone_curve_2>
construct_opposite(const X_monotone_curve_2&) const
{
CGAL_error_msg("Construct opposite curve is not supported!");

12
Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Polycurve_2.h
View File

@ -96,7 +96,7 @@ public:
m_subcurves()
{
typedef typename std::iterator_traits<InputIterator>::value_type VT;
typedef typename boost::is_same<VT, Point_type_2>::type Is_point;
typedef typename std::is_same<VT, Point_type_2>::type Is_point;
construct_polycurve(begin, end, Is_point());
}
@ -108,7 +108,7 @@ public:
*/
template <typename InputIterator>
void construct_polycurve(InputIterator begin, InputIterator end,
boost::false_type)
std::false_type)
{ m_subcurves.assign(begin, end); }
/*! Construct a polycurve from a range of points.
@ -120,7 +120,7 @@ public:
template <typename InputIterator>
CGAL_DEPRECATED void construct_polycurve(InputIterator begin,
InputIterator end,
boost::true_type)
std::true_type)
{
// Check if there are no points in the range:
InputIterator ps = begin;
@ -433,7 +433,7 @@ public:
Base(begin, end)
{
typedef typename std::iterator_traits<InputIterator>::value_type VT;
typedef typename boost::is_same<VT, Point_type_2>::type Is_point;
typedef typename std::is_same<VT, Point_type_2>::type Is_point;
construct_x_monotone_polycurve(begin, end, Is_point());
}
@ -444,7 +444,7 @@ public:
*/
template <typename InputIterator>
void construct_x_monotone_polycurve(InputIterator, InputIterator,
boost::false_type)
std::false_type)
{}
/*! Construct from a range of points, defining the endpoints of the
@ -453,7 +453,7 @@ public:
template <typename InputIterator>
CGAL_DEPRECATED void construct_x_monotone_polycurve(InputIterator,
InputIterator,
boost::true_type)
std::true_type)
{}
};

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

@ -247,7 +247,7 @@ overlay(const Arrangement_on_surface_2<GeometryTraitsA_2, TopologyTraitsA>& arr1
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt_adaptor_2, Ovl_gt2>,
typename boost::mpl::if_<std::is_same<Gt_adaptor_2, Ovl_gt2>,
const Ovl_gt2&, Ovl_gt2>::type
ex_traits(*traits_adaptor);

15
Arrangement_on_surface_2/include/CGAL/Arr_polycurve_basic_traits_2.h
View File

@ -25,8 +25,7 @@
*/
#include <iterator>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>
#include <type_traits>
#include <CGAL/basic.h>
#include <CGAL/tags.h>
@ -1144,14 +1143,14 @@ public:
Approximate_2;
/*! Obtain an Approximate_2 functor object. */
Approximate_2 approximate_2_object_impl(boost::false_type) const
Approximate_2 approximate_2_object_impl(std::false_type) const
{ return subcurve_traits_2()->approximate_2_object(); }
Approximate_2 approximate_2_object_impl(boost::true_type) const { }
Approximate_2 approximate_2_object_impl(std::true_type) const { }
Approximate_2 approximate_2_object() const
{
typedef typename boost::is_same<void, Approximate_2>::type Is_void;
typedef typename std::is_same<void, Approximate_2>::type Is_void;
return approximate_2_object_impl(Is_void());
}
#endif
@ -1215,7 +1214,7 @@ public:
ForwardIterator end) const
{
typedef typename std::iterator_traits<ForwardIterator>::value_type VT;
typedef typename boost::is_same<VT,Point_2>::type Is_point;
typedef typename std::is_same<VT,Point_2>::type Is_point;
// Dispatch the range to the appropriate implementation.
return constructor_impl(begin, end, Is_point());
@ -1233,7 +1232,7 @@ public:
template <typename ForwardIterator>
X_monotone_curve_2 constructor_impl(ForwardIterator /* begin */,
ForwardIterator /* end */,
boost::true_type) const
std::true_type) const
{ CGAL_error_msg("Cannot construct a polycurve from a range of points!"); }
/*! Obtain an x-monotone polycurve from a range of subcurves.
@ -1254,7 +1253,7 @@ public:
template <typename ForwardIterator>
X_monotone_curve_2 constructor_impl(ForwardIterator begin,
ForwardIterator end,
boost::false_type) const
std::false_type) const
{
CGAL_precondition_msg
(

9
Arrangement_on_surface_2/include/CGAL/Arr_polycurve_traits_2.h
View File

@ -25,10 +25,9 @@
*/
#include <iterator>
#include <type_traits>
#include <boost/variant.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>
#include <CGAL/basic.h>
#include <CGAL/tags.h>
@ -1174,7 +1173,7 @@ public:
Curve_2 operator()(ForwardIterator begin, ForwardIterator end) const
{
typedef typename std::iterator_traits<ForwardIterator>::value_type VT;
typedef typename boost::is_same<VT, Point_2>::type Is_point;
typedef typename std::is_same<VT, Point_2>::type Is_point;
// Dispatch the range to the appropriate implementation.
return constructor_impl(begin, end, Is_point());
}
@ -1191,7 +1190,7 @@ public:
template <typename ForwardIterator>
Curve_2 constructor_impl(ForwardIterator /* begin */,
ForwardIterator /* end */,
boost::true_type) const
std::true_type) const
{ CGAL_error_msg("Cannot construct a polycurve from a range of points!"); }
/*! Construction implementation from a range of subcurves.
@ -1202,7 +1201,7 @@ public:
*/
template <typename ForwardIterator>
Curve_2 constructor_impl(ForwardIterator begin, ForwardIterator end,
boost::false_type) const
std::false_type) const
{
// Range has to contain at least one subcurve
CGAL_precondition(begin != end);

15
Arrangement_on_surface_2/include/CGAL/Arr_polyline_traits_2.h
View File

@ -29,8 +29,7 @@
#include <list>
#include <iterator>
#include <boost/type_traits/is_same.hpp>
#include <boost/utility/enable_if.hpp>
#include <type_traits>
#include <CGAL/basic.h>
#include <CGAL/tags.h>
@ -381,7 +380,7 @@ public:
Curve_2 operator()(ForwardIterator begin, ForwardIterator end) const
{
typedef typename std::iterator_traits<ForwardIterator>::value_type VT;
typedef typename boost::is_same<VT, Point_2>::type Is_point;
typedef typename std::is_same<VT, Point_2>::type Is_point;
// Dispatch the range to the appropriate implementation.
return constructor_impl(begin, end, Is_point());
}
@ -401,7 +400,7 @@ public:
*/
template <typename ForwardIterator>
Curve_2 constructor_impl(ForwardIterator begin, ForwardIterator end,
boost::false_type) const
std::false_type) const
{ return Base::Construct_curve_2::operator()(begin, end); }
/*! Construction of a polyline from a range of points.
@ -414,7 +413,7 @@ public:
*/
template <typename ForwardIterator>
Curve_2 constructor_impl(ForwardIterator begin, ForwardIterator end,
boost::true_type) const
std::true_type) const
{
// The range must not contain a single point.
CGAL_precondition_msg(std::distance(begin, end) != 1,
@ -503,7 +502,7 @@ public:
const
{
typedef typename std::iterator_traits<ForwardIterator>::value_type VT;
typedef typename boost::is_same<VT, Point_2>::type Is_point;
typedef typename std::is_same<VT, Point_2>::type Is_point;
// Dispatch the range to the appropriate implementation.
return constructor_impl(begin, end, Is_point());
}
@ -526,7 +525,7 @@ public:
template <typename ForwardIterator>
X_monotone_curve_2 constructor_impl(ForwardIterator begin,
ForwardIterator end,
boost::false_type) const
std::false_type) const
{ return Base::Construct_x_monotone_curve_2::operator()(begin, end); }
/*! Construction of an x-monotone polyline from a range of points.
@ -541,7 +540,7 @@ public:
template <typename ForwardIterator>
X_monotone_curve_2 constructor_impl(ForwardIterator begin,
ForwardIterator end,
boost::true_type) const
std::true_type) const
{
// The range must not contain a single point.
CGAL_precondition_msg(std::distance(begin, end) != 1,

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

@ -18,6 +18,7 @@
#include <vector>
#include <ostream>
#include <type_traits>
#include <CGAL/Arr_enums.h>
#include <CGAL/tags.h>
#include <CGAL/Arr_tags.h>
@ -26,8 +27,6 @@
#include <CGAL/Arithmetic_kernel.h>
#include <CGAL/Algebraic_kernel_d_1.h>
#include <boost/type_traits/is_same.hpp>
namespace CGAL {
namespace Arr_rational_arc {
@ -63,8 +62,8 @@ public:
typedef std::vector<std::pair<Algebraic_real_1, Multiplicity> >
Root_multiplicity_vector;
CGAL_static_assertion((boost::is_same<Integer,Coefficient>::value));
CGAL_static_assertion((boost::is_same<Polynomial_1,
CGAL_static_assertion((std::is_same<Integer,Coefficient>::value));
CGAL_static_assertion((std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value));
public:

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

@ -20,6 +20,7 @@
#include <vector>
#include <list>
#include <ostream>
#include <type_traits>
#include <CGAL/Arr_enums.h>
#include <CGAL/tags.h>
#include <CGAL/Arr_tags.h>
@ -34,7 +35,6 @@
#include <CGAL/Arr_rat_arc/Rational_function.h>
#include <CGAL/Arr_rat_arc/Rational_function_pair.h>
#include <boost/type_traits/is_same.hpp>
namespace CGAL {
namespace Arr_rational_arc {
@ -100,8 +100,8 @@ public:
typedef Algebraic_point_2 Point_2;
CGAL_static_assertion((boost::is_same<Integer, Coefficient>::value));
CGAL_static_assertion((boost::is_same<Polynomial_1,
CGAL_static_assertion((std::is_same<Integer, Coefficient>::value));
CGAL_static_assertion((std::is_same<Polynomial_1,
typename FT_poly_rat_1::Numerator_type>::value));
public:

10
Arrangement_on_surface_2/include/CGAL/Arr_spherical_gaussian_map_3/Arr_polyhedral_sgm.h
View File

@ -84,7 +84,7 @@ private:
typedef typename Polyhedron::Halfedge_around_vertex_circulator
Polyhedron_halfedge_around_vertex_circulator;
typedef boost::is_same<typename Polyhedron::Plane_3, Vector_3>
typedef std::is_same<typename Polyhedron::Plane_3, Vector_3>
Polyhedron_has_normal;
typedef typename Polyhedron::HalfedgeDS HDS;
@ -103,7 +103,7 @@ private:
}
};
void compute_planes(Polyhedron& polyhedron, boost::true_type)
void compute_planes(Polyhedron& polyhedron, std::true_type)
{
std::transform(polyhedron.facets_begin(), polyhedron.facets_end(),
polyhedron.planes_begin(), Normal_equation());
@ -120,7 +120,7 @@ private:
}
};
void compute_planes(Polyhedron& polyhedron, boost::false_type)
void compute_planes(Polyhedron& polyhedron, std::false_type)
{
std::transform(polyhedron.facets_begin(), polyhedron.facets_end(),
polyhedron.planes_begin(), Plane_equation());
@ -350,12 +350,12 @@ private:
/*! Obtain the normal of a facet of a polyhedron that supports normals */
template <typename Facet>
const Vector_3& get_normal(const Facet& facet, boost::true_type) const
const Vector_3& get_normal(const Facet& facet, std::true_type) const
{ return facet->plane(); }
/*! Obtain the normal of a facet of a polyhedron that supports planes */
template <typename Facet>
Vector_3 get_normal(const Facet& facet, boost::false_type) const
Vector_3 get_normal(const Facet& facet, std::false_type) const
{ return facet->plane().orthogonal_vector(); }
/*! Process a polyhedron vertex recursively constructing the Gaussian map

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

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

11
Arrangement_on_surface_2/include/CGAL/Arr_tags.h
View File

@ -252,7 +252,7 @@ typedef boost::mpl::bool_<false> Arr_false;
template <typename ArrSideCategory>
struct Arr_is_side_oblivious {
typedef ArrSideCategory Side_cat;
typedef boost::is_same<Side_cat, Arr_oblivious_side_tag> Is_same;
typedef std::is_same<Side_cat, Arr_oblivious_side_tag> Is_same;
typedef boost::mpl::if_<Is_same, Arr_true, Arr_false> result;
typedef typename result::type type;
};
@ -260,7 +260,7 @@ struct Arr_is_side_oblivious {
template <typename ArrSideCategory>
struct Arr_is_side_open {
typedef ArrSideCategory Side_cat;
typedef boost::is_same<Side_cat, Arr_open_side_tag> Is_same;
typedef std::is_same<Side_cat, Arr_open_side_tag> Is_same;
typedef boost::mpl::if_<Is_same, Arr_true, Arr_false> result;
typedef typename result::type type;
};
@ -268,7 +268,7 @@ struct Arr_is_side_open {
template <typename ArrSideCategory>
struct Arr_is_side_identified {
typedef ArrSideCategory Side_cat;
typedef boost::is_same<Side_cat, Arr_identified_side_tag> Is_same;
typedef std::is_same<Side_cat, Arr_identified_side_tag> Is_same;
typedef boost::mpl::if_<Is_same, Arr_true, Arr_false> result;
typedef typename result::type type;
};
@ -276,7 +276,7 @@ struct Arr_is_side_identified {
template <typename ArrSideCategory>
struct Arr_is_side_contracted {
typedef ArrSideCategory Side_cat;
typedef boost::is_same<Side_cat, Arr_contracted_side_tag> Is_same;
typedef std::is_same<Side_cat, Arr_contracted_side_tag> Is_same;
typedef boost::mpl::if_<Is_same, Arr_true, Arr_false> result;
typedef typename result::type type;
};
@ -284,7 +284,7 @@ struct Arr_is_side_contracted {
template <typename ArrSideCategory>
struct Arr_is_side_closed {
typedef ArrSideCategory Side_cat;
typedef boost::is_same<Side_cat, Arr_closed_side_tag> Is_same;
typedef std::is_same<Side_cat, Arr_closed_side_tag> Is_same;
typedef boost::mpl::if_<Is_same, Arr_true, Arr_false> result;
typedef typename result::type type;
};
@ -429,6 +429,7 @@ struct Arr_sane_identified_tagging {
* otherwise bool_<false>
*/
typedef boost::mpl::and_<LR_ok, BT_ok> result;
static constexpr bool value = result::value;
};
/*! Checks whether one of two boundary sides are identified

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

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

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

@ -124,7 +124,7 @@ decompose(const Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt2, Vgt2>, const Vgt2&, Vgt2>::type
typename boost::mpl::if_<std::is_same<Gt2, Vgt2>, const Vgt2&, Vgt2>::type
ex_traits(*geom_traits);
// Define the sweep-line visitor and perform the sweep.

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

@ -63,11 +63,11 @@ private:
typedef boost::mpl::bool_< false > false_;
typedef boost::mpl::if_<
boost::is_same< Arr_smaller_implementation_tag, Arr_use_traits_tag >,
std::is_same< Arr_smaller_implementation_tag, Arr_use_traits_tag >,
true_, false_ > Smaller_traits;
typedef boost::mpl::if_<
boost::is_same< Arr_larger_implementation_tag, Arr_use_traits_tag >,
std::is_same< Arr_larger_implementation_tag, Arr_use_traits_tag >,
true_, false_ > Larger_traits;
public:

28
Arrangement_on_surface_2/include/CGAL/Arrangement_2/Arrangement_on_surface_2_global.h
View File

@ -73,7 +73,7 @@ template <typename GeometryTraits_2, typename TopologyTraits,
void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
const typename GeometryTraits_2::Curve_2& c,
const PointLocation& pl, ZoneVisitor &visitor,
boost::is_same<int, double>::type)
std::is_same<int, double>::type)
{
typedef GeometryTraits_2 Gt2;
typedef TopologyTraits Tt;
@ -145,7 +145,7 @@ template <typename GeometryTraits_2, typename TopologyTraits,
void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
const typename GeometryTraits_2::X_monotone_curve_2& c,
const PointLocation& pl, ZoneVisitor &visitor,
boost::is_same<int, int>::type)
std::is_same<int, int>::type)
{
typedef GeometryTraits_2 Gt2;
typedef TopologyTraits Tt;
@ -184,7 +184,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
{
typedef GeometryTraits_2 Gt2;
typedef typename Gt2::X_monotone_curve_2 X_monotone_curve_2;
typedef typename boost::is_same<Curve, X_monotone_curve_2>::type
typedef typename std::is_same<Curve, X_monotone_curve_2>::type
Is_x_monotone;
insert(arr, c, pl, visitor, Is_x_monotone());
@ -193,7 +193,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
// In some compilers there is a template deduction disambiguity between this
// function and the function receiving two InputIterator.
// For now the solution is to add a dummy variable at the end (referring
// to point-location). Maybe the proper solution is to use boost::enable_if
// to point-location). Maybe the proper solution is to use std::enable_if
// together with appropriate tag.
template <typename GeometryTraits_2, typename TopologyTraits, typename Curve,
typename PointLocation>
@ -271,7 +271,7 @@ insert_empty(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt2, Cgt2>, const Cgt2&, Cgt2>::type
typename boost::mpl::if_<std::is_same<Gt2, Cgt2>, const Cgt2&, Cgt2>::type
traits(*geom_traits);
// Define a surface-sweep instance and perform the sweep:
@ -326,7 +326,7 @@ void insert_empty(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>&
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt2, Cgt2>, const Cgt2&, Cgt2>::type
typename boost::mpl::if_<std::is_same<Gt2, Cgt2>, const Cgt2&, Cgt2>::type
traits(*geom_traits);
// Define a surface-sweep instance and perform the sweep.
@ -379,7 +379,7 @@ void insert_non_empty(Arrangement_on_surface_2<GeometryTraits_2,
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt2, Igt2>, const Igt2&, Igt2>::type
typename boost::mpl::if_<std::is_same<Gt2, Igt2>, const Igt2&, Igt2>::type
traits(*geom_traits);
// Create a set of existing as well as new curves and points.
@ -417,7 +417,7 @@ template <typename GeometryTraits_2, typename TopologyTraits,
typename InputIterator>
void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
InputIterator begin, InputIterator end,
boost::is_same<int, double>::type)
std::is_same<int, double>::type)
{
typedef GeometryTraits_2 Gt2;
typedef TopologyTraits Tt;
@ -471,7 +471,7 @@ template <typename GeometryTraits_2, typename TopologyTraits,
typename InputIterator>
void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
InputIterator begin, InputIterator end,
boost::is_same<int, int>::type)
std::is_same<int, int>::type)
{
typedef GeometryTraits_2 Gt2;
typedef TopologyTraits Tt;
@ -513,7 +513,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2,TopologyTraits>& arr,
typedef typename std::iterator_traits<InputIterator>::value_type
Iterator_value_type;
typedef typename boost::is_same<Iterator_value_type,X_monotone_curve_2>::type
typedef typename std::is_same<Iterator_value_type,X_monotone_curve_2>::type
Is_x_monotone;
return insert(arr, begin, end, Is_x_monotone());
@ -979,7 +979,7 @@ non_intersecting_insert_non_empty(Arrangement_on_surface_2<GeometryTraits_2,
* Use the form 'A a(*b);' and not ''A a = b;' to handle the case where A has
* only an implicit constructor, (which takes *b as a parameter).
*/
typename boost::mpl::if_<boost::is_same<Gt2, Igt2>, const Igt2&, Igt2>::type
typename boost::mpl::if_<std::is_same<Gt2, Igt2>, const Igt2&, Igt2>::type
traits(*geom_traits);
// Create a set of existing as well as new curves and points.
@ -1533,7 +1533,7 @@ template <typename GeometryTraits_2, typename TopologyTraits,
bool
do_intersect(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
const typename GeometryTraits_2::X_monotone_curve_2& c,
const PointLocation& pl, boost::is_same<int, int>::type)
const PointLocation& pl, std::is_same<int, int>::type)
{
typedef GeometryTraits_2 Gt2;
typedef TopologyTraits Tt;
@ -1571,7 +1571,7 @@ template <typename GeometryTraits_2, typename TopologyTraits,
bool
do_intersect(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
const typename GeometryTraits_2::X_monotone_curve_2& c,
const PointLocation& pl, boost::is_same<int, double>::type)
const PointLocation& pl, std::is_same<int, double>::type)
{
typedef GeometryTraits_2 Gt2;
typedef TopologyTraits Tt;
@ -1628,7 +1628,7 @@ do_intersect(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
typedef typename Gt2::X_monotone_curve_2 X_monotone_curve_2;
typedef typename boost::is_same<Curve, X_monotone_curve_2>::type
typedef typename std::is_same<Curve, X_monotone_curve_2>::type
Is_x_monotone;
return do_intersect(arr, c, pl, Is_x_monotone());

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

@ -77,13 +77,10 @@ public:
typedef typename Traits_adaptor_2::Top_side_category Top_side_category;
typedef typename Traits_adaptor_2::Right_side_category Right_side_category;
BOOST_MPL_ASSERT(
(typename
Arr_sane_identified_tagging<Left_side_category,
Bottom_side_category,
Top_side_category,
Right_side_category>::result)
);
CGAL_static_assertion((Arr_sane_identified_tagging<Left_side_category,
Bottom_side_category,
Top_side_category,
Right_side_category>::value));
public:
typedef Arrangement_on_surface_2<Geometry_traits_2, Topology_traits>
@ -2853,7 +2850,7 @@ protected:
// In some compilers there is a template deduction disambiguity between this
// function and the following function receiving two InputIterator.
// For now the solution is to add a dummy variable at the end (referring
// to point-location). Maybe the proper solution is to use boost::enable_if
// to point-location). Maybe the proper solution is to use std::enable_if
// together with appropriate tag.
/*!
* Insert a curve or x-monotone curve into the arrangement (incremental

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

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

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

@ -22,9 +22,9 @@
#include <CGAL/Handle_with_policy.h>
#include <iostream>
#include <type_traits>
#include <boost/optional.hpp>
#include <boost/none.hpp>
#include <boost/type_traits/is_same.hpp>
#include <CGAL/Bbox_2.h>
#include <CGAL/Arr_enums.h>
@ -232,7 +232,7 @@ public:
//!@}
#if !defined(CGAL_NO_ASSERTIONS)
static const bool Kernel_arc_2_equals_Arc_2 = boost::is_same<Arc_2, Kernel_arc_2>::value;
static const bool Kernel_arc_2_equals_Arc_2 = std::is_same<Arc_2, Kernel_arc_2>::value;
#endif
public:

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

@ -279,7 +279,7 @@ Lrestart:
std::cerr << "Switching to multi-precision arithmetic" <<
std::endl;
#ifdef CGAL_CKVA_USE_MULTIPREC_ARITHMETIC
if(::boost::is_same<typename Algebraic_structure_traits< Float >::
if(::std::is_same<typename Algebraic_structure_traits< Float >::
Is_exact, CGAL::Tag_true>::value)
goto Lexit;
@ -298,7 +298,7 @@ Lrestart:
std::cerr << "Switching to exact arithmetic" << std::endl;
#ifdef CGAL_CKVA_USE_RATIONAL_ARITHMETIC
if(::boost::is_same<
if(::std::is_same<
typename Algebraic_structure_traits< Float >::Is_exact,
CGAL::Tag_true>::value)
goto Lexit;

5
Arrangement_on_surface_2/include/CGAL/Curved_kernel_via_analysis_2/Point_2.h
View File

@ -23,7 +23,6 @@
#include <boost/optional.hpp>
#include <boost/optional/optional_io.hpp>
#include <boost/type_traits/is_same.hpp>
#include <CGAL/Handle_with_policy.h>
@ -31,6 +30,8 @@
#include <CGAL/Curved_kernel_via_analysis_2/Curved_kernel_via_analysis_2_functors.h>
#include <type_traits>
namespace CGAL {
namespace internal {
@ -170,7 +171,7 @@ public:
//!@}
#if !defined(CGAL_NO_ASSERTIONS)
static const bool Kernel_point_2_equals_Point_2 = boost::is_same<Point_2, Kernel_point_2>::value;
static const bool Kernel_point_2_equals_Point_2 = std::is_same<Point_2, Kernel_point_2>::value;
#endif
public:

3
Arrangement_on_surface_2/test/Arrangement_on_surface_2/test_conic_polycurve.cpp
View File

@ -13,8 +13,7 @@ int main()
#include <vector>
#include <list>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
#include <CGAL/Cartesian.h>
#include <CGAL/Quotient.h>

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

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

18
BGL/include/CGAL/boost/graph/Face_filtered_graph.h
View File

@ -214,9 +214,9 @@ struct Face_filtered_graph
FacePatchIndexMap face_patch_index_map,
const CGAL_NP_CLASS& np
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<
typename boost::has_range_const_iterator<FacePatchIndexRange>::type
>::type* = 0
, std::enable_if_t<
boost::has_range_const_iterator<FacePatchIndexRange>::value
>* = 0
#endif
)
: _graph(const_cast<Graph&>(graph)),
@ -231,9 +231,9 @@ struct Face_filtered_graph
Face_filtered_graph(const Graph& graph,
const FacePatchIndexRange& selected_face_patch_indices,
FacePatchIndexMap face_patch_index_map
, typename boost::enable_if<
typename boost::has_range_const_iterator<FacePatchIndexRange>::type
>::type* = 0
, std::enable_if_t<
boost::has_range_const_iterator<FacePatchIndexRange>::value
>* = 0
)
: _graph(const_cast<Graph&>(graph)),
fimap(CGAL::get_initialized_face_index_map(graph)),
@ -471,9 +471,9 @@ struct Face_filtered_graph
void set_selected_faces(const FacePatchIndexRange& selected_face_patch_indices,
FacePatchIndexMap face_patch_index_map
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<
typename boost::has_range_const_iterator<FacePatchIndexRange>::type
>::type* = 0
, std::enable_if_t<
boost::has_range_const_iterator<FacePatchIndexRange>::value
>* = 0
#endif
)
{

6
BGL/include/CGAL/boost/graph/IO/3MF.h
View File

@ -18,11 +18,11 @@
#include <CGAL/boost/graph/iterator.h>
#include <boost/property_map/property_map.hpp>
#include <boost/utility/enable_if.hpp>
#include <string>
#include <unordered_map>
#include <vector>
#include <type_traits>
#if defined(CGAL_LINKED_WITH_3MF) || defined(DOXYGEN_RUNNING)
@ -59,9 +59,9 @@ bool write_3MF(const std::string& filename,
const GraphRange& gs,
const std::vector<std::string>& names
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<
, std::enable_if_t<!
internal::is_Point_set_or_Range_or_Iterator<
typename boost::range_value<GraphRange>::type> >::type* = nullptr
typename boost::range_value<GraphRange>::type>::value>* = nullptr
#endif
)
{

14
BGL/include/CGAL/boost/graph/IO/GOCAD.h
View File

@ -114,7 +114,7 @@ bool read_GOCAD(std::istream& is,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -135,7 +135,7 @@ bool read_GOCAD(std::istream& is,
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(std::istream& is, Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr)
{
std::pair<std::string, std::string> dummy;
return read_GOCAD(is, dummy, g, np);
@ -188,7 +188,7 @@ bool read_GOCAD(const std::string& fname,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -201,7 +201,7 @@ bool read_GOCAD(const std::string& fname,
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(const std::string& fname, Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr)
{
std::pair<std::string, std::string> dummy;
return read_GOCAD(fname, dummy, g, np);
@ -251,7 +251,7 @@ bool write_GOCAD(std::ostream& os,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -347,7 +347,7 @@ bool write_GOCAD(std::ostream& os,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -392,7 +392,7 @@ bool write_GOCAD(const std::string& fname,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{

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

@ -109,7 +109,7 @@ bool read_OBJ(std::istream& is,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -165,7 +165,7 @@ bool read_OBJ(const std::string& fname,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -217,7 +217,7 @@ bool write_OBJ(std::ostream& os,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -263,7 +263,7 @@ bool write_OBJ(const std::string& fname,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{

10
BGL/include/CGAL/boost/graph/IO/OFF.h
View File

@ -22,8 +22,6 @@
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <boost/utility/enable_if.hpp>
#include <fstream>
#include <iostream>
#include <string>
@ -155,7 +153,7 @@ bool read_OFF(std::istream& is,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -239,7 +237,7 @@ bool read_OFF(const std::string& fname,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -365,7 +363,7 @@ bool write_OFF(std::ostream& os,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -439,7 +437,7 @@ bool write_OFF(const std::string& fname,
const Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{

14
BGL/include/CGAL/boost/graph/IO/PLY.h
View File

@ -19,8 +19,6 @@
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <boost/utility/enable_if.hpp>
#include <fstream>
#include <string>
@ -136,7 +134,7 @@ bool read_PLY(std::istream& is,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -211,7 +209,7 @@ bool read_PLY(const std::string& fname,
Graph& g,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -298,7 +296,7 @@ bool write_PLY(std::ostream& os,
const std::string& comments,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -421,7 +419,7 @@ bool write_PLY(std::ostream& os,
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr)
{
return write_PLY(os, g, std::string(), np);
}
@ -494,7 +492,7 @@ bool write_PLY(const std::string& fname,
const std::string& comments,
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
, std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr
#endif
)
{
@ -518,7 +516,7 @@ bool write_PLY(const std::string& fname,
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
std::enable_if_t<!internal::is_Point_set_or_Range_or_Iterator<Graph>::value>* = nullptr)
{
return write_PLY(fname, g, std::string(), np);
}

1
BGL/include/CGAL/boost/graph/copy_face_graph.h
View File

@ -23,7 +23,6 @@
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/property_map.h>
#include <boost/utility/enable_if.hpp>
#include <unordered_map>

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

@ -28,6 +28,9 @@ public:
static const bool value = (sizeof(f<T>(0)) == sizeof(char));
};
template<class T>
CGAL_CPP17_INLINE constexpr bool Has_member_clear_v = Has_member_clear<T>::value;
} // internal
} // cgal

9
BGL/include/CGAL/boost/graph/internal/OM_iterator_from_circulator.h
View File

@ -21,7 +21,6 @@
#include <boost/concept_check.hpp>
#include <boost/mpl/if.hpp>
#include <boost/utility/enable_if.hpp>
namespace CGAL {
@ -92,12 +91,12 @@ public:
// templates as a work-around.
private:
template <bool Prevent_deref_>
typename boost::enable_if_c<Prevent_deref_, reference>::type
std::enable_if_t<Prevent_deref_, reference>
indirection() const {
return const_cast<Self*>(this)->current;
}
template <bool Prevent_deref_>
typename boost::disable_if_c<Prevent_deref_, reference>::type
std::enable_if_t<!Prevent_deref_, reference>
indirection() const {
return *current;
}
@ -108,12 +107,12 @@ public:
private:
template <bool Prevent_deref_>
typename boost::disable_if_c<Prevent_deref_, pointer>::type
std::enable_if_t<!Prevent_deref_, pointer>
structure_dereference() {
return &(*current);
}
template <bool Prevent_deref_>
typename boost::enable_if_c<Prevent_deref_, pointer>::type
std::enable_if_t<Prevent_deref_, pointer>
structure_dereference() {
return &current;
}

5
BGL/include/CGAL/boost/graph/named_params_helper.h
View File

@ -22,7 +22,6 @@
#include <boost/mpl/if.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/type_traits/is_same.hpp>
#include <fstream>
#include <iterator>
@ -153,7 +152,7 @@ class GetGeomTraits
struct Fake_GT {}; // to be used if there is no internal vertex_point_map in PolygonMesh
typedef typename boost::mpl::if_c<Has_internal_pmap::value ||
!boost::is_same<internal_np::Param_not_found, NP_vpm>::value,
!std::is_same<internal_np::Param_not_found, NP_vpm>::value,
typename GetK<PolygonMesh, NamedParametersVPM>::Kernel,
Fake_GT>::type DefaultKernel;
@ -343,7 +342,7 @@ struct Point_set_processing_3_np_helper
static constexpr bool has_normal_map()
{
return !boost::is_same< typename internal_np::Get_param<typename NamedParameters::base, internal_np::normal_t>::type,
return !std::is_same< typename internal_np::Get_param<typename NamedParameters::base, internal_np::normal_t>::type,
internal_np::Param_not_found> ::value;
}
};

6
BGL/include/CGAL/boost/graph/properties_OpenMesh.h
View File

@ -29,11 +29,11 @@ namespace CGAL {
template <typename Mesh, typename Descriptor, typename Value>
class OM_pmap {
public:
typedef typename boost::mpl::if_<boost::is_same<Descriptor, typename boost::graph_traits<Mesh>::vertex_descriptor>,
typedef typename boost::mpl::if_<std::is_same<Descriptor, typename boost::graph_traits<Mesh>::vertex_descriptor>,
OpenMesh::VPropHandleT<Value>,
typename boost::mpl::if_<boost::is_same<Descriptor, typename boost::graph_traits<Mesh>::face_descriptor>,
typename boost::mpl::if_<std::is_same<Descriptor, typename boost::graph_traits<Mesh>::face_descriptor>,
OpenMesh::FPropHandleT<Value>,
typename boost::mpl::if_<boost::is_same<Descriptor, typename boost::graph_traits<Mesh>::halfedge_descriptor>,
typename boost::mpl::if_<std::is_same<Descriptor, typename boost::graph_traits<Mesh>::halfedge_descriptor>,
OpenMesh::HPropHandleT<Value>,
OpenMesh::EPropHandleT<Value> >::type>::type>::type H;

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

@ -17,7 +17,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <vector>
#include <boost/mpl/assert.hpp>
#include <CGAL/Boolean_set_operations_2/Gps_traits_decorator.h>
#include <CGAL/Boolean_set_operations_2/Curve_with_halfedge.h>
#include <CGAL/Boolean_set_operations_2/Point_with_vertex.h>
@ -124,18 +123,14 @@ public:
typedef typename Arr::Right_side_category Right_side_category;
// a side is either oblivious or open (unbounded)
BOOST_MPL_ASSERT((boost::mpl::or_<
boost::is_same<Left_side_category, Arr_oblivious_side_tag>,
boost::is_same<Left_side_category, Arr_open_side_tag> >));
BOOST_MPL_ASSERT((boost::mpl::or_<
boost::is_same<Bottom_side_category, Arr_oblivious_side_tag>,
boost::is_same<Bottom_side_category, Arr_open_side_tag> >));
BOOST_MPL_ASSERT((boost::mpl::or_<
boost::is_same<Top_side_category, Arr_oblivious_side_tag>,
boost::is_same<Top_side_category, Arr_open_side_tag> >));
BOOST_MPL_ASSERT((boost::mpl::or_<
boost::is_same<Right_side_category, Arr_oblivious_side_tag>,
boost::is_same<Right_side_category, Arr_open_side_tag> >));
CGAL_static_assertion((std::is_same<Left_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Left_side_category, Arr_open_side_tag>::value));
CGAL_static_assertion((std::is_same<Bottom_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Bottom_side_category, Arr_open_side_tag>::value));
CGAL_static_assertion((std::is_same<Top_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Top_side_category, Arr_open_side_tag>::value));
CGAL_static_assertion((std::is_same<Right_side_category, Arr_oblivious_side_tag>::value ||
std::is_same<Right_side_category, Arr_open_side_tag>::value));
typedef typename Arr::Halfedge_handle Halfedge_handle;
typedef typename Arr::Vertex_handle Vertex_handle;

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

@ -15,9 +15,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/mpl/assert.hpp>
namespace CGAL {
template <class Traits_, class Curve_data_, class Point_data_>
@ -56,30 +53,14 @@ public:
typedef typename Base::Right_side_category Right_side_category;
// a side is either oblivious or open (unbounded)
BOOST_MPL_ASSERT(
(boost::mpl::or_<
boost::is_same< Left_side_category, Arr_oblivious_side_tag >,
boost::is_same< Left_side_category, Arr_open_side_tag > >
)
);
BOOST_MPL_ASSERT(
(boost::mpl::or_<
boost::is_same< Bottom_side_category, Arr_oblivious_side_tag >,
boost::is_same< Bottom_side_category, Arr_open_side_tag > >
)
);
BOOST_MPL_ASSERT(
(boost::mpl::or_<
boost::is_same< Top_side_category, Arr_oblivious_side_tag >,
boost::is_same< Top_side_category, Arr_open_side_tag > >
)
);
BOOST_MPL_ASSERT(
(boost::mpl::or_<
boost::is_same< Right_side_category, Arr_oblivious_side_tag >,
boost::is_same< Right_side_category, Arr_open_side_tag > >
)
);
CGAL_static_assertion((std::is_same< Left_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Left_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Bottom_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Bottom_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Top_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Top_side_category, Arr_open_side_tag >::value));
CGAL_static_assertion((std::is_same< Right_side_category, Arr_oblivious_side_tag >::value ||
std::is_same< Right_side_category, Arr_open_side_tag >::value));
class Ex_point_2
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/complement.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/difference.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/do_intersect.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/intersection.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/join.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/oriented_side.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

4
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/symmetric_difference.h
View File

@ -18,8 +18,6 @@
#include <CGAL/license/Boolean_set_operations_2.h>
#include <boost/utility/enable_if.hpp>
#include <CGAL/disable_warnings.h>
#include <CGAL/Polygon_2.h>
@ -33,7 +31,7 @@
#include <CGAL/iterator.h>
#include <CGAL/Boolean_set_operations_2/Bso_internal_functions.h>
#include <CGAL/Boolean_set_operations_2/Polygon_conversions.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
namespace CGAL
{

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

@ -330,7 +330,7 @@ CGAL_CPP17_INLINE constexpr bool Has_member_report_v = Has_member_report<T>::val
template <typename Callback>
inline
std::enable_if_t<Has_member_report_v<Callback>, bool>
std::enable_if_t<Has_member_report<Callback>::value, bool>
report_impl(Callback callback, int dim)
{
return callback.report(dim);
@ -338,7 +338,7 @@ report_impl(Callback callback, int dim)
template <typename Callback>
inline
std::enable_if_t<!Has_member_report_v<Callback>, bool>
std::enable_if_t<!Has_member_report<Callback>::value, bool>
report_impl(const Callback&, int)
{
return false;
@ -346,7 +346,7 @@ report_impl(const Callback&, int)
template <typename Callback>
inline
std::enable_if_t<Has_member_report_v<Callback>, void>
std::enable_if_t<Has_member_report<Callback>::value, void>
progress_impl(Callback callback, double d)
{
callback.progress(d);
@ -354,7 +354,7 @@ progress_impl(Callback callback, double d)
template <typename Callback>
inline
std::enable_if_t<!Has_member_report_v<Callback>, void>
std::enable_if_t<!Has_member_report<Callback>::value, void>
progress_impl(const Callback&, double)
{}

22
CGAL_ipelets/include/CGAL/CGAL_Ipelet_base_v6.h
View File

@ -338,12 +338,12 @@ public:
draw_polyline_in_ipe(const iterator first, const iterator last,
bool setclose=false,bool deselect_all=false,
bool blackfill=false,
typename boost::enable_if<
boost::is_same<
std::enable_if_t<
std::is_same<
typename std::iterator_traits<iterator>::value_type,
Point_2
>
>::type* =nullptr) const
>::value
>* =nullptr) const
{
IpeSegmentSubPath* SSP_ipe=create_polyline(first,last,setclose);
if (SSP_ipe!=nullptr){
@ -636,13 +636,13 @@ public:
template<class iterator>
void
draw_in_ipe(const iterator begin,const iterator end,const Iso_rectangle_2& bbox,bool make_grp=true,bool deselect_all=false,
typename boost::enable_if< boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Point_2> ,
boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Segment_2> ,
boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Circle_2> ,
boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Circular_arc_2> ,
boost::is_same<typename std::iterator_traits<iterator>::value_type,Polygon_2>
> > > >
>::type* = nullptr) const
std::enable_if_t< boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Point_2> ,
boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Segment_2> ,
boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Circle_2> ,
boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Circular_arc_2> ,
std::is_same<typename std::iterator_traits<iterator>::value_type,Polygon_2>
> > > >::value
>* = nullptr) const
{
for (iterator it=begin;it!=end;++it)
draw_in_ipe(*it,bbox);

22
CGAL_ipelets/include/CGAL/CGAL_Ipelet_base_v7.h
View File

@ -350,12 +350,12 @@ public:
draw_polyline_in_ipe(const iterator first, const iterator last,
bool setclose=false,bool deselect_all=false,
bool blackfill=false,
typename boost::enable_if<
boost::is_same<
std::enable_if_t<
std::is_same<
typename std::iterator_traits<iterator>::value_type,
Point_2
>
>::type* =nullptr) const
>::value
>* =nullptr) const
{
ipe::Curve* SSP_ipe=create_polyline(first,last,setclose);
if (SSP_ipe!=nullptr){
@ -645,13 +645,13 @@ public:
template<class iterator>
void
draw_in_ipe(const iterator begin,const iterator end,const Iso_rectangle_2& bbox,bool make_grp=true,bool deselect_all=false,
typename boost::enable_if< boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Point_2> ,
boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Segment_2> ,
boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Circle_2> ,
boost::mpl::or_< boost::is_same<typename std::iterator_traits<iterator>::value_type,Circular_arc_2> ,
boost::is_same<typename std::iterator_traits<iterator>::value_type,Polygon_2>
> > > >
>::type* = nullptr) const
std::enable_if_t< boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Point_2> ,
boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Segment_2> ,
boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Circle_2> ,
boost::mpl::or_< std::is_same<typename std::iterator_traits<iterator>::value_type,Circular_arc_2> ,
std::is_same<typename std::iterator_traits<iterator>::value_type,Polygon_2>
> > > >::value
>* = nullptr) const
{
for (iterator it=begin;it!=end;++it)
draw_in_ipe(*it,bbox);

2
Cartesian_kernel/include/CGAL/Cartesian_converter.h
View File

@ -129,7 +129,7 @@ public:
template <typename T>
T
operator()(const T t,
typename std::enable_if<std::is_fundamental<T>::value>::type* = nullptr) const
std::enable_if_t<std::is_fundamental<T>::value>* = nullptr) const
{
return t;
}

2
Circular_kernel_2/include/CGAL/Circular_kernel_2/Circular_arc_point_2.h
View File

@ -22,10 +22,10 @@
#include <iostream>
#include <type_traits>
#include <CGAL/Handle.h>
#include <CGAL/Bbox_2.h>
#include <CGAL/Interval_nt.h>
#include <boost/type_traits/is_same.hpp>
namespace CGAL {
namespace internal {

2
Circular_kernel_3/include/CGAL/Circular_kernel_3/function_objects_polynomial_sphere.h
View File

@ -21,7 +21,7 @@
#include <CGAL/kernel_basic.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
#include <CGAL/Spherical_kernel_intersections.h>
#include <CGAL/Circular_kernel_3/internal_functions_on_circular_arc_point_3.h>

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

@ -15,7 +15,7 @@
#include <CGAL/Dart_iterators.h>
#include <CGAL/Combinatorial_map_basic_operations.h>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
// TODO do all the orbit iterator of any orbit ?
@ -82,7 +82,7 @@ namespace CGAL {
Ite(amap, adart, amap.get_new_mark()),
mcell_mark_number(amap.get_new_mark())
{
CGAL_static_assertion( (boost::is_same<typename Ite::Basic_iterator,
CGAL_static_assertion( (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( (boost::is_same<typename Ite::Basic_iterator,
CGAL_static_assertion( (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( (boost::is_same<typename Base::Basic_iterator,
CGAL_static_assertion( (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);

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

@ -40,8 +40,8 @@
#include <deque>
#include <tuple>
#include <map>
#include <type_traits>
#include <unordered_map>
#include <boost/type_traits/is_same.hpp>
#include <boost/graph/graph_traits.hpp>
#include <CGAL/boost/graph/helpers.h>
@ -1524,7 +1524,7 @@ namespace CGAL {
template < class Ite >
std::ostream& display_orbits(std::ostream & aos) const
{
CGAL_static_assertion( (boost::is_same<typename Ite::Basic_iterator,
CGAL_static_assertion( (std::is_same<typename Ite::Basic_iterator,
Tag_true>::value) );
unsigned int nb = 0;
size_type amark = get_new_mark();

14
Combinatorial_map/include/CGAL/Combinatorial_map/internal/Combinatorial_map_utility.h
View File

@ -17,8 +17,8 @@
#include <CGAL/Concurrent_compact_container.h>
#include <iostream>
#include <cstdint>
#include <type_traits>
#include <boost/type_traits/is_same.hpp>
#include <boost/function.hpp>
#include <boost/mpl/has_xxx.hpp>
@ -172,8 +172,8 @@ namespace CGAL
<Type,k,std::tuple<T...>,dim>::pos - 1;
static const int value =
( pos==k ) ? ( boost::is_same<T1,Type>::value ? 0:-dim-1 )
: ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 1:0 )
( pos==k ) ? ( std::is_same<T1,Type>::value ? 0:-dim-1 )
: ( ( pos<k ) ? ( ( std::is_same<T1,Type>::value ? 1:0 )
+ Nb_type_in_tuple_up_to_k
<Type,k,std::tuple
<T...>,dim >::value)
@ -186,7 +186,7 @@ namespace CGAL
{
static const int pos=dim;
static const int value=(pos==k?
(boost::is_same<T1,Type>::value?0:-dim-1) :
(std::is_same<T1,Type>::value?0:-dim-1) :
0);
};
@ -205,8 +205,8 @@ namespace CGAL
<Type,k,std::tuple<T...>,dim >::pos - 1;
static const int value =
( pos==k ) ? ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
: ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
( pos==k ) ? ( std::is_same<T1,Type>::value ? -dim-1 : 0 )
: ( ( pos<k ) ? ( ( std::is_same<T1,Type>::value ? 0:1 )
+ Nb_type_different_in_tuple_up_to_k
<Type,k,std::tuple<T...>,dim >::value)
:0
@ -219,7 +219,7 @@ namespace CGAL
{
static const int pos=dim;
static const int value=(pos==k?
(boost::is_same<T1,Type>::value?-dim-1:0) :
(std::is_same<T1,Type>::value?-dim-1:0) :
0);
};

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

@ -15,7 +15,7 @@
#include <CGAL/Combinatorial_map_iterators_base.h>
#include <CGAL/tags.h>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
namespace CGAL
{
@ -34,7 +34,7 @@ namespace CGAL
typename Map::Dart_const_descriptor adart1,
typename Map::Dart_const_descriptor adart2)
{
CGAL_static_assertion( (boost::is_same<typename Iterator::Basic_iterator,
CGAL_static_assertion( (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( (boost::is_same<typename Iterator::Basic_iterator,
CGAL_static_assertion( (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( (boost::is_same<typename Iterator::Basic_iterator,
CGAL_static_assertion( (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( (boost::is_same<typename Iterator::Basic_iterator,
CGAL_static_assertion( (std::is_same<typename Iterator::Basic_iterator,
Tag_true>::value) );
CGAL_assertion( (is_whole_orbit_unmarked<Map,
CMap_non_basic_iterator<Map,Iterator> >

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

@ -19,7 +19,8 @@
#include <queue>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <type_traits>
namespace CGAL {
@ -305,7 +306,7 @@ namespace CGAL {
typedef typename Map::size_type size_type;
CGAL_static_assertion( (Bi<=Map::dimension &&
boost::is_same<Ite_has_stack,Tag_false>::value) );
std::is_same<Ite_has_stack,Tag_false>::value) );
public:
/// Main constructor.
@ -492,7 +493,7 @@ namespace CGAL {
typedef typename Map::size_type size_type;
CGAL_static_assertion( (boost::is_same<typename Base::Basic_iterator,
CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
Tag_true>::value) );
/// Main constructor.
@ -578,7 +579,7 @@ namespace CGAL {
/// True iff this iterator is basic
typedef Tag_false Basic_iterator;
CGAL_static_assertion( (boost::is_same<typename Base::Basic_iterator,
CGAL_static_assertion( (std::is_same<typename Base::Basic_iterator,
Tag_true>::value) );
/// Main constructor.

21
Convex_hull_3/include/CGAL/convex_hull_3.h
View File

@ -40,14 +40,15 @@
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/iterator/transform_iterator.hpp>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/is_iterator.h>
#include <CGAL/type_traits/is_iterator.h>
#include <boost/next_prior.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/graph/graph_traits.hpp>
#include <type_traits>
#ifndef CGAL_CH_NO_POSTCONDITIONS
#include <CGAL/convexity_check_3.h>
#endif // CGAL_CH_NO_POSTCONDITIONS
@ -181,7 +182,7 @@ struct Is_cartesian_kernel< Convex_hull_traits_3<Kernel, PolygonMesh, Tag_true>
{
// Rational here is that Tag_true can only be passed by us since it is not documented
// so we can assume that Kernel is a CGAL Kernel
typedef typename boost::is_same<typename Kernel::Kernel_tag, Cartesian_tag>::type type;
typedef typename std::is_same<typename Kernel::Kernel_tag, Cartesian_tag>::type type;
};
// Predicate internally used as a wrapper around has_on_positive_side
@ -1052,7 +1053,7 @@ template <class InputIterator, class PolygonMesh>
void convex_hull_3(InputIterator first, InputIterator beyond,
PolygonMesh& polyhedron,
// workaround to avoid ambiguity with next overload.
typename std::enable_if<CGAL::is_iterator<InputIterator>::value>::type* = 0)
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0)
{
typedef typename std::iterator_traits<InputIterator>::value_type Point_3;
typedef typename Convex_hull_3::internal::Default_traits_for_Chull_3<Point_3, PolygonMesh>::type Traits;
@ -1083,9 +1084,9 @@ template <class InputIterator, class PointRange, class TriangleRange>
void convex_hull_3(InputIterator first, InputIterator beyond,
PointRange& vertices,
TriangleRange& faces,
typename std::enable_if<CGAL::is_iterator<InputIterator>::value>::type* = 0,
typename std::enable_if<boost::has_range_iterator<PointRange>::value>::type* = 0,
typename std::enable_if<boost::has_range_iterator<TriangleRange>::value>::type* = 0)
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0,
std::enable_if_t<boost::has_range_iterator<PointRange>::value>* = 0,
std::enable_if_t<boost::has_range_iterator<TriangleRange>::value>* = 0)
{
typedef typename std::iterator_traits<InputIterator>::value_type Point_3;
typedef typename Kernel_traits<Point_3>::type Traits;
@ -1100,9 +1101,9 @@ void convex_hull_3(InputIterator first, InputIterator beyond,
PointRange& vertices,
TriangleRange& faces,
const Traits& traits,
typename std::enable_if<CGAL::is_iterator<InputIterator>::value>::type* = 0,
typename std::enable_if<boost::has_range_iterator<PointRange>::value>::type* = 0,
typename std::enable_if<boost::has_range_iterator<TriangleRange>::value>::type* = 0)
std::enable_if_t<CGAL::is_iterator<InputIterator>::value>* = 0,
std::enable_if_t<boost::has_range_iterator<PointRange>::value>* = 0,
std::enable_if_t<boost::has_range_iterator<TriangleRange>::value>* = 0)
{
Convex_hull_3::internal::Indexed_triangle_set<PointRange, TriangleRange> its(vertices,faces);
convex_hull_3(first, beyond, its, traits);

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

85
Documentation/doc/resources/1.9.3/BaseDoxyfile.in
View File

@ -307,15 +307,15 @@ ALIASES = "cgal=%CGAL" \
"cgalExample{1}=<br><b>File</b> \ref \1 \include \1" \
"cgalFigureAnchor{1}=\anchor fig__\1" \
"cgalFigureRef{1}=\ref fig__\1" \
"cgalFigureBegin{2}=\anchor fig__\1 ^^ \image html \2 ^^ \image latex \2 \"\" width=15cm ^^ \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly \latexonly ^^ \endlatexonly ^^ \ref fig__\1" \
"cgalFigureBegin{3}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=7.5cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=7.5cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{4}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=5cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=5cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=5cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{5}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=3.75cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=3.75cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=3.75cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=3.75cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{6}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=3cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=3cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=3cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=3cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=3cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{7}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=2.5cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=2.5cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=2.5cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=2.5cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=2.5cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=2.5cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{8}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=2.1cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=2.1cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=2.1cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=2.1cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=2.1cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=2.1cm ^^ </TD> <TD> \image html \8 ^^ \image latex \8 \"\" width=2.1cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{9}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=1.9cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=1.9cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=1.9cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=1.9cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=1.9cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=1.9cm ^^ </TD> <TD> \image html \8 ^^ \image latex \8 \"\" width=1.9cm ^^ </TD> <TD> \image html \9 ^^ \image latex \9 \"\" width=1.9cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{10}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=1.6cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=1.6cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=1.6cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=1.6cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=1.6cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=1.6cm ^^ </TD> <TD> \image html \8 ^^ \image latex \8 \"\" width=1.6cm ^^ </TD> <TD> \image html \9 ^^ \image latex \9 \"\" width=1.6cm ^^ </TD> <TD> \image html \10 ^^ \image latex \10 \"\" width=1.6cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \latexonly ^^ \endlatexonly \ref fig__\1" \
"cgalFigureBegin{2}=\anchor fig__\1 ^^ \image html \2 ^^ \image latex \2 \"\" width=15cm ^^ \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{3}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=7.5cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=7.5cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{4}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=5cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=5cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=5cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{5}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=3.75cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=3.75cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=3.75cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=3.75cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{6}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=3cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=3cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=3cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=3cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=3cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{7}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=2.5cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=2.5cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=2.5cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=2.5cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=2.5cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=2.5cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{8}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=2.1cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=2.1cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=2.1cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=2.1cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=2.1cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=2.1cm ^^ </TD> <TD> \image html \8 ^^ \image latex \8 \"\" width=2.1cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{9}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=1.9cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=1.9cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=1.9cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=1.9cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=1.9cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=1.9cm ^^ </TD> <TD> \image html \8 ^^ \image latex \8 \"\" width=1.9cm ^^ </TD> <TD> \image html \9 ^^ \image latex \9 \"\" width=1.9cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureBegin{10}=\anchor fig__\1 ^^ <CENTER> <TABLE border=0> <TR> <TD> \image html \2 ^^ \image latex \2 \"\" width=1.6cm ^^ </TD> <TD> \image html \3 ^^ \image latex \3 \"\" width=1.6cm ^^ </TD> <TD> \image html \4 ^^ \image latex \4 \"\" width=1.6cm ^^ </TD> <TD> \image html \5 ^^ \image latex \5 \"\" width=1.6cm ^^ </TD> <TD> \image html \6 ^^ \image latex \6 \"\" width=1.6cm ^^ </TD> <TD> \image html \7 ^^ \image latex \7 \"\" width=1.6cm ^^ </TD> <TD> \image html \8 ^^ \image latex \8 \"\" width=1.6cm ^^ </TD> <TD> \image html \9 ^^ \image latex \9 \"\" width=1.6cm ^^ </TD> <TD> \image html \10 ^^ \image latex \10 \"\" width=1.6cm ^^ </TD> </TR> </TABLE> </CENTER> \htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly ^^ \ref fig__\1" \
"cgalFigureEnd=\htmlonly[block] </div> \endhtmlonly <br>" \
"cgalFigureCaptionBegin{1}=\htmlonly[block] <div class=\"cgal_figure_caption\"> \endhtmlonly \ref fig__\1" \
"cgalFigureCaptionEnd=\htmlonly[block] </div> \endhtmlonly <br>" \
@ -1308,6 +1308,23 @@ HTML_STYLESHEET = ${CGAL_DOC_RESOURCE_DIR}/stylesheet.css
HTML_EXTRA_STYLESHEET =
# The HTML_COLORSTYLE tag can be used to specify if the generated HTML output
# should be rendered with a dark or light theme. Default setting AUTO_LIGHT
# enables light output unless the user preference is dark output. Other options
# are DARK to always use dark mode, LIGHT to always use light mode, AUTO_DARK to
# default to dark mode unless the user prefers light mode, and TOGGLE to let the
# user toggle between dark and light mode via a button.
# Possible values are: LIGHT Always generate light output., DARK Always generate
# dark output., AUTO_LIGHT Automatically set the mode according to the user
# preference, use light mode if no preference is set (the default)., AUTO_DARK
# Automatically set the mode according to the user preference, use dark mode if
# no preference is set. and TOGGLE Allow to user to switch between light and
# dark mode via a button..
# The default value is: AUTO_LIGHT.
# This tag requires that the tag GENERATE_HTML is set to YES.
HTML_COLORSTYLE = LIGHT
# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
# other source files which should be copied to the HTML output directory. Note
# that these files will be copied to the base HTML output directory. Use the
@ -1649,17 +1666,6 @@ HTML_FORMULA_FORMAT = svg
FORMULA_FONTSIZE = 10
# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are not
# supported properly for IE 6.0, but are supported on all modern browsers.
#
# Note that when changing this option you need to delete any form_*.png files in
# the HTML output directory before the changes have effect.
# The default value is: YES.
# This tag requires that the tag GENERATE_HTML is set to YES.
FORMULA_TRANSPARENT = YES
# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
# to create new LaTeX commands to be used in formulas as building blocks. See
# the section "Including formulas" for details.
@ -2355,22 +2361,27 @@ HAVE_DOT = YES
DOT_NUM_THREADS = 0
# When you want a differently looking font in the dot files that doxygen
# generates you can specify the font name using DOT_FONTNAME. You need to make
# sure dot is able to find the font, which can be done by putting it in a
# standard location or by setting the DOTFONTPATH environment variable or by
# setting DOT_FONTPATH to the directory containing the font.
# The default value is: Helvetica.
# DOT_COMMON_ATTR is common attributes for nodes, edges and labels of
# subgraphs. When you want a differently looking font in the dot files that
# doxygen generates you can specify fontname, fontcolor and fontsize attributes.
# For details please see <a href=https://graphviz.org/doc/info/attrs.html>Node,
# Edge and Graph Attributes specification</a> You need to make sure dot is able
# to find the font, which can be done by putting it in a standard location or by
# setting the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
# directory containing the font. Default graphviz fontsize is 14.
# The default value is: fontname=Helvetica,fontsize=10.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTNAME = Helvetica
DOT_COMMON_ATTR = "fontname=Helvetica,fontsize=10"
# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
# dot graphs.
# Minimum value: 4, maximum value: 24, default value: 10.
# DOT_EDGE_ATTR is concatenated with DOT_COMMON_ATTR. For elegant style you can
# add 'arrowhead=open, arrowtail=open, arrowsize=0.5'. <a
# href=https://graphviz.org/doc/info/arrows.html>Complete documentation about
# arrows shapes.</a>
# The default value is: labelfontname=Helvetica,labelfontsize=10.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_FONTSIZE = 10
DOT_EDGE_ATTR = "labelfontname=Helvetica,labelfontsize=10"
# By default doxygen will tell dot to use the default font as specified with
# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
@ -2584,18 +2595,6 @@ DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not seem
# to support this out of the box.
#
# Warning: Depending on the platform used, enabling this option may lead to
# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
# read).
# The default value is: NO.
# This tag requires that the tag HAVE_DOT is set to YES.
DOT_TRANSPARENT = NO
# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
# files in one run (i.e. multiple -o and -T options on the command line). This
# makes dot run faster, but since only newer versions of dot (>1.8.10) support

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