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

Merge pull request #7403 from sloriot/CGAL-replace_boost_by_std 

Replace boost by std
This commit is contained in:
Sébastien Loriot 2023-07-05 11:08:36 +02:00
parent f7a78677fc 8bc01b14a9
commit 68813c5c63
212 changed files with 1633 additions and 1058 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -24,7 +24,6 @@
#include <iterator>
#include <boost/mpl/and.hpp>
#include <CGAL/type_traits/is_iterator.h>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/mpl/if.hpp>
#include <CGAL/Default.h>

5
AABB_tree/include/CGAL/AABB_tree.h
View File

@ -27,7 +27,6 @@
#include <CGAL/AABB_tree/internal/Has_nested_type_Shared_data.h>
#include <CGAL/AABB_tree/internal/Primitive_helper.h>
#include <boost/optional.hpp>
#include <boost/lambda/lambda.hpp>
#ifdef CGAL_HAS_THREADS
#include <CGAL/mutex.h>
@ -326,7 +325,7 @@ public:
boost::optional< typename Intersection_and_primitive_id<Ray>::Type >
first_intersection(const Ray& query) const
{
return first_intersection(query, boost::lambda::constant(false));
return first_intersection(query, [](Primitive_id){ return false; });
}
/// \endcond
@ -351,7 +350,7 @@ public:
boost::optional<Primitive_id>
first_intersected_primitive(const Ray& query) const
{
return first_intersected_primitive(query, boost::lambda::constant(false));
return first_intersected_primitive(query, [](Primitive_id){ return false; });
}
/// \endcond
///@}

1
AABB_tree/test/AABB_tree/aabb_test_multi_mesh.cpp
View File

@ -3,7 +3,6 @@
#include <iterator>
#include <boost/functional/value_factory.hpp>
#include <boost/array.hpp>
#include <CGAL/algorithm.h>
#include <CGAL/point_generators_3.h>

3
AABB_tree/test/AABB_tree/aabb_test_ray_intersection.cpp
View File

@ -3,7 +3,6 @@
#include <iterator>
#include <boost/functional/value_factory.hpp>
#include <boost/array.hpp>
#include <CGAL/assertions.h>
#include <CGAL/algorithm.h>
@ -92,7 +91,7 @@ int main()
Vector bbox_center((bbox.xmin() + bbox.xmax()) / 2,
(bbox.ymin() + bbox.ymax()) / 2,
(bbox.zmin() + bbox.zmax()) / 2);
boost::array<double, 3> extents;
std::array<double, 3> extents;
extents[0] = bbox.xmax() - bbox.xmin();
extents[1] = bbox.ymax() - bbox.ymin();
extents[2] = bbox.zmax() - bbox.zmin();

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

@ -612,10 +612,8 @@ class Test_is_square {
CGAL_USE_TYPE(First_argument_type);
CGAL_USE_TYPE(Second_argument_type);
static_assert(
( ::std::is_same< AS , First_argument_type>::value));
static_assert(
( ::std::is_same< AS& , Second_argument_type>::value));
static_assert(::std::is_same< AS , First_argument_type>::value);
static_assert(::std::is_same< AS& , Second_argument_type>::value);
//static_assert(::std::is_same< bool , Result_type>::value);
bool b = Result_type(true); CGAL_USE(b);
@ -674,12 +672,9 @@ public:
CGAL_USE_TYPE(First_argument_type);
CGAL_USE_TYPE(Second_argument_type);
CGAL_USE_TYPE(Result_type);
static_assert(
( ::std::is_same<int, First_argument_type>::value));
static_assert(
( ::std::is_same< AS , Second_argument_type>::value));
static_assert(
( ::std::is_same< AS , Result_type>::value));
static_assert(::std::is_same<int, First_argument_type>::value);
static_assert(::std::is_same< AS , Second_argument_type>::value);
static_assert(::std::is_same< AS , Result_type>::value);
AS epsilon(1);
assert( test_equality_epsilon( AS (2),
root( 4, AS (16) ), epsilon ) );
@ -821,6 +816,7 @@ void test_algebraic_structure(){
static_assert(::std::is_same< Tag, Algebraic_category>::value);
static_assert(!::std::is_same< Simplify, Null_functor>::value);
static_assert(!::std::is_same< Unit_part, Null_functor>::value);
const Simplify simplify=Simplify();;
const Unit_part unit_part= Unit_part();
@ -940,8 +936,7 @@ void test_algebraic_structure( const AS & a, const AS & b, const AS & c) {
typedef CGAL::Algebraic_structure_traits<AS> AST;
typedef typename AST::Is_numerical_sensitive Is_numerical_sensitive;
static_assert(
!(::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value));
static_assert(!::std::is_same<Is_numerical_sensitive, CGAL::Null_tag>::value);
CGAL_USE_TYPE(Is_numerical_sensitive);
}

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

@ -23,7 +23,6 @@
#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>
@ -66,14 +65,14 @@ namespace internal {
template<typename Comparable,bool has_template_typedefs>
struct Is_derived_from_Handle_with_policy {
typedef boost::false_type Tag;
typedef std::false_type Tag;
};
template<typename Comparable>
struct Is_derived_from_Handle_with_policy<Comparable,true> {
typedef typename
boost::is_base_of< CGAL::Handle_with_policy
std::is_base_of< CGAL::Handle_with_policy
< typename Comparable::T,
typename Comparable::Handle_policy,
typename Comparable::Allocator >,
@ -90,7 +89,7 @@ template<typename Comparable,typename Tag> struct Compare_for_vert_line_map_
};
template<typename Comparable>
struct Compare_for_vert_line_map_<Comparable,boost::true_type> {
struct Compare_for_vert_line_map_<Comparable,std::true_type> {
bool operator() (const Comparable& a, const Comparable& b) const {
return CGAL::Handle_id_less_than< Comparable >()(a,b);

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

@ -448,7 +448,7 @@ struct Alpha_nt_selector_2
GeomTraits,
// If the base traits is already exact then we don't need to do anything,
// and we can simply directly use the traits class
Boolean_tag<boost::is_floating_point<typename GeomTraits::FT>::value &&
Boolean_tag<std::is_floating_point<typename GeomTraits::FT>::value &&
ExactAlphaComparisonTag::value >,
Weighted_tag>
{ };

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

@ -417,7 +417,7 @@ struct Alpha_nt_selector_3
GeomTraits,
// If the base traits is already exact then we don't need to do anything,
// and we can simply directly use the traits class
Boolean_tag<boost::is_floating_point<typename GeomTraits::FT>::value &&
Boolean_tag<std::is_floating_point<typename GeomTraits::FT>::value &&
ExactAlphaComparisonTag::value >,
Weighted_tag>
{ };

3
Alpha_shapes_3/include/CGAL/Fixed_alpha_shape_3.h
View File

@ -27,7 +27,6 @@
#include <utility>
#include <iostream>
#include <queue>
#include <boost/next_prior.hpp>
#include <CGAL/Triangulation_utils_3.h>
#include <CGAL/Unique_hash_map.h>
@ -255,7 +254,7 @@ public:
std::back_inserter(cells),
Emptyset_iterator()));
Facet facet=*boost::prior(facets_on_the_boundary_of_the_hole.end());
Facet facet=*std::prev(facets_on_the_boundary_of_the_hole.end());
// Remember the points that are hidden by the conflicting cells,
// as they will be deleted during the insertion.

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

@ -352,7 +352,7 @@ namespace CGAL {
//typedef const result_type& qualified_result_type;
template < typename T >
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference_t<qualified_result_type>
Circular_arc_point_2
operator()(const T &a) const
{
@ -370,7 +370,7 @@ namespace CGAL {
typedef Point_2 result_type;
//typedef const result_type& qualified_result_type;
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference_t<qualified_result_type>
result_type
operator() (const boost::variant< Arc1, Arc2 > & cv) const
{
@ -397,7 +397,7 @@ namespace CGAL {
//typedef const result_type& qualified_result_type;
template < typename T >
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference_t<qualified_result_type>
Circular_arc_point_2
operator()(const T &a) const
{
@ -420,7 +420,7 @@ namespace CGAL {
typedef Point_2 result_type;
//typedef const result_type& qualified_result_type;
//typename boost::remove_reference<qualified_result_type>::type
//std::remove_reference<qualified_result_type>
result_type
operator() (const boost::variant< Arc1, Arc2 > & cv) const
{

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

@ -79,7 +79,7 @@ public:
typedef Tag_true Has_left_category;
typedef Tag_true Has_merge_category;
typedef Tag_false Has_do_intersect_category;
//typedef boost::true_type Has_line_segment_constructor;
//typedef std::true_type Has_line_segment_constructor;
typedef Arr_oblivious_side_tag Left_side_category;
typedef Arr_oblivious_side_tag Bottom_side_category;

18
Arrangement_on_surface_2/include/CGAL/Arr_geodesic_arc_on_sphere_traits_2.h
View File

@ -66,7 +66,7 @@ public:
typedef Arr_contracted_side_tag Top_side_category;
typedef Arr_identified_side_tag Right_side_category;
typedef boost::integral_constant<bool, atan_y==0> Zero_atan_y;
typedef std::integral_constant<bool, atan_y==0> Zero_atan_y;
// Traits objects
typedef Arr_extended_direction_3<Kernel> Point_2;
@ -358,7 +358,7 @@ public:
*/
void intersection_with_identification(const X_monotone_curve_2& xcv,
Direction_3& dp,
boost::true_type) const
std::true_type) const
{
const Direction_3& normal = xcv.normal();
dp = (CGAL::sign(normal.dz()) == POSITIVE) ?
@ -371,7 +371,7 @@ public:
*/
void intersection_with_identification(const X_monotone_curve_2& xcv,
Direction_3& dp,
boost::false_type) const
std::false_type) const
{
const Direction_3& normal = xcv.normal();
FT z((atan_x * normal.dx() + atan_y * normal.dy()) /
@ -383,7 +383,7 @@ public:
* \param[in] cv the curve
*/
bool overlap_with_identification(const X_monotone_curve_2& xcv,
boost::true_type) const
std::true_type) const
{
const Direction_3& normal = xcv.normal();
return ((x_sign(normal) == ZERO) &&
@ -395,7 +395,7 @@ public:
* \param[in] cv the curve
*/
bool overlap_with_identification(const X_monotone_curve_2& xcv,
boost::false_type) const
std::false_type) const
{
const Direction_3& normal = xcv.normal();
const Direction_3& iden_normal = identification_normal();
@ -441,7 +441,7 @@ public:
Point_2 p;
Direction_3& d(p);
d = Direction_3(x, y, z);
init(p, boost::integral_constant<bool, atan_y==0>());
init(p, std::integral_constant<bool, atan_y==0>());
return p;
}
@ -454,14 +454,14 @@ public:
Point_2 p;
Direction_3& d(p);
d = Direction_3(other);
init(p, boost::integral_constant<bool, atan_y==0>());
init(p, std::integral_constant<bool, atan_y==0>());
return p;
}
/*! Initialize a point on the sphere,
* \param[in] p the point to initialize.
*/
void init(Point_2& p, boost::true_type) const
void init(Point_2& p, std::true_type) const
{
const Direction_3& dir = p;
if (y_sign(dir) != ZERO) {
@ -480,7 +480,7 @@ public:
/*! Initialize a point on the sphere,
* \param[in] p the point to initialize.
*/
void init(Point_2& p, boost::false_type) const
void init(Point_2& p, std::false_type) const
{
const Direction_3& dir = p;
if ((x_sign(dir) == ZERO) && (y_sign(dir) == ZERO)) {

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

@ -61,7 +61,7 @@ namespace Ss2 = Surface_sweep_2;
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
// Curve_2 are the same class.
// The last parameter should be boost::false_type but we used a
// The last parameter should be std::false_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -132,7 +132,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
//
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
// same class. The last parameter should be boost::true_type but we used a
// same class. The last parameter should be std::true_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -406,7 +406,7 @@ void insert_non_empty(Arrangement_on_surface_2<GeometryTraits_2,
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
// Curve_2 are the same class.
// The last parameter should be boost::false_type but we used a
// The last parameter should be std::false_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -460,7 +460,7 @@ void insert(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
//
// The last parameter is used to resolve ambiguity between this function and
// insert of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
// same class. The last parameter should be boost::true_type but we used a
// same class. The last parameter should be std::true_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_2<>&,
@ -1522,7 +1522,7 @@ zone(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
// Checks whether the given x-monotone curve intersects the existing arrangement.
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of Curve_2 in case that X_monotone_curve_2 and Curve_2 are the
// same class. The last parameter should be boost::true_type but we used a
// same class. The last parameter should be std::true_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to `do_intersect(Arrangement_on_surface_2<>&,
@ -1559,7 +1559,7 @@ do_intersect(Arrangement_on_surface_2<GeometryTraits_2, TopologyTraits>& arr,
// The last parameter is used to resolve ambiguity between this function and
// do_intersect of X_monotone_curve_2 in case that X_monotone_curve_2 and
// Curve_2 are the same class.
// The last parameter should be boost::false_type but we used a
// The last parameter should be std::false_type but we used a
// workaround since it didn't compile in FC3_g++-3.4.4 with the error of:
//
// error: no matching function for call to

8
Arrangement_on_surface_2/include/CGAL/Arrangement_2/arrangement_type_traits.h
View File

@ -24,7 +24,7 @@
#include <CGAL/license/Arrangement_on_surface_2.h>
#include <boost/type_traits/integral_constant.hpp>
#include <type_traits>
namespace CGAL
{
@ -62,7 +62,7 @@ namespace CGAL
// In the meanwhile we use a default implementation.
template <class T>
class is_arrangement_2 : public boost::false_type
class is_arrangement_2 : public std::false_type
{};
//-------------------------------- Arrangement_2
@ -74,7 +74,7 @@ class Arrangement_2;
template <class GeomTraits_, class DCEL_>
class is_arrangement_2<
Arrangement_2<GeomTraits_, DCEL_>
> : public boost::false_type
> : public std::false_type
{};
@ -87,7 +87,7 @@ class Arrangement_on_surface_2;
template <class GeomTraits_, class TopTraits_>
class is_arrangement_2<
Arrangement_on_surface_2<GeomTraits_, TopTraits_>
> : public boost::true_type
> : public std::true_type
{};
} // namespace CGAL

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

@ -62,7 +62,6 @@
#include <CGAL/Bbox_2.h>
#include <CGAL/Arithmetic_kernel.h>
#include <boost/array.hpp>
#include <CGAL/Curved_kernel_via_analysis_2/gfx/Curve_renderer_2.h>

2
BGL/include/CGAL/boost/graph/Dual.h
View File

@ -458,7 +458,7 @@ out_degree(typename boost::graph_traits<Dual<P> >::vertex_descriptor v,
const Dual<P>& dual)
{
const typename Dual<P>::Primal& primal = dual.primal();
return boost::distance(halfedges_around_face(halfedge(v,primal),primal));
return halfedges_around_face(halfedge(v,primal),primal).size();
}
template <typename P>

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

@ -486,8 +486,8 @@ struct Face_filtered_graph
selected_halfedges.reset();
typedef typename boost::property_traits<FacePatchIndexMap>::value_type Patch_index;
std::unordered_set<Patch_index> pids(boost::begin(selected_face_patch_indices),
boost::end(selected_face_patch_indices));
std::unordered_set<Patch_index> pids(std::begin(selected_face_patch_indices),
std::end(selected_face_patch_indices));
for(face_descriptor fd : faces(_graph) )
{

2
BGL/include/CGAL/boost/graph/IO/STL.h
View File

@ -264,7 +264,7 @@ bool write_STL(std::ostream& os,
if(get_mode(os) == BINARY)
{
os << "FileType: Binary ";
const boost::uint32_t N32 = static_cast<boost::uint32_t>(faces(g).size());
const std::uint32_t N32 = static_cast<std::uint32_t>(faces(g).size());
os.write(reinterpret_cast<const char *>(&N32), sizeof(N32));
for(const face_descriptor f : faces(g))

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

@ -848,12 +848,12 @@ inline
std::enable_if_t<!Has_member_clear<FaceGraph>::value, void>
clear_impl(FaceGraph& g)
{
while(boost::begin(edges(g))!=boost::end(edges(g)))
remove_edge(*boost::begin(edges(g)), g);
while(boost::begin(faces(g))!=boost::end(faces(g)))
remove_face(*boost::begin(faces(g)), g);
while(boost::begin(vertices(g))!=boost::end(vertices(g)))
remove_vertex(*boost::begin(vertices(g)), g);
while(std::begin(edges(g))!=std::end(edges(g)))
remove_edge(*std::begin(edges(g)), g);
while(std::begin(faces(g))!=std::end(faces(g)))
remove_face(*std::begin(faces(g)), g);
while(std::begin(vertices(g))!=std::end(vertices(g)))
remove_vertex(*std::begin(vertices(g)), g);
}
template <class FaceGraph>
@ -975,9 +975,9 @@ template<typename FaceGraph>
void clear(FaceGraph& g)
{
internal::clear_impl(g);
CGAL_postcondition(std::distance(boost::begin(edges(g)),boost::end(edges(g))) == 0);
CGAL_postcondition(std::distance(boost::begin(vertices(g)),boost::end(vertices(g))) == 0);
CGAL_postcondition(std::distance(boost::begin(faces(g)),boost::end(faces(g))) == 0);
CGAL_postcondition(std::distance(std::begin(edges(g)),std::end(edges(g))) == 0);
CGAL_postcondition(std::distance(std::begin(vertices(g)),std::end(vertices(g))) == 0);
CGAL_postcondition(std::distance(std::begin(faces(g)),std::end(faces(g))) == 0);
}
/**

2
BGL/include/CGAL/boost/graph/properties.h
View File

@ -140,7 +140,7 @@ struct Point_accessor<Handle, ValueType, ConstReference, true>
typedef ValueType value_type;
typedef Handle key_type;
typedef typename boost::mpl::if_< boost::is_reference<ConstReference>,
typedef typename boost::mpl::if_< std::is_reference<ConstReference>,
ValueType&,
ValueType >::type Reference;

30
BGL/include/CGAL/boost/graph/property_maps.h
View File

@ -15,9 +15,7 @@
#include <CGAL/property_map.h>
#include <CGAL/boost/graph/properties.h>
#include <boost/type_traits/is_const.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/remove_const.hpp>
namespace CGAL{
@ -25,7 +23,7 @@ namespace CGAL{
template < class TriangleMesh,
class VertexPointMap = typename boost::property_map<TriangleMesh,vertex_point_t>::type >
struct Triangle_from_face_descriptor_map{
typename boost::remove_const<TriangleMesh>::type* m_tm;
typename std::remove_const_t<TriangleMesh>* m_tm;
VertexPointMap m_vpm;
Triangle_from_face_descriptor_map()
@ -33,13 +31,13 @@ struct Triangle_from_face_descriptor_map{
{}
Triangle_from_face_descriptor_map(TriangleMesh const* tm)
: m_tm( const_cast<typename boost::remove_const<TriangleMesh>::type*>(tm) )
: m_tm( const_cast<std::remove_const_t<TriangleMesh>*>(tm) )
, m_vpm( get(vertex_point, *m_tm) )
{}
Triangle_from_face_descriptor_map(TriangleMesh const* tm,
VertexPointMap vpm )
: m_tm(const_cast<typename boost::remove_const<TriangleMesh>::type*>(tm))
: m_tm(const_cast<std::remove_const_t<TriangleMesh>*>(tm))
, m_vpm(vpm)
{}
@ -57,7 +55,7 @@ struct Triangle_from_face_descriptor_map{
get(const Triangle_from_face_descriptor_map<TriangleMesh,VertexPointMap>& pmap,
key_type f)
{
typename boost::remove_const<TriangleMesh>::type & tm = *(pmap.m_tm);
std::remove_const_t<TriangleMesh>& tm = *(pmap.m_tm);
CGAL_precondition(halfedge(f,tm) == next(next(next(halfedge(f,tm),tm),tm),tm));
return value_type( get(pmap.m_vpm, target(halfedge(f,tm),tm)),
@ -70,7 +68,7 @@ struct Triangle_from_face_descriptor_map{
get(const Triangle_from_face_descriptor_map<TriangleMesh,VertexPointMap>& pmap,
const std::pair<key_type, const TriangleMesh*>& f)
{
typename boost::remove_const<TriangleMesh>::type & tm = *(pmap.m_tm);
std::remove_const_t<TriangleMesh> & tm = *(pmap.m_tm);
CGAL_precondition(halfedge(f.first,tm) == next(next(next(halfedge(f.first,tm),tm),tm),tm));
return value_type( get(pmap.m_vpm, target(halfedge(f.first,tm),tm)),
@ -88,13 +86,13 @@ struct Segment_from_edge_descriptor_map{
{}
Segment_from_edge_descriptor_map(PolygonMesh const * pm)
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(pm) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(pm) )
, m_vpm( get(vertex_point, *m_pm) )
{}
Segment_from_edge_descriptor_map(PolygonMesh const * pm,
VertexPointMap vpm )
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(pm) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(pm) )
, m_vpm(vpm)
{}
@ -106,7 +104,7 @@ struct Segment_from_edge_descriptor_map{
typedef value_type reference;
typedef boost::readable_property_map_tag category;
//data
typename boost::remove_const<PolygonMesh>::type* m_pm;
std::remove_const_t<PolygonMesh>* m_pm;
VertexPointMap m_vpm;
//get function for property map
@ -138,16 +136,16 @@ struct One_point_from_face_descriptor_map{
{}
One_point_from_face_descriptor_map(PolygonMesh const * g)
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm( get(vertex_point, *m_pm) )
{}
One_point_from_face_descriptor_map(PolygonMesh const * g, VertexPointMap vpm )
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm(vpm)
{}
typename boost::remove_const<PolygonMesh>::type* m_pm;
std::remove_const_t<PolygonMesh>* m_pm;
VertexPointMap m_vpm;
//classical typedefs
@ -182,12 +180,12 @@ struct Source_point_from_edge_descriptor_map{
{}
Source_point_from_edge_descriptor_map(PolygonMesh const * g)
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm( get(vertex_point, *m_pm) )
{}
Source_point_from_edge_descriptor_map(PolygonMesh const * g, VertexPointMap vpm )
: m_pm( const_cast<typename boost::remove_const<PolygonMesh>::type*>(g) )
: m_pm( const_cast<std::remove_const_t<PolygonMesh>*>(g) )
, m_vpm(vpm)
{}
@ -198,7 +196,7 @@ struct Source_point_from_edge_descriptor_map{
typedef boost::readable_property_map_tag category;
//data
typename boost::remove_const<PolygonMesh>::type* m_pm;
std::remove_const_t<PolygonMesh>* m_pm;
VertexPointMap m_vpm;
//get function for property map

339
BGL/include/CGAL/boost/graph/visitor.h
View File

@ -14,13 +14,13 @@
#include <boost/graph/graph_traits.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/ref.hpp>
#include <utility>
namespace boost
{
template<typename V, typename Graph>
struct graph_traits<
boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> > >
boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> > >
: boost::graph_traits< Graph >
{
typedef boost::graph_traits<Graph> Base;
@ -29,20 +29,20 @@ namespace boost
template<typename V, typename Graph>
struct graph_traits<
boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> > const >
boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> > const >
: boost::graph_traits< Graph >
{};
template<typename V, typename Graph, class PropertyTag>
struct property_map<
boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> >,
boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> >,
PropertyTag>
: public property_map<Graph, PropertyTag>
{};
template<typename V, typename Graph, class PropertyTag>
struct property_map<
const boost::tuple<boost::reference_wrapper<V>, boost::reference_wrapper<Graph> >,
const boost::tuple<std::reference_wrapper<V>, std::reference_wrapper<Graph> >,
PropertyTag>
: public property_map<Graph, PropertyTag>
{};
@ -52,11 +52,11 @@ namespace boost
namespace CGAL
{
template<typename V, typename Graph>
boost::tuple<boost::reference_wrapper<V>,
boost::reference_wrapper<Graph> >
boost::tuple<std::reference_wrapper<V>,
std::reference_wrapper<Graph> >
make_graph_with_visitor(V& v, Graph& g)
{
return boost::make_tuple(boost::ref(v), boost::ref(g));
return boost::make_tuple(std::ref(v), std::ref(g));
}
template<typename Graph>
@ -67,11 +67,8 @@ public:
typedef typename gt::halfedge_descriptor halfedge_descriptor;
typedef typename gt::edge_descriptor edge_descriptor;
typedef typename gt::vertex_descriptor vertex_descriptor;
};
//// OVERLOADS FOR Visitor
template<typename Graph>
@ -260,119 +257,119 @@ void get(PropertyTag ptag, const Visitor_base<Graph>& w)
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::vertices_size_type
num_vertices(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
num_vertices(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
num_vertices(boost::unwrap_ref(w.get<0>()));
return num_vertices(boost::unwrap_ref(w.get<1>()));
num_vertices(get<0>(w).get());
return num_vertices(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::edges_size_type
num_edges(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
num_edges(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
num_edges(boost::unwrap_ref(w.get<0>()));
return num_edges(boost::unwrap_ref(w.get<1>()));
num_edges(get<0>(w).get());
return num_edges(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::degree_size_type
degree(typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
degree(v, boost::unwrap_ref(w.get<0>()));
return degree(v, boost::unwrap_ref(w.get<1>()));
degree(v, get<0>(w).get());
return degree(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::degree_size_type
out_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
out_degree(v, boost::unwrap_ref(w.get<0>()));
return out_degree(v, boost::unwrap_ref(w.get<1>()));
out_degree(v, get<0>(w).get());
return out_degree(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::degree_size_type
in_degree(typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
in_degree(v, boost::unwrap_ref(w.get<0>()));
return in_degree(v, boost::unwrap_ref(w.get<1>()));
in_degree(v, get<0>(w).get());
return in_degree(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::vertex_descriptor
source(typename boost::graph_traits<Graph>::edge_descriptor e
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> > & w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> > & w)
{
source(e, boost::unwrap_ref(w.get<0>()));
return source(e, boost::unwrap_ref(w.get<1>()));
source(e, get<0>(w).get());
return source(e, get<1>(w).get);
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::vertex_descriptor
target(typename boost::graph_traits<Graph>::edge_descriptor e
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> > & w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> > & w)
{
target(e, boost::unwrap_ref(w.get<0>()));
return target(e, boost::unwrap_ref(w.get<1>()));
target(e, get<0>(w).get());
return target(e, get<1>(w).get());
}
template <class Graph, class Visitor>
std::pair<typename boost::graph_traits<Graph>::edge_descriptor, bool>
edge(typename boost::graph_traits<Graph>::vertex_descriptor u
, typename boost::graph_traits<Graph>::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> > & w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> > & w)
{
edge(u, v, boost::unwrap_ref(w.get<0>()));
return edge(u, v, boost::unwrap_ref(w.get<1>()));
edge(u, v, get<0>(w).get());
return edge(u, v, get<1>(w).get);
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::vertex_iterator>
vertices(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
vertices(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
vertices(boost::unwrap_ref(w.get<0>()));
return vertices(boost::unwrap_ref(w.get<1>()));
vertices(get<0>(w).get());
return vertices(get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::edge_iterator>
edges(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
edges(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
edges(boost::unwrap_ref(w.get<0>()));
return edges(boost::unwrap_ref(w.get<1>()));
edges(get<0>(w).get());
return edges(get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::in_edge_iterator>
in_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
in_edges(u, boost::unwrap_ref(w.get<0>()));
return in_edges(u, boost::unwrap_ref(w.get<1>()));
in_edges(u, get<0>(w).get());
return in_edges(u, get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::out_edge_iterator>
out_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
out_edges(u, boost::unwrap_ref(w.get<0>()));
return out_edges(u, boost::unwrap_ref(w.get<1>()));
out_edges(u, get<0>(w).get());
return out_edges(u, get<1>(w).get());
}
//
@ -381,72 +378,72 @@ out_edges(typename boost::graph_traits<Graph>::vertex_descriptor u
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
add_vertex(boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
add_vertex(boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_vertex(boost::unwrap_ref(w.get<0>()));
return add_vertex(boost::unwrap_ref(w.get<1>()));
add_vertex(get<0>(w).get());
return add_vertex(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
add_vertex(const typename boost::graph_traits<Graph >::vertex_property_type& p
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_vertex(p, boost::unwrap_ref(w.get<0>()));
return add_vertex(p, boost::unwrap_ref(w.get<1>()));
add_vertex(p, get<0>(w).get());
return add_vertex(p, get<1>(w).get());
}
template <class Graph, class Visitor>
void
remove_vertex(typename boost::graph_traits< Graph >::vertex_descriptor v
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
remove_vertex(v, boost::unwrap_ref(w.get<0>()));
remove_vertex(v, boost::unwrap_ref(w.get<1>()));
remove_vertex(v, get<0>(w).get());
remove_vertex(v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::edge_descriptor
add_edge(boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
add_edge(boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_edge(boost::unwrap_ref(w.get<0>()));
return add_edge(boost::unwrap_ref(w.get<1>()));
add_edge(get<0>(w).get());
return add_edge(get<1>(w).get());
}
template <class Graph, class Visitor>
void
remove_edge(typename boost::graph_traits< Graph >::edge_descriptor e
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
remove_edge(e, boost::unwrap_ref(w.get<0>()));
remove_edge(e, boost::unwrap_ref(w.get<1>()));
remove_edge(e, get<0>(w).get());
remove_edge(e, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_target(typename boost::graph_traits< Graph >::halfedge_descriptor h1
, typename boost::graph_traits< Graph >::vertex_descriptor v
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_target(h1, v, boost::unwrap_ref(w.get<0>()));
set_target(h1, v, boost::unwrap_ref(w.get<1>()));
set_target(h1, v, get<0>(w).get());
set_target(h1, v, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_next(typename boost::graph_traits< Graph >::halfedge_descriptor h1
, typename boost::graph_traits< Graph >::halfedge_descriptor h2
, boost::tuple<boost::reference_wrapper<Visitor >,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor >,
std::reference_wrapper<Graph> >& w)
{
set_next(h1, h2, boost::unwrap_ref(w.get<0>()));
set_next(h1, h2, boost::unwrap_ref(w.get<1>()));
set_next(h1, h2, get<0>(w).get());
set_next(h1, h2, get<1>(w).get());
}
//
@ -454,65 +451,65 @@ set_next(typename boost::graph_traits< Graph >::halfedge_descriptor h1
//
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::face_descriptor
add_face(boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
add_face(boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_face(boost::unwrap_ref(w.get<0>()));
return add_face(boost::unwrap_ref(w.get<1>()));
add_face(get<0>(w).get());
return add_face(get<1>(w).get());
}
template <class InputIterator, class Graph, class Visitor>
typename boost::graph_traits< Graph >::face_descriptor
add_face(InputIterator begin,
InputIterator end,
boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
add_face(begin, end, boost::unwrap_ref(w.get<0>()));
return add_face(begin, end, boost::unwrap_ref(w.get<1>()));
add_face(begin, end, get<0>(w).get());
return add_face(begin, end, get<1>(w).get());
}
template <class Graph, class Visitor>
void
remove_face(typename boost::graph_traits< Graph >::face_descriptor f
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
remove_face(f, boost::unwrap_ref(w.get<0>()));
return remove_face(f, boost::unwrap_ref(w.get<1>()));
remove_face(f, get<0>(w).get());
return remove_face(f, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_face(typename boost::graph_traits< Graph >::halfedge_descriptor h
, typename boost::graph_traits< Graph >::face_descriptor f
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_face(h, f, boost::unwrap_ref(w.get<0>()));
set_face(h, f, boost::unwrap_ref(w.get<1>()));
set_face(h, f, get<0>(w).get());
set_face(h, f, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_halfedge(typename boost::graph_traits< Graph >::face_descriptor f
, typename boost::graph_traits< Graph >::halfedge_descriptor h
, boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_halfedge(f, h, boost::unwrap_ref(w.get<0>()));
set_halfedge(f, h, boost::unwrap_ref(w.get<1>()));
set_halfedge(f, h, get<0>(w).get());
set_halfedge(f, h, get<1>(w).get());
}
template <class Graph, class Visitor>
void
set_halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
, typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
set_halfedge(v, h, boost::unwrap_ref(w.get<0>()));
set_halfedge(v, h, boost::unwrap_ref(w.get<1>()));
set_halfedge(v, h, get<0>(w).get());
set_halfedge(v, h, get<1>(w).get());
}
//
@ -521,31 +518,31 @@ boost::reference_wrapper<Graph> >& w)
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::edge_descriptor
edge(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
edge(h, boost::unwrap_ref(w.get<0>()));
return edge(h, boost::unwrap_ref(w.get<1>()));
edge(h, get<0>(w).get());
return edge(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
halfedge(typename boost::graph_traits< Graph >::edge_descriptor e
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
halfedge(e, boost::unwrap_ref(w.get<0>()));
return halfedge(e, boost::unwrap_ref(w.get<1>()));
halfedge(e, get<0>(w).get());
return halfedge(e, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
halfedge(typename boost::graph_traits< Graph >::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
halfedge(v, boost::unwrap_ref(w.get<0>()));
return halfedge(v, boost::unwrap_ref(w.get<1>()));
halfedge(v, get<0>(w).get());
return halfedge(v, get<1>(w).get());
}
template <class Graph, class Visitor>
@ -553,58 +550,58 @@ std::pair< typename boost::graph_traits< Graph >::halfedge_descriptor
, bool>
halfedge(typename boost::graph_traits< Graph >::vertex_descriptor u
, typename boost::graph_traits< Graph >::vertex_descriptor v
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
halfedge(u, v, boost::unwrap_ref(w.get<0>()));
return halfedge(u, v, boost::unwrap_ref(w.get<1>()));
halfedge(u, v, get<0>(w).get());
return halfedge(u, v, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
opposite(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
opposite(h, boost::unwrap_ref(w.get<0>()));
return opposite(h, boost::unwrap_ref(w.get<1>()));
opposite(h, get<0>(w).get());
return opposite(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
source(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
source(h, boost::unwrap_ref(w.get<0>()));
return source(h, boost::unwrap_ref(w.get<1>()));
source(h, get<0>(w).get());
return source(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::vertex_descriptor
target(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
target(h, boost::unwrap_ref(w.get<0>()));
return target(h, boost::unwrap_ref(w.get<1>()));
target(h, get<0>(w).get());
return target(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
next(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
next(outedge, boost::unwrap_ref(w.get<0>()));
return next(outedge, boost::unwrap_ref(w.get<1>()));
next(outedge, get<0>(w).get());
return next(outedge, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
prev(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
prev(outedge, boost::unwrap_ref(w.get<0>()));
return prev(outedge, boost::unwrap_ref(w.get<1>()));
prev(outedge, get<0>(w).get());
return prev(outedge, get<1>(w).get());
}
//
@ -612,73 +609,73 @@ prev(typename boost::graph_traits< Graph >::halfedge_descriptor outedge
//
template <class Graph, class Visitor>
CGAL::Iterator_range<typename boost::graph_traits< Graph >::halfedge_iterator>
halfedges(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
halfedges(const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
halfedges(boost::unwrap_ref(w.get<0>()));
return halfedges(boost::unwrap_ref(w.get<1>()));
halfedges(get<0>(w).get());
return halfedges(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedges_size_type
num_halfedges(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
num_halfedges(const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
num_halfedges(boost::unwrap_ref(w.get<0>()));
return num_halfedges(boost::unwrap_ref(w.get<1>()));
num_halfedges(get<0>(w).get());
return num_halfedges(get<1>(w).get());
}
// Graph
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::face_descriptor
face(typename boost::graph_traits< Graph >::halfedge_descriptor h
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
face(h, boost::unwrap_ref(w.get<0>()));
return face(h, boost::unwrap_ref(w.get<1>()));
face(h, get<0>(w).get());
return face(h, get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits< Graph >::halfedge_descriptor
halfedge(typename boost::graph_traits< Graph >::face_descriptor f
, const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
, const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
halfedge(f, boost::unwrap_ref(w.get<0>()));
return halfedge(f, boost::unwrap_ref(w.get<1>()));
halfedge(f, get<0>(w).get());
return halfedge(f, get<1>(w).get());
}
template <class Graph, class Visitor>
inline CGAL::Iterator_range<typename boost::graph_traits<Graph>::face_iterator >
faces(const boost::tuple<boost::reference_wrapper<Visitor>, boost::reference_wrapper<Graph> >& w)
faces(const boost::tuple<std::reference_wrapper<Visitor>, std::reference_wrapper<Graph> >& w)
{
faces(boost::unwrap_ref(w.get<0>()));
return faces(boost::unwrap_ref(w.get<1>()));
faces(get<0>(w).get());
return faces(get<1>(w).get());
}
template <class Graph, class Visitor>
typename boost::graph_traits<Graph>::faces_size_type
num_faces(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
num_faces(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
num_faces(boost::unwrap_ref(w.get<0>()));
return num_faces(boost::unwrap_ref(w.get<1>()));
num_faces(get<0>(w).get());
return num_faces(get<1>(w).get());
}
template <class Graph, class Visitor>
bool is_valid(const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w
bool is_valid(const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w
, bool verbose = false)
{
is_valid(boost::unwrap_ref(w.get<0>()), verbose);
return is_valid(boost::unwrap_ref(w.get<1>()), verbose);
is_valid(get<0>(w).get(), verbose);
return is_valid(get<1>(w).get(), verbose);
}
template <class Graph, class PropertyTag, class Visitor>
typename boost::property_map< Graph, PropertyTag >::type
get(PropertyTag ptag,
const boost::tuple<boost::reference_wrapper<Visitor>,
boost::reference_wrapper<Graph> >& w)
const boost::tuple<std::reference_wrapper<Visitor>,
std::reference_wrapper<Graph> >& w)
{
get(ptag, boost::unwrap_ref(w.get<0>()));
return get(ptag, boost::unwrap_ref(w.get<1>()));
get(ptag, get<0>(w).get());
return get(ptag, get<1>(w).get());
}
}//end namespace CGAL

24
BGL/test/BGL/test_Euler_operations.cpp
View File

@ -270,8 +270,8 @@ join_vertex_interior_test()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m)) == 3);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m)) == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m).size() == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m).size() == 3);
assert(degree(f.x, f.m) == 4);
assert(CGAL::is_valid_polygon_mesh(f.m));
}
@ -295,8 +295,8 @@ join_vertex_exterior_test()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m)) == 4);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m)) == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m).size() == 4);
assert(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m).size() == 3);
assert(degree(f.y, f.m) == 3);
assert(CGAL::is_valid_polygon_mesh(f.m));
}
@ -314,8 +314,8 @@ join_vertex_exterior_test()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m)) == 4);
assert(boost::distance(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m)) == 3);
assert(CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m).size() == 4);
assert(CGAL::halfedges_around_face(halfedge(f.f2, f.m), f.m).size() == 3);
assert(CGAL::is_valid_polygon_mesh(f.m));
assert(degree(f.w, f.m) == 3);
@ -344,8 +344,8 @@ split_vertex()
assert(CGAL::is_valid_polygon_mesh(f.m));
assert(CGAL::internal::exact_num_vertices(f.m) == 7);
assert(CGAL::internal::exact_num_edges(f.m) == 8);
assert(boost::distance(CGAL::halfedges_around_face(h1, f.m)) == 5);
assert(boost::distance(CGAL::halfedges_around_face(h2, f.m)) == 7);
assert(CGAL::halfedges_around_face(h1, f.m).size() == 5);
assert(CGAL::halfedges_around_face(h2, f.m).size() == 7);
}
template <typename T>
@ -371,8 +371,8 @@ split_join_vertex_inverse()
assert(CGAL::internal::exact_num_faces(f.m) == 2);
assert(CGAL::internal::exact_num_edges(f.m) == 6);
assert(CGAL::internal::exact_num_halfedges(f.m) == 12);
assert(boost::distance(CGAL::halfedges_around_face(h1, f.m)) == 3);
assert(boost::distance(CGAL::halfedges_around_face(h2, f.m)) == 3);
assert(CGAL::halfedges_around_face(h1, f.m).size() == 3);
assert(CGAL::halfedges_around_face(h2, f.m).size() == 3);
}
@ -476,8 +476,8 @@ test_swap_edges()
{
Graph g;
CGAL::make_tetrahedron(pt,pt,pt,pt,g);
halfedge_descriptor h1 = *std::next(boost::begin(halfedges(g)), i);
halfedge_descriptor h2 = *std::next(boost::begin(halfedges(g)), j);
halfedge_descriptor h1 = *std::next(std::begin(halfedges(g)), i);
halfedge_descriptor h2 = *std::next(std::begin(halfedges(g)), j);
CGAL::internal::swap_edges(h1, h2, g);
assert(CGAL::is_valid_polygon_mesh(g));
}

2
BGL/test/BGL/test_Face_filtered_graph.cpp
View File

@ -37,7 +37,7 @@ void test_halfedge_around_vertex_iterator(const Graph& g)
assert(target(*havit, fg) == *vit);
// check if we are really moving clockwise
halfedge_around_target_iterator step = boost::next(havit);
halfedge_around_target_iterator step = std::next(havit);
if(step != havend) {
halfedge_descriptor stepd = *step;
assert(stepd == opposite(next(*havit, fg), fg));

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

@ -68,9 +68,9 @@ void test_uniqueness(const Graph&,
#endif
typename boost::range_iterator<ForwardRange>::type
begin = boost::begin(range),
begin2 = boost::begin(range),
end = boost::end(range);
begin = std::begin(range),
begin2 = std::begin(range),
end = std::end(range);
typedef std::unordered_set<typename IndexPropertyMap::value_type> id_map;
typedef std::pair<typename id_map::iterator, bool> resultp;

2
BGL/test/BGL/test_graph_traits.cpp
View File

@ -34,7 +34,7 @@ void test_halfedge_around_vertex_iterator(const Graph& g)
assert(target(*havit, g) == *vit);
// check if we are really moving clockwise
halfedge_around_target_iterator step = boost::next(havit);
halfedge_around_target_iterator step = std::next(havit);
if(step != havend) {
halfedge_descriptor stepd = *step;
assert(stepd == opposite(next(*havit, g), g));

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

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

4
CGAL_ImageIO/include/CGAL/ImageIO/bmptypes.h
View File

@ -39,10 +39,10 @@
typedef char CGAL_INT8;
typedef short CGAL_INT16;
typedef boost::int32_t CGAL_INT32;
typedef std::int32_t CGAL_INT32;
typedef unsigned char CGAL_UINT8;
typedef unsigned short CGAL_UINT16;
typedef boost::uint32_t CGAL_UINT32;
typedef std::uint32_t CGAL_UINT32;
/*****************************************************************************
*

10
CGAL_ImageIO/include/CGAL/Image_3_vtk_interface.h
View File

@ -55,31 +55,31 @@ struct VTK_type_generator<char> {
};
template <>
struct VTK_type_generator<boost::uint8_t> {
struct VTK_type_generator<std::uint8_t> {
static const int type = VTK_UNSIGNED_CHAR;
typedef vtkUnsignedCharArray ArrayType;
};
template <>
struct VTK_type_generator<boost::int16_t> {
struct VTK_type_generator<std::int16_t> {
static const int type = VTK_SHORT;
typedef vtkShortArray ArrayType;
};
template <>
struct VTK_type_generator<boost::uint16_t> {
struct VTK_type_generator<std::uint16_t> {
static const int type = VTK_UNSIGNED_SHORT;
typedef vtkUnsignedShortArray ArrayType;
};
template <>
struct VTK_type_generator<boost::int32_t> {
struct VTK_type_generator<std::int32_t> {
static const int type = VTK_INT;
typedef vtkIntArray ArrayType;
};
template <>
struct VTK_type_generator<boost::uint32_t> {
struct VTK_type_generator<std::uint32_t> {
static const int type = VTK_UNSIGNED_INT;
typedef vtkUnsignedIntArray ArrayType;
};

7
CGAL_ImageIO/include/CGAL/SEP_header.h
View File

@ -20,7 +20,6 @@
#include <boost/tuple/tuple.hpp>
#include <boost/fusion/adapted/boost_tuple.hpp>
#include <boost/array.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/phoenix/operator.hpp>
@ -106,9 +105,9 @@ namespace CGAL {
class SEP_header {
boost::array<std::size_t, 3> _n;
boost::array<double, 3> _d;
boost::array<double, 3> _o;
std::array<std::size_t, 3> _n;
std::array<double, 3> _d;
std::array<double, 3> _o;
SEP_header_aux::String_dict _string_dict;

4
CGAL_ipelets/demo/CGAL_ipelets/pca.cpp
View File

@ -67,8 +67,8 @@ void pcaIpelet::protected_run(int fn)
for (std::list<Polygon_2>::iterator it=poly_list.begin();it!=poly_list.end();++it)
if (it->size()==3){
tri_list.push_back(Kernel::Triangle_2(*(it->vertices_begin()),
*boost::next(it->vertices_begin()),
*boost::next(it->vertices_begin(),2)
*std::next(it->vertices_begin()),
*std::next(it->vertices_begin(),2)
));
}
else{

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

@ -317,10 +317,10 @@ public:
IpeSegmentSubPath*
create_polyline(const iterator first, const iterator last,bool setclose=false) const
{
if (boost::next(first)!=last){
if (std::next(first)!=last){
IpeSegmentSubPath* SSP_ipe = new IpeSegmentSubPath();
IpeVector Prev_pt=IpeVector(CGAL::to_double(first->x()),CGAL::to_double(first->y())) ;
for (iterator it = boost::next(first);it!=last;++it){
for (iterator it = std::next(first);it!=last;++it){
IpeVector Cur_pt=IpeVector(CGAL::to_double(it->x()),CGAL::to_double(it->y()));
SSP_ipe -> AppendSegment(Prev_pt,Cur_pt);
Prev_pt=Cur_pt;

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

@ -329,10 +329,10 @@ public:
ipe::Curve*
create_polyline(const iterator first, const iterator last,bool setclose=false) const
{
if (boost::next(first)!=last){
if (std::next(first)!=last){
ipe::Curve* SSP_ipe = new ipe::Curve();
ipe::Vector Prev_pt=ipe::Vector(CGAL::to_double(first->x()),CGAL::to_double(first->y())) ;
for (iterator it = boost::next(first);it!=last;++it){
for (iterator it = std::next(first);it!=last;++it){
ipe::Vector Cur_pt=ipe::Vector(CGAL::to_double(it->x()),CGAL::to_double(it->y()));
SSP_ipe -> appendSegment(Prev_pt,Cur_pt);
Prev_pt=Cur_pt;

2
Circular_kernel_2/benchmark/DxfArrayBenchmarks/benchmark.h
View File

@ -267,7 +267,7 @@ private:
try{
this->start();
insert(_pm,ac.begin(),ac.end(),boost::false_type());
insert(_pm,ac.begin(),ac.end(),std::false_type());
this->stop();
}
catch (...) {

2
Circular_kernel_2/benchmark/arrangement_traits/benchmark.h
View File

@ -214,7 +214,7 @@ class Bench
try{
this->start();
insert(_pm,ac.begin(),ac.end(),boost::false_type());
insert(_pm,ac.begin(),ac.end(),std::false_type());
this->stop();
}

2
Circular_kernel_2/benchmark/benchmark.h
View File

@ -219,7 +219,7 @@ private:
Point_location _pl(_pm);
try{
this->start();
insert(_pm,ac.begin(),ac.end(),boost::false_type());
insert(_pm,ac.begin(),ac.end(),std::false_type());
this->stop();
} catch (std::exception &e) {
this->fail();

4
Circular_kernel_2/benchmark/benchmark_CK2.cpp
View File

@ -87,7 +87,7 @@ void do_main(const char *s) {
struct rusage before, after;
struct timeval utime, stime;
getrusage(RUSAGE_SELF,&before);
insert(_pm,ac.begin(),ac.end(),boost::false_type());
insert(_pm,ac.begin(),ac.end(),std::false_type());
getrusage(RUSAGE_SELF,&after);
timersub(&(after.ru_utime),&(before.ru_utime),&utime);
timersub(&(after.ru_stime),&(before.ru_stime),&stime);
@ -177,7 +177,7 @@ void do_main(int k) {
struct rusage before, after;
struct timeval utime, stime;
getrusage(RUSAGE_SELF,&before);
insert(_pm,ac.begin(),ac.end(),boost::false_type());
insert(_pm,ac.begin(),ac.end(),std::false_type());
getrusage(RUSAGE_SELF,&after);
timersub(&(after.ru_utime),&(before.ru_utime),&utime);
timersub(&(after.ru_stime),&(before.ru_stime),&stime);

2
Circular_kernel_2/benchmark/incremental_insertion/benchmark.h
View File

@ -217,7 +217,7 @@ class Bench
this->start();
for (typename ArcContainer::const_iterator it=ac.begin();
it != ac.end(); ++it) {
insert(_pm,*it,_pl,boost::false_type());
insert(_pm,*it,_pl,std::false_type());
};
this->stop();
}

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

@ -27,8 +27,6 @@
#include <functional>
#include <iterator>
#include <boost/type_traits/is_convertible.hpp>
// These are name redefinitions for backwards compatibility
// with the pre iterator-traits style adaptors.
@ -193,45 +191,45 @@ template <class C> inline
void Assert_circulator( const C &) {
typedef typename Circulator_traits<C>::category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, Circulator_tag>::value);
static_assert(std::is_convertible<category, Circulator_tag>::value);
}
template <class I> inline
void Assert_iterator( const I &) {
typedef typename Circulator_traits<I>::category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, Iterator_tag>::value);
static_assert(std::is_convertible<category, Iterator_tag>::value);
}
template <class I> inline
void Assert_input_category( const I &/*i*/) {
typedef typename std::iterator_traits<I>::iterator_category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, std::input_iterator_tag>::value);
static_assert(std::is_convertible<category, std::input_iterator_tag>::value);
}
template <class I> inline
void Assert_output_category( const I &/*i*/) {
typedef typename std::iterator_traits<I>::iterator_category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, std::output_iterator_tag>::value);
static_assert(std::is_convertible<category, std::output_iterator_tag>::value);
}
template <class IC> inline
void Assert_forward_category( const IC &/*ic*/) {
typedef typename std::iterator_traits<IC>::iterator_category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, std::forward_iterator_tag>::value);
static_assert(std::is_convertible<category, std::forward_iterator_tag>::value);
}
template <class IC> inline
void Assert_bidirectional_category( const IC &/*ic*/) {
typedef typename std::iterator_traits<IC>::iterator_category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, std::bidirectional_iterator_tag>::value);
static_assert(std::is_convertible<category, std::bidirectional_iterator_tag>::value);
}
template <class IC> inline
void Assert_random_access_category( const IC &/*ic*/) {
typedef typename std::iterator_traits<IC>::iterator_category category;
CGAL_USE_TYPE(category);
static_assert(boost::is_convertible<category, std::random_access_iterator_tag>::value);
static_assert(std::is_convertible<category, std::random_access_iterator_tag>::value);
}
// The assert at-least-category functions use the following
// functions to resolve properly. Note the proper order of the

2
Combinatorial_map/doc/Combinatorial_map/Combinatorial_map.txt
View File

@ -498,7 +498,7 @@ Step 2 defines the onsplit and onmerge dynamic functors. We can see here that wi
The next operations will call these functors when 2-cells are split or merged. The \link CombinatorialMap::sew `sew<3>`\endlink operation calls 1 onmerge as two faces are identified; the \link GenericMap::insert_cell_0_in_cell_2 `insert_cell_0_in_cell_2`\endlink operation calls 3 onsplit as one face is split in 4.
Lastly we remove the dynamic onmerge functor (step 7). This is done by initializing the fonctor to a default boost::function. After this initialization, no dynamic merge functor is called when two faces are merged.
Lastly we remove the dynamic onmerge functor (step 7). This is done by initializing the functor to a default boost::function. After this initialization, no dynamic merge functor is called when two faces are merged.
\cgalExample{Combinatorial_map/map_3_dynamic_onmerge.cpp}

3
Convex_hull_3/include/CGAL/Convex_hull_3/dual/halfspace_intersection_3.h
View File

@ -30,7 +30,6 @@
#include <CGAL/Number_types/internal/Exact_type_selector.h>
#include <unordered_map>
#include <boost/type_traits/is_floating_point.hpp>
#include <deque>
namespace CGAL
@ -261,7 +260,7 @@ namespace CGAL
// The check is done only if the number type is not float or double because in that
// case we know the construction of dual points is not exact
CGAL_assertion_msg(
boost::is_floating_point<typename K::FT>::value ||
std::is_floating_point<typename K::FT>::value ||
Convex_hull_3::internal::point_inside_convex_polyhedron(P, *origin),
"halfspace_intersection_3: origin not in the polyhedron"
);

2
Convex_hull_3/include/CGAL/Convex_hull_traits_3.h
View File

@ -151,7 +151,7 @@ struct GT3_for_CH3 {
template <class R_, class Polyhedron = Default,
class Has_filtered_predicates_tag = Boolean_tag
<
boost::is_floating_point<typename R_::FT>::type::value &&
std::is_floating_point<typename R_::FT>::type::value &&
R_::Has_filtered_predicates_tag::value
> >
class Convex_hull_traits_3

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

@ -42,8 +42,6 @@
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/type_traits/is_iterator.h>
#include <boost/next_prior.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/graph/graph_traits.hpp>
@ -149,7 +147,7 @@ namespace internal {
//struct to select the default traits class for computing convex hull
template< class Point_3,
class PolygonMesh = Default,
class Is_floating_point=typename boost::is_floating_point<typename Kernel_traits<Point_3>::Kernel::FT>::type,
class Is_floating_point=typename std::is_floating_point<typename Kernel_traits<Point_3>::Kernel::FT>::type,
class Has_filtered_predicates_tag=typename Kernel_traits<Point_3>::Kernel::Has_filtered_predicates_tag >
struct Default_traits_for_Chull_3{
typedef typename Kernel_traits<Point_3>::Kernel type;
@ -157,7 +155,7 @@ struct Default_traits_for_Chull_3{
//FT is a floating point type and Kernel is a filtered kernel
template <class Point_3, class PolygonMesh>
struct Default_traits_for_Chull_3<Point_3, PolygonMesh, boost::true_type,Tag_true>{
struct Default_traits_for_Chull_3<Point_3, PolygonMesh, std::true_type,Tag_true>{
typedef Convex_hull_traits_3< typename Kernel_traits<Point_3>::Kernel, PolygonMesh, Tag_true > type;
};
@ -174,7 +172,7 @@ struct Default_polyhedron_for_Chull_3<Convex_hull_traits_3<K, P, Tag> >{
template <class T>
struct Is_cartesian_kernel
{
typedef boost::false_type type;
typedef std::false_type type;
};
template <class Kernel, class PolygonMesh>
@ -235,7 +233,7 @@ public:
//interval arithmetic (the protector must be created before using this predicate)
//and in case of failure, exact arithmetic is used.
template <class Kernel, class P>
class Is_on_positive_side_of_plane_3<Convex_hull_traits_3<Kernel, P, Tag_true>, boost::true_type >{
class Is_on_positive_side_of_plane_3<Convex_hull_traits_3<Kernel, P, Tag_true>, std::true_type >{
typedef Simple_cartesian<CGAL::internal::Exact_field_selector<double>::Type> Exact_K;
typedef Simple_cartesian<Interval_nt_advanced > Approx_K;
typedef Convex_hull_traits_3<Kernel, P, Tag_true> Traits;
@ -613,7 +611,7 @@ partition_outside_sets(const std::list<Face_handle>& new_facets,
}
if(! point_list.empty()){
pending_facets.push_back(f);
f->it = boost::prior(pending_facets.end());
f->it = std::prev(pending_facets.end());
} else {
f->it = pending_facets.end();
}
@ -748,7 +746,7 @@ void non_coplanar_quickhull_3(std::list<typename Traits::Point_3>& points,
for(Face_iterator fit = tds.faces_begin(); fit != tds.faces_end(); ++fit){
if (! fit->points.empty()){
pending_facets.push_back(fit);
fit->it = boost::prior(pending_facets.end());
fit->it = std::prev(pending_facets.end());
} else {
fit->it = pending_facets.end();
}

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

@ -29,6 +29,6 @@ int main()
static_assert(std::is_same<SCR,Default_traits_for_Chull_3<SCR::Point_3>::type>::value);
static_assert(std::is_same<EPEC,Default_traits_for_Chull_3<EPEC::Point_3>::type>::value);
static_assert(std::is_same<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>,Default_traits_for_Chull_3<EPIC::Point_3>::type>::value);
static_assert(std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, boost::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value);
static_assert(std::is_same<Is_on_positive_side_of_plane_3<CGAL::Convex_hull_traits_3<EPIC, CGAL::Default, CGAL::Tag_true>, std::true_type >::Protector,CGAL::Protect_FPU_rounding<true> >::value);
return 0;
}

4
Envelope_3/include/CGAL/Envelope_3/Envelope_diagram_on_surface_2.h
View File

@ -129,14 +129,14 @@ public:
template <class GeomTraits_, class TopTraits_>
class is_arrangement_2<
Envelope_diagram_on_surface_2<GeomTraits_, TopTraits_>
> : public boost::true_type
> : public std::true_type
{};
// specialization
template <class GeomTraits_, class DCEL_>
class is_arrangement_2<
Envelope_diagram_2<GeomTraits_, DCEL_>
> : public boost::true_type
> : public std::true_type
{};

8
Filtered_kernel/include/CGAL/Lazy.h
View File

@ -2088,10 +2088,10 @@ struct Lazy_construction<LK, AC, EC, E2A_, true> {
typedef typename LK::Approximate_kernel AK;
typedef typename LK::Exact_kernel EK;
typedef typename boost::remove_cv<
typename boost::remove_reference < typename AC::result_type >::type >::type AT;
typedef typename boost::remove_cv<
typename boost::remove_reference < typename EC::result_type >::type >::type ET;
typedef std::remove_cv_t<
std::remove_reference_t < typename AC::result_type > > AT;
typedef std::remove_cv_t<
std::remove_reference_t < typename EC::result_type > > ET;
typedef typename Default::Get<E2A_, typename LK::E2A>::type E2A;

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

@ -29,8 +29,6 @@
#include <boost/none.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <CGAL/Lazy_exact_nt.h>
#if defined(BOOST_MSVC)
@ -64,8 +62,8 @@ public:
template<typename T>
struct Has_result_type
: boost::integral_constant< bool,
Has_result_type_helper< typename boost::remove_cv<T>::type>::value>
: std::integral_constant< bool,
Has_result_type_helper< std::remove_cv_t<T>>::value>
{};
template <typename T>
@ -192,10 +190,10 @@ private:
template <typename Construction, typename Dummy = boost::none_t>
struct Lazy_wrapper_traits :
boost::mpl::eval_if< internal::Has_result_type<Construction>,
boost::mpl::eval_if< std::is_same< typename boost::remove_cv<
typename boost::remove_reference<
boost::mpl::eval_if< std::is_same< std::remove_cv_t<
std::remove_reference_t<
typename internal::Lazy_result_type<Construction>::type
>::type >::type,
> >,
typename Approximate_kernel::FT>,
boost::mpl::int_<NT>,
boost::mpl::eval_if< std::is_same< typename internal::Lazy_result_type<Construction>::type,

2
Generalized_map/doc/Generalized_map/Generalized_map.txt
View File

@ -520,7 +520,7 @@ Step 2 defines the onsplit and onmerge dynamic functors. We can see here that wi
The next operations will call these functors when 2-cells are split or merged. The \link GeneralizedMap::sew `sew<3>`\endlink operation calls 1 onmerge as two faces are identified; the \link GenericMap::insert_cell_0_in_cell_2 `insert_cell_0_in_cell_2`\endlink operation calls 3 onsplit as one face is split in 4.
Lastly we remove the dynamic onmerge functor (step 7). This is done by initializing the fonctor to a default boost::function. After this initialization, no dynamic merge functor is called when two faces are merged.
Lastly we remove the dynamic onmerge functor (step 7). This is done by initializing the functor to a default boost::function. After this initialization, no dynamic merge functor is called when two faces are merged.
\cgalExample{Generalized_map/gmap_3_dynamic_onmerge.cpp}

4
Generator/include/CGAL/Generator/internal/Generic_random_point_generator.h
View File

@ -118,8 +118,8 @@ struct Apply_approx_sqrt
Apply_approx_sqrt(const Functor& f) : Functor(f) { }
template <class T>
typename boost::remove_reference<
typename cpp11::result_of<Functor(const T&)>::type>::type
std::remove_reference_t<
typename cpp11::result_of<Functor(const T&)>::type>
operator()(const T& t) const
{
return approximate_sqrt( static_cast<const Functor&>(*this)(t) );

1
HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h
View File

@ -20,7 +20,6 @@
#include <boost/config.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <CGAL/boost/iterator/transform_iterator.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>

5
Homogeneous_kernel/include/CGAL/Homogeneous/PointH2.h
View File

@ -18,7 +18,6 @@
#define CGAL_HOMOGENEOUS_POINT_2_H
#include <CGAL/Origin.h>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/mpl/and.hpp>
#include <boost/mpl/logical.hpp>
@ -54,8 +53,8 @@ public:
template < typename Tx, typename Ty >
PointH2(const Tx & x, const Ty & y,
std::enable_if_t< boost::mpl::and_<boost::is_convertible<Tx, RT>,
boost::is_convertible<Ty, RT> >::value >* = 0)
std::enable_if_t< boost::mpl::and_<std::is_convertible<Tx, RT>,
std::is_convertible<Ty, RT> >::value >* = 0)
: base(x, y) {}
PointH2(const FT& x, const FT& y)

6
Homogeneous_kernel/include/CGAL/Homogeneous/PointH3.h
View File

@ -52,9 +52,9 @@ public:
template < typename Tx, typename Ty, typename Tz >
PointH3(const Tx & x, const Ty & y, const Tz & z,
std::enable_if_t< boost::mpl::and_< boost::mpl::and_< boost::is_convertible<Tx, RT>,
boost::is_convertible<Ty, RT> >,
boost::is_convertible<Tz, RT> >::value >* = 0)
std::enable_if_t< boost::mpl::and_< boost::mpl::and_< std::is_convertible<Tx, RT>,
std::is_convertible<Ty, RT> >,
std::is_convertible<Tz, RT> >::value >* = 0)
: base(x, y, z) {}
PointH3(const FT& x, const FT& y, const FT& z)

10
Homogeneous_kernel/include/CGAL/Homogeneous/VectorH2.h
View File

@ -23,8 +23,6 @@
#include <CGAL/Kernel_d/Cartesian_const_iterator_d.h>
#include <CGAL/Handle_for.h>
#include <boost/next_prior.hpp>
namespace CGAL {
template < class R_ >
@ -59,8 +57,8 @@ public:
template < typename Tx, typename Ty >
VectorH2(const Tx & x, const Ty & y,
std::enable_if_t< boost::mpl::and_<boost::is_convertible<Tx, RT>,
boost::is_convertible<Ty, RT> >::value >* = 0)
std::enable_if_t< boost::mpl::and_<std::is_convertible<Tx, RT>,
std::is_convertible<Ty, RT> >::value >* = 0)
: base(CGAL::make_array<RT>(x, y, RT(1))) {}
VectorH2(const FT& x, const FT& y)
@ -101,12 +99,12 @@ public:
Cartesian_const_iterator cartesian_begin() const
{
return make_cartesian_const_iterator_begin(CGAL::get_pointee_or_identity(base).begin(),
boost::prior(CGAL::get_pointee_or_identity(base).end()));
std::prev(CGAL::get_pointee_or_identity(base).end()));
}
Cartesian_const_iterator cartesian_end() const
{
return make_cartesian_const_iterator_end(boost::prior(CGAL::get_pointee_or_identity(base).end()));
return make_cartesian_const_iterator_end(std::prev(CGAL::get_pointee_or_identity(base).end()));
}
int dimension() const;

12
Homogeneous_kernel/include/CGAL/Homogeneous/VectorH3.h
View File

@ -21,8 +21,6 @@
#include <CGAL/array.h>
#include <CGAL/Kernel_d/Cartesian_const_iterator_d.h>
#include <boost/next_prior.hpp>
namespace CGAL {
template < class R_ >
@ -69,9 +67,9 @@ public:
template < typename Tx, typename Ty, typename Tz >
VectorH3(const Tx & x, const Ty & y, const Tz & z,
std::enable_if_t< boost::mpl::and_< boost::mpl::and_< boost::is_convertible<Tx, RT>,
boost::is_convertible<Ty, RT> >,
boost::is_convertible<Tz, RT> >::value >* = 0)
std::enable_if_t< boost::mpl::and_< boost::mpl::and_< std::is_convertible<Tx, RT>,
std::is_convertible<Ty, RT> >,
std::is_convertible<Tz, RT> >::value >* = 0)
: base(CGAL::make_array<RT>(x, y, z, RT(1))) {}
VectorH3(const FT& x, const FT& y, const FT& z)
@ -117,12 +115,12 @@ public:
Cartesian_const_iterator cartesian_begin() const
{
return make_cartesian_const_iterator_begin(get_pointee_or_identity(base).begin(),
boost::prior(get_pointee_or_identity(base).end()));
std::prev(get_pointee_or_identity(base).end()));
}
Cartesian_const_iterator cartesian_end() const
{
return make_cartesian_const_iterator_end(boost::prior(get_pointee_or_identity(base).end()));
return make_cartesian_const_iterator_end(std::prev(get_pointee_or_identity(base).end()));
}
int dimension() const { return 3; };

2
Hyperbolic_triangulation_2/include/CGAL/Hyperbolic_Delaunay_triangulation_2.h
View File

@ -431,7 +431,7 @@ public:
template < class InputIterator >
std::ptrdiff_t insert(InputIterator first, InputIterator last,
std::enable_if_t<
boost::is_base_of<Point, typename std::iterator_traits<InputIterator>::value_type>::value
std::is_base_of<Point, typename std::iterator_traits<InputIterator>::value_type>::value
>* = nullptr)
#else
template < class InputIterator >

2
Hyperbolic_triangulation_2/include/CGAL/Hyperbolic_triangulation_face_base_2.h
View File

@ -23,7 +23,7 @@ namespace CGAL {
class Hyperbolic_data
{
typedef boost::int8_t Id;
typedef std::int8_t Id;
private:
// - 2 for infinite face

4
Interpolation/include/CGAL/regular_neighbor_coordinates_2.h
View File

@ -22,8 +22,6 @@
#include <CGAL/function_objects.h>
#include <CGAL/Polygon_2_algorithms.h>
#include <boost/type_traits/is_convertible.hpp>
#include <iterator>
#include <list>
#include <map>
@ -343,7 +341,7 @@ regular_neighbor_coordinates_2(const Rt& rt,
OutputIterator out,
OutputFunctor fct,
std::enable_if_t<
!boost::is_convertible<OutputFunctor,
!std::is_convertible<OutputFunctor,
typename Rt::Face_handle>::value
>* = 0)
{

10
Intersections_3/include/CGAL/Intersections_3/internal/Triangle_3_Triangle_3_intersection.h
View File

@ -21,8 +21,6 @@
#include <CGAL/kernel_assertions.h>
#include <boost/next_prior.hpp>
#include <list>
#include <map>
#include <vector>
@ -53,8 +51,8 @@ void intersection_coplanar_triangles_cutoff(const typename Kernel::Point_3& p,
CGAL_kernel_assertion_code(int pt_added = 0;)
const typename Kernel::Point_3* prev = &(*boost::prior(inter_pts.end()));
Iterator stop = inter_pts.size() > 2 ? inter_pts.end() : boost::prior(inter_pts.end());
const typename Kernel::Point_3* prev = &(*std::prev(inter_pts.end()));
Iterator stop = inter_pts.size() > 2 ? inter_pts.end() : std::prev(inter_pts.end());
for(Iterator it=inter_pts.begin(); it!=stop; ++it)
{
const typename Kernel::Point_3& curr = *it;
@ -120,10 +118,10 @@ intersection_coplanar_triangles(const typename K::Triangle_3& t1,
return intersection_return<typename K::Intersect_3, typename K::Triangle_3, typename K::Triangle_3>(*inter_pts.begin());
case 2:
return intersection_return<typename K::Intersect_3, typename K::Triangle_3, typename K::Triangle_3>(
k.construct_segment_3_object()(*inter_pts.begin(), *boost::next(inter_pts.begin())) );
k.construct_segment_3_object()(*inter_pts.begin(), *std::next(inter_pts.begin())) );
case 3:
return intersection_return<typename K::Intersect_3, typename K::Triangle_3, typename K::Triangle_3>(
k.construct_triangle_3_object()(*inter_pts.begin(), *boost::next(inter_pts.begin()), *boost::prior(inter_pts.end())) );
k.construct_triangle_3_object()(*inter_pts.begin(), *std::next(inter_pts.begin()), *std::prev(inter_pts.end())) );
default:
return intersection_return<typename K::Intersect_3, typename K::Triangle_3, typename K::Triangle_3>(
std::vector<typename K::Point_3>(inter_pts.begin(),inter_pts.end()));

9
Kernel_23/include/CGAL/Kernel/Type_mapper.h
View File

@ -21,9 +21,6 @@
#include <vector>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/mpl/remove.hpp>
@ -111,9 +108,9 @@ struct Type_mapper_impl < typename K1::FT, K1, K2 >
template < typename T, typename K1, typename K2 >
struct Type_mapper :
internal::Type_mapper_impl< typename boost::remove_cv<
typename boost::remove_reference < T >::type
>::type, K1, K2 >
internal::Type_mapper_impl< std::remove_cv_t<
std::remove_reference_t< T >
>, K1, K2 >
{ };
} //namespace CGAL

10
Kernel_23/test/Kernel_23/include/CGAL/_test_cls_point_2.h
View File

@ -26,8 +26,6 @@
#include <CGAL/Weighted_point_2.h>
#include <CGAL/use.h>
#include <boost/type_traits/is_convertible.hpp>
#include <cassert>
#include <iostream>
@ -60,10 +58,10 @@ _test_cls_point_2(const R& )
CGAL::Weighted_point_2<R> wp(p1);
CGAL::Point_2<R> p7(wp);
static_assert(!(boost::is_convertible<CGAL::Weighted_point_2<R>,
CGAL::Point_2<R> >::value));
static_assert(!(boost::is_convertible<CGAL::Point_2<R>,
CGAL::Weighted_point_2<R> >::value));
static_assert(!std::is_convertible<CGAL::Weighted_point_2<R>,
CGAL::Point_2<R> >::value);
static_assert(!std::is_convertible<CGAL::Point_2<R>,
CGAL::Weighted_point_2<R> >::value);
std::cout << '.';

8
Kernel_23/test/Kernel_23/include/CGAL/_test_cls_point_3.h
View File

@ -58,10 +58,10 @@ _test_cls_point_3(const R& )
CGAL::Weighted_point_3<R> wp(p1);
CGAL::Point_3<R> p7(wp);
static_assert(!(boost::is_convertible<CGAL::Weighted_point_3<R>,
CGAL::Point_3<R> >::value));
static_assert(!(boost::is_convertible<CGAL::Point_3<R>,
CGAL::Weighted_point_3<R> >::value));
static_assert(!std::is_convertible<CGAL::Weighted_point_3<R>,
CGAL::Point_3<R> >::value);
static_assert(!std::is_convertible<CGAL::Point_3<R>,
CGAL::Weighted_point_3<R> >::value);
std::cout << '.';

4
Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp
View File

@ -42,7 +42,7 @@ bool read_off_ascii(Surface_mesh& mesh,
Vec2f t;
Surface_mesh::Vertex v;
typename CGAL::GetVertexPointMap<Surface_mesh, NamedParameters>::const_type
vpm = choose_parameter(get_parameter(np, CGAL::boost::internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
@ -164,7 +164,7 @@ bool read_off_binary(Surface_mesh& mesh,
if (has_normals) normals = mesh.vertex_property<Normal>("v:normal");
if (has_texcoords) texcoords = mesh.vertex_property<Texture_coordinate>("v:texcoord");
typename CGAL::GetVertexPointMap<Surface_mesh, NamedParameters>::const_type
vpm = choose_parameter(get_parameter(np, CGAL::boost::internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));

6
Mesh_2/include/CGAL/Mesh_2/Mesh_global_optimizer_2.h
View File

@ -33,8 +33,6 @@
#include <algorithm>
#include <iterator>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <boost/format.hpp>
#include <boost/math/constants/constants.hpp>
@ -329,7 +327,7 @@ private:
typename FT_list::iterator pos = std::find_if(
big_moves_.begin(),
big_moves_.end(),
boost::lambda::_1 < new_sq_move );
[&](const FT& v) { return v< new_sq_move; } );
big_moves_.insert(pos, new_sq_move);
}
@ -343,8 +341,6 @@ private:
bool check_convergence() const
{
namespace bl = boost::lambda;
FT sum(0);
for(typename FT_list::const_iterator it = big_moves_.begin();
it != big_moves_.end();

4
Mesh_3/benchmark/Mesh_3/StdAfx.h
View File

@ -137,11 +137,7 @@
#include <boost/type_traits.hpp>
#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_reference.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility.hpp>
#include <boost/variant.hpp>
#include <boost/version.hpp>

6
Mesh_3/include/CGAL/Implicit_to_labeling_function_wrapper.h
View File

@ -32,8 +32,6 @@
#endif
#include <boost/dynamic_bitset.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/mpl/if.hpp>
@ -156,8 +154,8 @@ class Implicit_multi_domain_to_labeling_function_wrapper
class Implicit_function_traits<RT_ (*)(Point_)>
{
public:
typedef typename boost::remove_reference<
typename boost::remove_cv< Point_ >::type>::type Point;
typedef std::remove_reference_t<
std::remove_cv_t< Point_ >> Point;
};
public:

27
Mesh_3/include/CGAL/Mesh_3/C3T3_helpers.h
View File

@ -36,12 +36,9 @@
#include <CGAL/Mesh_3/Profiling_tools.h>
#endif
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
#include <boost/optional.hpp>
#include <CGAL/boost/iterator/transform_iterator.hpp>
#include <boost/iterator/function_output_iterator.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/unordered_set.hpp>
#ifdef CGAL_LINKED_WITH_TBB
@ -1931,7 +1928,7 @@ private:
{
# ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tbb::parallel_for_each(
outdated_cells.begin(), outdated_cells.end(),
@ -1959,7 +1956,7 @@ private:
{
# ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tbb::parallel_for
(
@ -2129,8 +2126,8 @@ private:
template <typename CellRange>
void reset_sliver_cache(CellRange& cell_range) const
{
reset_sliver_cache(boost::begin(cell_range),
boost::end(cell_range));
reset_sliver_cache(std::begin(cell_range),
std::end(cell_range));
}
template <typename CellForwardIterator>
@ -2146,8 +2143,8 @@ private:
template <typename CellRange>
void reset_circumcenter_cache(CellRange& cell_range) const
{
reset_circumcenter_cache(boost::begin(cell_range),
boost::end(cell_range));
reset_circumcenter_cache(std::begin(cell_range),
std::end(cell_range));
}
template <typename CellForwardIterator>
@ -2696,7 +2693,7 @@ rebuild_restricted_delaunay(OutdatedCells& outdated_cells,
# ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
std::vector<Cell_handle> outdated_cells_vector;
outdated_cells_vector.reserve(outdated_cells.size());
@ -2820,7 +2817,7 @@ rebuild_restricted_delaunay(ForwardIterator first_cell,
// Note: ~58% of rebuild_restricted_delaunay time
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tbb::parallel_for_each(first_cell, last_cell,
Update_cell<C3T3, Update_c3t3>(c3t3_, updater));
@ -2842,7 +2839,7 @@ rebuild_restricted_delaunay(ForwardIterator first_cell,
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tbb::parallel_for_each(
facets.begin(), facets.end(),
@ -2954,7 +2951,7 @@ move_point(const Vertex_handle& old_vertex,
# ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tr_.incident_cells_threadsafe(old_vertex, std::back_inserter(incident_cells_));
}
@ -3436,7 +3433,7 @@ get_least_square_surface_plane(const Vertex_handle& v,
Facet_vector facets;
# ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tr_.finite_incident_facets_threadsafe(v, std::back_inserter(facets));
}
@ -3845,7 +3842,7 @@ get_conflict_zone_topo_change(const Vertex_handle& old_vertex,
# ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tr_.incident_cells_threadsafe(old_vertex, removal_conflict_cells);
}

12
Mesh_3/include/CGAL/Mesh_3/Mesh_global_optimizer.h
View File

@ -44,8 +44,6 @@
#include <list>
#include <limits>
#include <boost/type_traits/is_convertible.hpp>
#ifdef CGAL_LINKED_WITH_TBB
# include <atomic>
# include <mutex>
@ -802,7 +800,7 @@ compute_moves(Moving_vertices_set& moving_vertices)
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tbb::concurrent_vector<Vertex_handle> vertices_not_moving_any_more;
@ -888,7 +886,7 @@ compute_move(const Vertex_handle& v)
incident_cells.reserve(64);
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tr_.incident_cells_threadsafe(v, std::back_inserter(incident_cells));
}
@ -947,7 +945,7 @@ update_mesh(const Moves_vector& moves,
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
// Apply moves in triangulation
tbb::parallel_for(tbb::blocked_range<size_t>(0, moves.size()),
@ -1040,7 +1038,7 @@ fill_sizing_field()
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
typedef tbb::enumerable_thread_specific<
std::vector< std::pair<Bare_point, FT> > > Local_list;
@ -1111,7 +1109,7 @@ average_circumradius_length(const Vertex_handle& v) const
incident_cells.reserve(64);
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
tr_.incident_cells_threadsafe(v, std::back_inserter(incident_cells));
}

7
Mesh_3/include/CGAL/Mesh_3/Mesher_3.h
View File

@ -63,7 +63,6 @@
#endif
#include <boost/format.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <string>
#include <atomic>
@ -653,7 +652,7 @@ initialize()
defined(CGAL_SEQUENTIAL_MESH_3_ADD_OUTSIDE_POINTS_ON_A_FAR_SPHERE)
#ifndef CGAL_SEQUENTIAL_MESH_3_ADD_OUTSIDE_POINTS_ON_A_FAR_SPHERE
if(boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if(std::is_convertible<Concurrency_tag, Parallel_tag>::value)
#endif // If that macro is defined, then estimated_bbox must be initialized
{
Base::set_bbox(r_oracle_.bbox());
@ -666,7 +665,7 @@ initialize()
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
// we're not multi-thread, yet
r_c3t3_.triangulation().set_lock_data_structure(0);
@ -861,7 +860,7 @@ Mesher_3<C3T3,MC,MD>::
status() const
{
#ifdef CGAL_LINKED_WITH_TBB
if(boost::is_convertible<Concurrency_tag, Parallel_tag>::value) {
if(std::is_convertible<Concurrency_tag, Parallel_tag>::value) {
return Mesher_status(
# if CGAL_CONCURRENT_COMPACT_CONTAINER_APPROXIMATE_SIZE
approximate_number_of_vertices(Concurrency_tag()),

2
Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h
View File

@ -2104,7 +2104,7 @@ repopulate_edges_around_corner(const Vertex_handle& v, ErasedVeOutIt out)
// `check_and_repopulate_edges()::vertices` before it is passed itself
// to `repopulate_edges_around_corner()`.
if(c3t3_.is_in_complex(to_repopulate.back()))
std::copy(to_repopulate.begin(), boost::prior(to_repopulate.end()), out);
std::copy(to_repopulate.begin(), std::prev(to_repopulate.end()), out);
else
std::copy(to_repopulate.begin(), to_repopulate.end(), out);

5
Mesh_3/include/CGAL/Mesh_3/Refine_cells_3.h
View File

@ -38,7 +38,6 @@
#include <boost/format.hpp>
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <sstream>
#include <atomic>
@ -175,7 +174,7 @@ template<class Tr,
#ifdef CGAL_LINKED_WITH_TBB
class Container_ = typename boost::mpl::if_c // (parallel/sequential?)
<
boost::is_convertible<Concurrency_tag, Parallel_tag>::value,
std::is_convertible<Concurrency_tag, Parallel_tag>::value,
// Parallel
# ifdef CGAL_MESH_3_USE_LAZY_UNSORTED_REFINEMENT_QUEUE
@ -663,7 +662,7 @@ scan_triangulation_impl()
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Ct, Parallel_tag>::value)
if (std::is_convertible<Ct, Parallel_tag>::value)
{
# if defined(CGAL_MESH_3_VERBOSE) || defined(CGAL_MESH_3_PROFILING)
std::cerr << "Scanning triangulation for bad cells (in parallel)";

5
Mesh_3/include/CGAL/Mesh_3/Refine_facets_3.h
View File

@ -48,7 +48,6 @@
#include <boost/mpl/has_xxx.hpp>
#include <boost/mpl/if.hpp>
#include <CGAL/tuple.h>
#include <boost/type_traits/is_convertible.hpp>
#include <sstream>
#include <atomic>
@ -643,7 +642,7 @@ template<class Tr,
#ifdef CGAL_LINKED_WITH_TBB
class Container_ = typename boost::mpl::if_c // (parallel/sequential?)
<
boost::is_convertible<Concurrency_tag, Parallel_tag>::value,
std::is_convertible<Concurrency_tag, Parallel_tag>::value,
// Parallel
# ifdef CGAL_MESH_3_USE_LAZY_UNSORTED_REFINEMENT_QUEUE
Meshes::Filtered_deque_container
@ -984,7 +983,7 @@ scan_triangulation_impl()
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Ct, Parallel_tag>::value)
if (std::is_convertible<Ct, Parallel_tag>::value)
{
# if defined(CGAL_MESH_3_VERBOSE) || defined(CGAL_MESH_3_PROFILING)
std::cerr << "Scanning triangulation for bad facets (in parallel) - "

18
Mesh_3/include/CGAL/Mesh_3/Refine_facets_manifold_base.h
View File

@ -251,7 +251,7 @@ private:
{
#ifdef CGAL_LINKED_WITH_TBB
// Sequential only
if (!boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (!std::is_convertible<Concurrency_tag, Parallel_tag>::value)
#endif // CGAL_LINKED_WITH_TBB
{
//Sequential
@ -280,7 +280,7 @@ private:
#ifdef CGAL_LINKED_WITH_TBB
// Sequential only
if (!boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (!std::is_convertible<Concurrency_tag, Parallel_tag>::value)
#endif // CGAL_LINKED_WITH_TBB
{
if(m_bad_vertices_initialized) {
@ -359,7 +359,7 @@ public:
{
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->insert_bad_facet(biggest_incident_facet_in_complex(*eit),
typename Base::Quality());
@ -402,7 +402,7 @@ public:
#endif // CGAL_MESHES_DEBUG_REFINEMENT_POINTS
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->insert_bad_facet(biggest_incident_facet_in_complex(vit),
typename Base::Quality());
@ -471,7 +471,7 @@ public:
Facet get_next_element_impl() {
#ifdef CGAL_LINKED_WITH_TBB
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
return Base::get_next_element_impl();
else
#endif
@ -570,7 +570,7 @@ public:
{
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->insert_bad_facet(biggest_incident_facet_in_complex(edge),
typename Base::Quality());
@ -585,7 +585,7 @@ public:
else {
#ifdef CGAL_LINKED_WITH_TBB
// Sequential only
if (!boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (!std::is_convertible<Concurrency_tag, Parallel_tag>::value)
#endif // CGAL_LINKED_WITH_TBB
{
m_bad_edges.left.erase( edge_to_edgevv(edge) ); // @TODO: pourquoi?!
@ -622,7 +622,7 @@ public:
#endif // CGAL_MESHES_DEBUG_REFINEMENT_POINTS
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->insert_bad_facet(biggest_incident_facet_in_complex(*vit),
typename Base::Quality());
@ -645,7 +645,7 @@ public:
#endif // CGAL_MESHES_DEBUG_REFINEMENT_POINTS
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->insert_bad_facet(biggest_incident_facet_in_complex(v),
typename Base::Quality());

3
Mesh_3/include/CGAL/Mesh_3/Sliver_perturber.h
View File

@ -59,7 +59,6 @@
#include <boost/format.hpp>
#include <CGAL/Modifiable_priority_queue.h>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/unordered_map.hpp>
@ -928,7 +927,7 @@ perturb(const FT& sliver_bound, PQueue& pqueue, Visitor& visitor) const
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->create_task_group();

5
Mesh_3/include/CGAL/Mesh_3/Slivers_exuder.h
View File

@ -39,7 +39,6 @@
#include <boost/format.hpp>
#include <boost/iterator/function_output_iterator.hpp>
#include <boost/optional.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <algorithm>
#include <iomanip> // std::setprecision
@ -623,7 +622,7 @@ private:
{
#if defined( CGAL_LINKED_WITH_TBB ) && ( !defined (BOOST_MSVC) || !defined( _DEBUG ) || !defined (CGAL_TEST_SUITE) )
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
enqueue_task<pump_vertices_on_surfaces>(
ch, this->erase_counter(ch), criterion_value);
// Sequential
@ -920,7 +919,7 @@ pump_vertices(FT sliver_criterion_limit,
#if defined( CGAL_LINKED_WITH_TBB ) && ( !defined (BOOST_MSVC) || !defined( _DEBUG ) || !defined (CGAL_TEST_SUITE) )
// Parallel
if (boost::is_convertible<Concurrency_tag, Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, Parallel_tag>::value)
{
this->create_task_group();

4
Mesh_3/include/CGAL/Mesh_3/experimental/Get_curve_index.h
View File

@ -57,14 +57,12 @@ get(Get_curve_index<Primitive>, const typename Primitive::Id id) {
}} // end namespace CGAL::Mesh_3
#include <boost/type_traits/remove_const.hpp>
namespace boost {
// specialization for using pointers as property maps
template <typename Primitive>
struct property_traits<CGAL::Mesh_3::Get_curve_index<Primitive> > {
typedef typename std::iterator_traits<typename Primitive::Id::first_type>::value_type ConstPair;
typedef typename boost::remove_const<typename ConstPair::first_type>::type value_type;
typedef std::remove_const_t<typename ConstPair::first_type> value_type;
typedef value_type& reference;
typedef typename Primitive::Id key_type;
typedef readable_property_map_tag category;

16
Mesh_3/include/CGAL/Mesh_3/polylines_to_protect.h
View File

@ -29,7 +29,7 @@
#include <CGAL/Mesh_3/internal/Graph_manipulations.h>
#include <boost/graph/adjacency_list.hpp>
#include <boost/utility.hpp> // for boost::prior
#include <boost/utility.hpp> // for std::prev
#include <boost/optional.hpp>
#include <CGAL/Search_traits_3.h>
@ -387,8 +387,8 @@ void snap_graph_vertices(Graph& graph,
{
if(poly_it->begin() != poly_it->end()) {
tree.insert(*poly_it->begin());
if(boost::next(poly_it->begin()) != poly_it->end()) {
tree.insert(*boost::prior(poly_it->end()));
if(std::next(poly_it->begin()) != poly_it->end()) {
tree.insert(*std::prev(poly_it->end()));
}
}
}
@ -1049,10 +1049,10 @@ polylines_to_protect(std::vector<std::vector<P> >& polylines,
continue;
typename Polyline::const_iterator pit = polyline.begin();
while (boost::next(pit) != polyline.end())
while (std::next(pit) != polyline.end())
{
vertex_descriptor v = g_manip.get_vertex(*pit, false);
vertex_descriptor w = g_manip.get_vertex(*boost::next(pit), false);
vertex_descriptor w = g_manip.get_vertex(*std::next(pit), false);
g_manip.try_add_edge(v, w);
++pit;
}
@ -1182,10 +1182,10 @@ merge_and_snap_polylines(const CGAL::Image_3& image,
continue;
auto pit = polyline.begin();
while (boost::next(pit) != polyline.end())
while (std::next(pit) != polyline.end())
{
vertex_descriptor v = g_manip.get_vertex(*pit, false);
vertex_descriptor w = g_manip.get_vertex(*boost::next(pit), false);
vertex_descriptor w = g_manip.get_vertex(*std::next(pit), false);
g_manip.try_add_edge(v, w);
++pit;
}
@ -1194,7 +1194,7 @@ merge_and_snap_polylines(const CGAL::Image_3& image,
// snap graph to existing_polylines
snap_graph_vertices(graph,
image.vx(), image.vy(), image.vz(),
boost::begin(existing_polylines), boost::end(existing_polylines),
std::begin(existing_polylines), std::end(existing_polylines),
K());
// rebuild polylines_to_snap

2
Mesh_3/include/CGAL/Mesh_3/search_for_connected_components_in_labeled_image.h
View File

@ -47,7 +47,7 @@ search_for_connected_components_in_labeled_image(const CGAL::Image_3& image,
const std::size_t nz = image.zdim();
const std::size_t size = nx * ny * nz;
typedef boost::uint16_t uint;
typedef std::uint16_t uint;
if(nx > 65535 || ny > 65535 || nz > 65535)
{

2
Mesh_3/include/CGAL/Mesh_cell_base_3.h
View File

@ -30,8 +30,6 @@
#include <CGAL/SMDS_3/io_signature.h>
#include <CGAL/tags.h>
#include <boost/type_traits/is_convertible.hpp>
#ifdef CGAL_LINKED_WITH_TBB
# include <atomic>
#endif

6
Mesh_3/include/CGAL/Mesh_criteria_3.h
View File

@ -28,7 +28,7 @@
#include <CGAL/Mesh_facet_criteria_3.h>
#include <CGAL/Mesh_cell_criteria_3.h>
#include <cfloat> // for the macro DBL_MAX
#include <boost/type_traits/is_base_of.hpp>
namespace CGAL {
@ -101,7 +101,7 @@ public:
template <typename Facet_criterion>
void add_facet_criterion(Facet_criterion* criterion) {
static_assert(boost::is_base_of<
static_assert(std::is_base_of<
typename Facet_criteria::Abstract_criterion,
Facet_criterion
>::value);
@ -110,7 +110,7 @@ public:
template <typename Cell_criterion>
void add_cell_criterion(Cell_criterion* criterion) {
static_assert(boost::is_base_of<
static_assert(std::is_base_of<
typename Cell_criteria::Abstract_criterion,
Cell_criterion
>::value);

7
Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h
View File

@ -37,7 +37,6 @@
#include <algorithm>
#include <type_traits>
#include <boost/next_prior.hpp> // for boost::prior and boost::next
#include <boost/variant.hpp>
#include <memory>
@ -883,7 +882,7 @@ public:
}
Curve_index maximal_curve_index() const {
if(edges_incidences_.empty()) return Curve_index();
return boost::prior(edges_incidences_.end())->first;
return std::prev(edges_incidences_.end())->first;
}
void build_curves_aabb_tree() const {
@ -1458,9 +1457,9 @@ insert_edge(InputIterator first, InputIterator end)
// 'compute_corners_incidences()', that corner is incident only to a
// loop, then it will be removed from the set of corners.
register_corner(*first, curve_index);
if ( *first != *boost::prior(end) )
if ( *first != *std::prev(end) )
{
register_corner(*boost::prior(end), curve_index);
register_corner(*std::prev(end), curve_index);
}
// Create a new polyline

8
Mesh_3/include/CGAL/Polyhedral_complex_mesh_domain_3.h
View File

@ -456,9 +456,9 @@ public:
// here we have a new free vertex on patch #`patch_id`
if(random.uniform_smallint(
boost::uint32_t(0),
boost::uint32_t(nb_of_free_vertices_on_patch[patch_id]))
< boost::uint32_t(needed_vertices_on_patch[patch_id]))
std::uint32_t(0),
std::uint32_t(nb_of_free_vertices_on_patch[patch_id]))
< std::uint32_t(needed_vertices_on_patch[patch_id]))
{
several_vertices_on_patch[patch_id].push_back(vit);
--needed_vertices_on_patch[patch_id];
@ -884,7 +884,7 @@ merge_duplicated_points(const PointSet& duplicated_points)
typename Union_find_t::handle first_handle =
handles[range_begin->second];
// In a second loop on the equal-range, update new_ids around p
for (it = boost::next(range_begin); it != range_end; ++it)
for (it = std::next(range_begin); it != range_end; ++it)
{
#if CGAL_MESH_3_VERBOSE > 10
std::cerr << " - #" << it->second << "\n";

4
Mesh_3/include/CGAL/refine_mesh_3.h
View File

@ -77,14 +77,14 @@ public:
#if defined(CGAL_LINKED_WITH_TBB)\
&& !defined(CGAL_PARALLEL_MESH_3_DO_NOT_ADD_OUTSIDE_POINTS_ON_A_FAR_SPHERE)
if (boost::is_convertible<typename C3T3::Concurrency_tag, CGAL::Parallel_tag>::value)
if (std::is_convertible<typename C3T3::Concurrency_tag, CGAL::Parallel_tag>::value)
{
if (dimension == -1)
r_c3t3_.add_far_point(new_vertex);
}
#endif
#ifdef CGAL_SEQUENTIAL_MESH_3_ADD_OUTSIDE_POINTS_ON_A_FAR_SPHERE
if (boost::is_convertible<typename C3T3::Concurrency_tag, CGAL::Sequential_tag>::value)
if (std::is_convertible<typename C3T3::Concurrency_tag, CGAL::Sequential_tag>::value)
{
if (dimension == -1)
r_c3t3_.add_far_point(new_vertex);

2
Mesh_3/test/Mesh_3/test_meshing_implicit_function.cpp
View File

@ -75,7 +75,7 @@ struct Implicit_tester : public Tester<K>
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
{
this->verify(c3t3, domain, criteria, Bissection_tag(), 40, 65, 60, 110);
}

2
Mesh_3/test/Mesh_3/test_meshing_implicit_function_deprecated.cpp
View File

@ -73,7 +73,7 @@ struct Implicit_tester : public Tester<K>
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
{
this->verify(c3t3, domain, criteria, Bissection_tag(), 40, 65, 60, 110);
}

2
Mesh_3/test/Mesh_3/test_meshing_polyhedron.cpp
View File

@ -90,7 +90,7 @@ struct Polyhedron_tester : public Tester<K>
this->verify_c3t3_volume(c3t3, vol*0.95, vol*1.05);
#ifdef CGAL_LINKED_WITH_TBB
// Parallel
if (boost::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
{
this->verify(c3t3, domain, criteria, Polyhedral_tag(),
110, 140, 190, 235, 300, 450);

2
Mesh_3/test/Mesh_3/test_meshing_utilities.h
View File

@ -399,7 +399,7 @@ struct Tester
// Parallel
typedef typename C3t3::Concurrency_tag Concurrency_tag;
if (boost::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
if (std::is_convertible<Concurrency_tag, CGAL::Parallel_tag>::value)
assert(hdist <= reference_value*4.);
else
#endif //CGAL_LINKED_WITH_TBB

22
NewKernel_d/include/CGAL/NewKernel_d/Cartesian_LA_base.h
View File

@ -13,7 +13,7 @@
#define CGAL_KERNEL_D_CARTESIAN_LA_BASE_H
#include <CGAL/basic.h>
#include <CGAL/Origin.h>
#include <boost/type_traits/integral_constant.hpp>
#include <type_traits>
#include <CGAL/representation_tags.h>
#include <CGAL/NewKernel_d/functor_tags.h>
#include <CGAL/Uncertain.h>
@ -89,7 +89,7 @@ struct Cartesian_LA_base_d : public Dimension_base<Dim_>
::add<Vector_cartesian_const_iterator_tag>::type
Iterator_list;
template<class, class=void, class=boost::integral_constant<int,0> > struct Functor {
template<class, class=void, class=std::integral_constant<int,0> > struct Functor {
typedef Null_functor type;
};
template<class D> struct Functor<Construct_ttag<Vector_tag>,D> {
@ -105,19 +105,19 @@ struct Cartesian_LA_base_d : public Dimension_base<Dim_>
typedef CartesianDVectorBase::Construct_cartesian_const_iterator<Self> type;
};
template<class D> struct Functor<Sum_of_vectors_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
typedef CartesianDVectorBase::Sum_of_vectors<Self> type;
};
template<class D> struct Functor<Difference_of_vectors_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
typedef CartesianDVectorBase::Difference_of_vectors<Self> type;
};
template<class D> struct Functor<Opposite_vector_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Has_vector_plus_minus_tag>::value> > {
typedef CartesianDVectorBase::Opposite_vector<Self> type;
};
template<class D> struct Functor<Midpoint_tag,D,
boost::integral_constant<int,
std::integral_constant<int,
!LA_vector::template Property<Has_vector_plus_minus_tag>::value
|| !LA_vector::template Property<Has_vector_scalar_ops_tag>::value> > {
typedef CartesianDVectorBase::Midpoint<Self> type;
@ -135,24 +135,24 @@ struct Cartesian_LA_base_d : public Dimension_base<Dim_>
typedef CartesianDVectorBase::PV_dimension<Self> type;
};
template<class D> struct Functor<Orientation_of_vectors_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_vectors_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_vectors_tag>::value> > {
typedef CartesianDVectorBase::Orientation_of_vectors<Self> type;
};
template<class D> struct Functor<Orientation_of_points_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_points_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Has_determinant_of_iterator_to_points_tag>::value> > {
typedef CartesianDVectorBase::Orientation_of_points<Self> type;
};
template<class D> struct Functor<Scalar_product_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Has_dot_product_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Has_dot_product_tag>::value> > {
typedef CartesianDVectorBase::Scalar_product<Self> type;
};
template<class D> struct Functor<Squared_distance_to_origin_tag,D,
boost::integral_constant<int,!LA_vector::template Property<Stores_squared_norm_tag>::value> > {
std::integral_constant<int,!LA_vector::template Property<Stores_squared_norm_tag>::value> > {
typedef CartesianDVectorBase::Squared_distance_to_origin_stored<Self> type;
};
// Use integral_constant<int,2> in case of failure, to distinguish from the previous one.
template<class D> struct Functor<Squared_distance_to_origin_tag,D,
boost::integral_constant<int,
std::integral_constant<int,
(LA_vector::template Property<Stores_squared_norm_tag>::value
|| !LA_vector::template Property<Has_dot_product_tag>::value)*2> > {
typedef CartesianDVectorBase::Squared_distance_to_origin_via_dotprod<Self> type;

8
NewKernel_d/include/CGAL/NewKernel_d/LA_eigen/LA.h
View File

@ -38,10 +38,10 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct LA_eigen {
struct Rebind_dimension {
typedef LA_eigen< NT, D2, D3 > Other;
};
template<class,class=void> struct Property : boost::false_type {};
template<class D> struct Property<Has_vector_plus_minus_tag,D> : boost::true_type {};
template<class D> struct Property<Has_vector_scalar_ops_tag,D> : boost::true_type {};
template<class D> struct Property<Has_dot_product_tag,D> : boost::true_type {};
template<class,class=void> struct Property : std::false_type {};
template<class D> struct Property<Has_vector_plus_minus_tag,D> : std::true_type {};
template<class D> struct Property<Has_vector_scalar_ops_tag,D> : std::true_type {};
template<class D> struct Property<Has_dot_product_tag,D> : std::true_type {};
typedef Eigen::Matrix<NT,Eigen_dimension<Dim_>::value,1,Eigen::ColMajor|Eigen::AutoAlign,Eigen_dimension<Max_dim_>::value,1> Vector;
typedef Eigen::Matrix<NT,Eigen::Dynamic,1> Dynamic_vector;

2
NewKernel_d/include/CGAL/NewKernel_d/Vector/array.h
View File

@ -38,7 +38,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Array_vector {
struct Rebind_dimension {
typedef Array_vector< NT, D2, D3 > Other;
};
template<class> struct Property : boost::false_type {};
template<class> struct Property : std::false_type {};
static const unsigned d_=Max_dim_::value;
static_assert(d_ != (unsigned)UNKNOWN_DIMENSION);

12
NewKernel_d/include/CGAL/NewKernel_d/Vector/avx4.h
View File

@ -31,19 +31,19 @@ namespace CGAL {
typedef Dimension_tag<4> Dimension;
typedef Dimension_tag<4> Max_dimension;
// No Rebind_dimension, this is a building block
template<class,bool=true> struct Property : boost::false_type {};
template<class,bool=true> struct Property : std::false_type {};
template<bool b> struct Property<Has_vector_plus_minus_tag,b>
: boost::true_type {};
: std::true_type {};
/* MAYBE?
template<bool b> struct Property<Has_vector_scalar_ops_tag,b>
: boost::true_type {};
: std::true_type {};
*/
template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
: boost::true_type {};
: std::true_type {};
template<bool b> struct Property<Has_dot_product_tag,b>
: boost::true_type {};
: std::true_type {};
template<bool b> struct Property<Has_determinant_of_vectors_omit_last_tag,b>
: boost::true_type {};
: std::true_type {};
typedef __m256d Vector;
struct Construct_vector {

2
NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_iterator_to_points_from_iterator_to_vectors.h
View File

@ -42,7 +42,7 @@ struct Add_determinant_of_iterator_to_points_from_iterator_to_vectors
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
boost::true_type {};
std::true_type {};
// TODO: use std::minus, boost::bind, etc
template<class T> struct Minus_fixed {

10
NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_iterator_to_points_from_points.h
View File

@ -42,7 +42,7 @@ struct Add_determinant_of_iterator_to_points_from_points
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@ -74,7 +74,7 @@ struct Add_determinant_of_iterator_to_points_from_points
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@ -108,7 +108,7 @@ struct Add_determinant_of_iterator_to_points_from_points
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@ -144,7 +144,7 @@ struct Add_determinant_of_iterator_to_points_from_points
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){
@ -182,7 +182,7 @@ struct Add_determinant_of_iterator_to_points_from_points
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_points_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_points(Iter const&first, Iter const&end){

10
NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_iterator_to_vectors_from_vectors.h
View File

@ -42,7 +42,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@ -72,7 +72,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@ -104,7 +104,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@ -138,7 +138,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){
@ -174,7 +174,7 @@ struct Add_determinant_of_iterator_to_vectors_from_vectors
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_iterator_to_vectors_tag, D> :
boost::true_type {};
std::true_type {};
template<class Iter>
static NT determinant_of_iterator_to_vectors(Iter const&first, Iter const&end){

10
NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_points_from_vectors.h
View File

@ -42,7 +42,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_points_tag, D> :
boost::true_type {};
std::true_type {};
static NT determinant_of_points(Vector const&a, Vector const&b,
Vector const&c){
@ -66,7 +66,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_points_tag, D> :
boost::true_type {};
std::true_type {};
static NT determinant_of_points(Vector const&a, Vector const&b,
Vector const&c, Vector const&d){
@ -90,7 +90,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_points_tag, D> :
boost::true_type {};
std::true_type {};
static NT determinant_of_points(Vector const&a, Vector const&b,
Vector const&c, Vector const&d, Vector const&e){
@ -114,7 +114,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_points_tag, D> :
boost::true_type {};
std::true_type {};
static NT determinant_of_points(Vector const&a, Vector const&b,
Vector const&c, Vector const&d, Vector const&e, Vector const&f){
@ -138,7 +138,7 @@ struct Add_determinant_of_points_from_vectors_and_minus
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<Has_determinant_of_points_tag, D> :
boost::true_type {};
std::true_type {};
static NT determinant_of_points(Vector const&a, Vector const&b,
Vector const&c, Vector const&d, Vector const&e, Vector const&f,

10
NewKernel_d/include/CGAL/NewKernel_d/Vector/determinant_of_vectors_small_dim_internal.h
View File

@ -46,7 +46,7 @@ struct CGAL_CLASS
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<CGAL_TAG, D> :
boost::true_type {};
std::true_type {};
static NT CGAL_FUNC(Vector const&a, Vector const&b){
return CGAL::determinant_of_vectors<NT>(a,b);
@ -69,7 +69,7 @@ struct CGAL_CLASS
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<CGAL_TAG, D> :
boost::true_type {};
std::true_type {};
static NT CGAL_FUNC(Vector const&a, Vector const&b,
Vector const&c){
@ -93,7 +93,7 @@ struct CGAL_CLASS
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<CGAL_TAG, D> :
boost::true_type {};
std::true_type {};
static NT CGAL_FUNC(Vector const&a, Vector const&b,
Vector const&c, Vector const&d){
@ -117,7 +117,7 @@ struct CGAL_CLASS
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<CGAL_TAG, D> :
boost::true_type {};
std::true_type {};
static NT CGAL_FUNC(Vector const&a, Vector const&b,
Vector const&c, Vector const&d, Vector const&e){
@ -141,7 +141,7 @@ struct CGAL_CLASS
};
template<class P,class=void> struct Property : LA::template Property<P> {};
template<class D> struct Property<CGAL_TAG, D> :
boost::true_type {};
std::true_type {};
static NT CGAL_FUNC(Vector const&a, Vector const&b,
Vector const&c, Vector const&d, Vector const&e, Vector const&f){

10
NewKernel_d/include/CGAL/NewKernel_d/Vector/sse2.h
View File

@ -32,17 +32,17 @@ namespace CGAL {
typedef Dimension_tag<2> Dimension;
typedef Dimension_tag<2> Max_dimension;
// No Rebind_dimension, this is a building block
template<class,bool=true> struct Property : boost::false_type {};
template<class,bool=true> struct Property : std::false_type {};
template<bool b> struct Property<Has_vector_plus_minus_tag,b>
: boost::true_type {};
: std::true_type {};
/* MAYBE?
template<bool b> struct Property<Has_vector_scalar_ops_tag,b>
: boost::true_type {};
: std::true_type {};
*/
template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
: boost::true_type {};
: std::true_type {};
template<bool b> struct Property<Has_dot_product_tag,b>
: boost::true_type {};
: std::true_type {};
typedef __m128d Vector;
struct Construct_vector {

8
NewKernel_d/include/CGAL/NewKernel_d/Vector/v2int.h
View File

@ -70,13 +70,13 @@ namespace CGAL {
typedef Dimension_tag<2> Dimension;
typedef Dimension_tag<2> Max_dimension;
// No Rebind_dimension, this is a building block
template<class,bool=true> struct Property : boost::false_type {};
template<class,bool=true> struct Property : std::false_type {};
//template<bool b> struct Property<Has_vector_plus_minus_tag,b>
// : boost::true_type {};
// : std::true_type {};
template<bool b> struct Property<Has_determinant_of_vectors_tag,b>
: boost::true_type {};
: std::true_type {};
//template<bool b> struct Property<Has_determinant_of_points_tag,b>
// : boost::true_type {};
// : std::true_type {};
// Advertise somehow that the sign_of_determinant* are exact?
typedef std::array<NT1,2> Vector;

2
NewKernel_d/include/CGAL/NewKernel_d/Vector/vector.h
View File

@ -29,7 +29,7 @@ template<class NT_,class Dim_,class Max_dim_=Dim_> struct Vector_vector {
struct Rebind_dimension {
typedef Vector_vector< NT, D2, D3 > Other;
};
template<class> struct Property : boost::false_type {};
template<class> struct Property : std::false_type {};
struct Construct_vector {
struct Dimension {

2
NewKernel_d/include/CGAL/NewKernel_d/functor_properties.h
View File

@ -20,7 +20,7 @@ namespace CGAL {
BOOST_MPL_HAS_XXX_TRAIT_DEF(Is_pretty) \
} \
template<class T,bool=internal::has_##Is_pretty<T>::value> \
struct Is_pretty : boost::false_type {}; \
struct Is_pretty : std::false_type {}; \
template<class T> \
struct Is_pretty<T,true> : T::Is_pretty {}

22
NewKernel_d/include/CGAL/NewKernel_d/functor_tags.h
View File

@ -69,19 +69,19 @@ namespace CGAL {
Provides_functor<K, typename boost::mpl::front<List>::type>,
Provides_functors<K, typename boost::mpl::pop_front<List>::type> > {};
template<class K, class List>
struct Provides_functors<K, List, true> : boost::true_type {};
struct Provides_functors<K, List, true> : std::true_type {};
template<class K, class List, bool=boost::mpl::empty<List>::type::value>
struct Provides_types : boost::mpl::and_ <
Provides_type<K, typename boost::mpl::front<List>::type>,
Provides_types<K, typename boost::mpl::pop_front<List>::type> > {};
template<class K, class List>
struct Provides_types<K, List, true> : boost::true_type {};
struct Provides_types<K, List, true> : std::true_type {};
namespace internal { BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_Type,template Type<Null_tag>,false) }
template<class Kernel, class Tg,
bool = internal::has_Type<Kernel>::value /* false */>
struct Provides_type_i : boost::false_type {};
struct Provides_type_i : std::false_type {};
template<class Kernel, class Tg>
struct Provides_type_i <Kernel, Tg, true>
: Has_type_different_from<typename Kernel::template Type<Tg>, Null_type> {};
@ -93,7 +93,7 @@ namespace CGAL {
template<class Kernel, class Tg, class O=void,
bool = internal::has_Functor<Kernel>::value /* false */>
struct Provides_functor_i : boost::false_type {};
struct Provides_functor_i : std::false_type {};
template<class Kernel, class Tg, class O>
struct Provides_functor_i <Kernel, Tg, O, true>
: Has_type_different_from<typename Kernel::template Functor<Tg, O>, Null_functor> {};
@ -332,19 +332,19 @@ namespace CGAL {
struct Stores_squared_norm_tag {};
template<class> struct Preserved_by_non_linear_extra_coordinate
: boost::false_type {};
: std::false_type {};
template<> struct Preserved_by_non_linear_extra_coordinate
<Has_extra_dimension_tag> : boost::true_type {};
<Has_extra_dimension_tag> : std::true_type {};
template<> struct Preserved_by_non_linear_extra_coordinate
<Has_determinant_of_vectors_tag> : boost::true_type {};
<Has_determinant_of_vectors_tag> : std::true_type {};
template<> struct Preserved_by_non_linear_extra_coordinate
<Has_determinant_of_points_tag> : boost::true_type {};
<Has_determinant_of_points_tag> : std::true_type {};
template<> struct Preserved_by_non_linear_extra_coordinate
<Has_determinant_of_iterator_to_vectors_tag> : boost::true_type {};
<Has_determinant_of_iterator_to_vectors_tag> : std::true_type {};
template<> struct Preserved_by_non_linear_extra_coordinate
<Has_determinant_of_iterator_to_points_tag> : boost::true_type {};
<Has_determinant_of_iterator_to_points_tag> : std::true_type {};
template<> struct Preserved_by_non_linear_extra_coordinate
<Has_determinant_of_vectors_omit_last_tag> : boost::true_type {};
<Has_determinant_of_vectors_omit_last_tag> : std::true_type {};
// Kernel properties
struct Point_stores_squared_distance_to_origin_tag {};

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