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

replace cpp11::tuple by std::tuple

This commit is contained in:
Sébastien Loriot 2019-03-20 09:52:59 +01:00
parent ce126b87c6
commit f62624c4f9
105 changed files with 608 additions and 844 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -979,8 +979,8 @@ public:
template<class OutputIterator>
OutputIterator filtration(OutputIterator it) const
{
Dispatch_or_drop_output_iterator<cpp11::tuple<CGAL::Object>, cpp11::tuple<OutputIterator> > out(it);
return cpp11::template get<0>( filtration_with_alpha_values(out) );
Dispatch_or_drop_output_iterator<std::tuple<CGAL::Object>, std::tuple<OutputIterator> > out(it);
return std::template get<0>( filtration_with_alpha_values(out) );
}
private:

2
BGL/doc/BGL/CGAL/Linear_cell_complex_bgl_min_items.h
View File

@ -22,7 +22,7 @@ struct Linear_cell_complex_bgl_min_items
typedef CGAL::Tag_true Darts_with_id;
typedef CGAL::Cell_attribute_with_point_and_id<LCC> Vertex_attrib;
typedef CGAL::Cell_attribute_with_id<LCC> Face_attrib;
typedef CGAL::cpp11::tuple<Vertex_attrib, void, Face_attrib> Attributes;
typedef std::tuple<Vertex_attrib, void, Face_attrib> Attributes;
};
};

10
CGAL_ipelets/demo/CGAL_ipelets/arrangement.cpp
View File

@ -96,11 +96,11 @@ void ArrPolyIpelet::protected_run(int fn){
for (std::list<Circular_arc_2>::iterator it=arc_list.begin();it!=arc_list.end();++it)
input_curves.push_back(
Curve_2( CGAL::cpp11::get<0>(*it).center(),
sqrt(CGAL::to_double(CGAL::cpp11::get<0>(*it).squared_radius())),
CGAL::cpp11::get<3>(*it),
Traits::Point_2(CGAL::cpp11::get<1>(*it).x(),CGAL::cpp11::get<1>(*it).y()),
Traits::Point_2(CGAL::cpp11::get<2>(*it).x(),CGAL::cpp11::get<2>(*it).y())
Curve_2( std::get<0>(*it).center(),
sqrt(CGAL::to_double(std::get<0>(*it).squared_radius())),
std::get<3>(*it),
Traits::Point_2(std::get<1>(*it).x(),std::get<1>(*it).y()),
Traits::Point_2(std::get<2>(*it).x(),std::get<2>(*it).y())
)
);

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

@ -67,7 +67,7 @@ namespace CGAL{
typedef typename CGAL::Polygon_2<Kernel> Polygon_2;
typedef typename Kernel::Circle_2 Circle_2;
typedef CGAL::cpp11::tuple<Circle_2,Point_2,Point_2,CGAL::Sign> Circular_arc_2;
typedef std::tuple<Circle_2,Point_2,Point_2,CGAL::Sign> Circular_arc_2;
Ipelet_base(const std::string NameS,const std::string SubLabS[],const std::string HMsgS[])
@ -411,15 +411,15 @@ public:
draw_in_ipe(const Circular_arc_2& arc,bool deselect_all=false) const
{
IpeSegmentSubPath* SSP_ipe = new IpeSegmentSubPath;
IpeVector ipeS=IpeVector( CGAL::to_double(CGAL::cpp11::get<1>(arc).x()),
CGAL::to_double(CGAL::cpp11::get<1>(arc).y()));//convert ot ipe format
IpeVector ipeT=IpeVector( CGAL::to_double(CGAL::cpp11::get<2>(arc).x()),
CGAL::to_double(CGAL::cpp11::get<2>(arc).y()));//convert ot ipe format
SSP_ipe->AppendArc(IpeMatrix(sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),0,
0,(CGAL::cpp11::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),
CGAL::to_double(CGAL::cpp11::get<0>(arc).center().x()),
CGAL::to_double(CGAL::cpp11::get<0>(arc).center().y())),
IpeVector ipeS=IpeVector( CGAL::to_double(std::get<1>(arc).x()),
CGAL::to_double(std::get<1>(arc).y()));//convert ot ipe format
IpeVector ipeT=IpeVector( CGAL::to_double(std::get<2>(arc).x()),
CGAL::to_double(std::get<2>(arc).y()));//convert ot ipe format
SSP_ipe->AppendArc(IpeMatrix(sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),0,
0,(std::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),
CGAL::to_double(std::get<0>(arc).center().x()),
CGAL::to_double(std::get<0>(arc).center().y())),
ipeS,ipeT);
IpePath* obj_ipe = new IpePath(_helper->Attributes());
obj_ipe->AddSubPath(SSP_ipe);
@ -482,17 +482,17 @@ public:
draw_in_ipe(const Circular_arc_2& object,const Iso_rectangle_2& bbox,bool deselect_all=false) const
{
std::vector<Circular_arc_2> arc_list;
const Circle_2& circle=CGAL::cpp11::get<0>(object);
const Circle_2& circle=std::get<0>(object);
restrict_circle_to_bbox(circle,bbox,std::back_inserter(arc_list));
if (arc_list.empty() && bbox.has_on_bounded_side(circle.center()) ){
draw_in_ipe(object,deselect_all);
return;
}
const Point_2* source=(CGAL::cpp11::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<1>(object):&CGAL::cpp11::get<2>(object);
const Point_2* target=(CGAL::cpp11::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<2>(object):&CGAL::cpp11::get<1>(object);
const Point_2* source=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&std::get<1>(object):&std::get<2>(object);
const Point_2* target=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&std::get<2>(object):&std::get<1>(object);
std::multimap<double,std::pair<Type_circ_arc,const Point_2*> > map_theta;
typedef typename std::multimap<double,std::pair<Type_circ_arc,const Point_2*> >::iterator Map_theta_iterator;
Map_theta_iterator s_it=map_theta.insert(
@ -501,10 +501,10 @@ public:
std::make_pair(get_theta(*target,circle),std::make_pair(OTRG,target)));
for (typename std::vector<Circular_arc_2>::iterator it_arc=arc_list.begin();it_arc!=arc_list.end();++it_arc){
const Point_2* arc_s=(CGAL::cpp11::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<1>(*it_arc):&CGAL::cpp11::get<2>(*it_arc);
const Point_2* arc_t=(CGAL::cpp11::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<2>(*it_arc):&CGAL::cpp11::get<1>(*it_arc);
const Point_2* arc_s=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&std::get<1>(*it_arc):&std::get<2>(*it_arc);
const Point_2* arc_t=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&std::get<2>(*it_arc):&std::get<1>(*it_arc);
map_theta.insert( std::make_pair(get_theta(*arc_s,circle),std::make_pair(SRC,arc_s) ) );
map_theta.insert( std::make_pair(get_theta(*arc_t,circle),std::make_pair(TRG,arc_t) ) );
}
@ -773,9 +773,9 @@ public:
Circle_2 approx_circle=conv(exact_circle);
if (!sign_known){
CGAL::Sign sign = (CGAL::orientation(sd,td,center)==CGAL::LEFT_TURN)?CGAL::POSITIVE:CGAL::NEGATIVE;
return CGAL::cpp11::make_tuple(approx_circle,sd,td,sign);
return std::make_tuple(approx_circle,sd,td,sign);
}
return CGAL::cpp11::make_tuple(approx_circle,sd,td,CGAL::POSITIVE);
return std::make_tuple(approx_circle,sd,td,CGAL::POSITIVE);
}
void

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

@ -103,7 +103,7 @@ namespace CGAL{
typedef CGAL::Polygon_2<Kernel> Polygon_2;
typedef typename Kernel::Circle_2 Circle_2;
typedef CGAL::cpp11::tuple<Circle_2,Point_2,Point_2,CGAL::Sign> Circular_arc_2;
typedef std::tuple<Circle_2,Point_2,Point_2,CGAL::Sign> Circular_arc_2;
Ipelet_base(const std::string NameS,const std::string SubLabS[],const std::string HMsgS[])
@ -422,15 +422,15 @@ public:
draw_in_ipe(const Circular_arc_2& arc,bool deselect_all=false) const
{
ipe::Curve* SSP_ipe = new ipe::Curve;
ipe::Vector ipeS=ipe::Vector( CGAL::to_double(CGAL::cpp11::get<1>(arc).x()),
CGAL::to_double(CGAL::cpp11::get<1>(arc).y()));//convert ot ipe format
ipe::Vector ipeT=ipe::Vector( CGAL::to_double(CGAL::cpp11::get<2>(arc).x()),
CGAL::to_double(CGAL::cpp11::get<2>(arc).y()));//convert ot ipe format
SSP_ipe->appendArc(ipe::Matrix(sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),0,
0,(CGAL::cpp11::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),
CGAL::to_double(CGAL::cpp11::get<0>(arc).center().x()),
CGAL::to_double(CGAL::cpp11::get<0>(arc).center().y())),
ipe::Vector ipeS=ipe::Vector( CGAL::to_double(std::get<1>(arc).x()),
CGAL::to_double(std::get<1>(arc).y()));//convert ot ipe format
ipe::Vector ipeT=ipe::Vector( CGAL::to_double(std::get<2>(arc).x()),
CGAL::to_double(std::get<2>(arc).y()));//convert ot ipe format
SSP_ipe->appendArc(ipe::Matrix(sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),0,
0,(std::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),
CGAL::to_double(std::get<0>(arc).center().x()),
CGAL::to_double(std::get<0>(arc).center().y())),
ipeS,ipeT);
ipe::Shape shape;
shape.appendSubPath(SSP_ipe);
@ -490,17 +490,17 @@ public:
draw_in_ipe(const Circular_arc_2& object,const Iso_rectangle_2& bbox,bool deselect_all=false) const
{
std::vector<Circular_arc_2> arc_list;
const Circle_2& circle=CGAL::cpp11::get<0>(object);
const Circle_2& circle=std::get<0>(object);
restrict_circle_to_bbox(circle,bbox,std::back_inserter(arc_list));
if (arc_list.empty() && bbox.has_on_bounded_side(circle.center()) ){
draw_in_ipe(object,deselect_all);
return;
}
const Point_2* source=(CGAL::cpp11::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<1>(object):&CGAL::cpp11::get<2>(object);
const Point_2* target=(CGAL::cpp11::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<2>(object):&CGAL::cpp11::get<1>(object);
const Point_2* source=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&std::get<1>(object):&std::get<2>(object);
const Point_2* target=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
&std::get<2>(object):&std::get<1>(object);
std::multimap<double,std::pair<Type_circ_arc,const Point_2*> > map_theta;
typedef typename std::multimap<double,std::pair<Type_circ_arc,const Point_2*> >::iterator Map_theta_iterator;
Map_theta_iterator s_it=map_theta.insert(
@ -510,10 +510,10 @@ public:
std::make_pair(get_theta(*target,circle),std::make_pair(OTRG,target)));
for (typename std::vector<Circular_arc_2>::iterator it_arc=arc_list.begin();it_arc!=arc_list.end();++it_arc){
const Point_2* arc_s=(CGAL::cpp11::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<1>(*it_arc):&CGAL::cpp11::get<2>(*it_arc);
const Point_2* arc_t=(CGAL::cpp11::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&CGAL::cpp11::get<2>(*it_arc):&CGAL::cpp11::get<1>(*it_arc);
const Point_2* arc_s=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&std::get<1>(*it_arc):&std::get<2>(*it_arc);
const Point_2* arc_t=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
&std::get<2>(*it_arc):&std::get<1>(*it_arc);
map_theta.insert( std::make_pair(get_theta(*arc_s,circle),std::make_pair(SRC,arc_s) ) );
map_theta.insert( std::make_pair(get_theta(*arc_t,circle),std::make_pair(TRG,arc_t) ) );
}
@ -779,9 +779,9 @@ public:
Circle_2 approx_circle=conv(exact_circle);
if (!sign_known){
CGAL::Sign sign = (CGAL::orientation(sd,td,center)==CGAL::LEFT_TURN)?CGAL::POSITIVE:CGAL::NEGATIVE;
return CGAL::cpp11::make_tuple(approx_circle,sd,td,sign);
return std::make_tuple(approx_circle,sd,td,sign);
}
return CGAL::cpp11::make_tuple(approx_circle,sd,td,CGAL::POSITIVE);
return std::make_tuple(approx_circle,sd,td,CGAL::POSITIVE);
}
void

2
Combinatorial_map/doc/Combinatorial_map/CGAL/Combinatorial_map.h
View File

@ -65,7 +65,7 @@ Information associated with darts. Equal to `void` if `Dart_info` is not defined
typedef Items::Dart_wrapper<Self>::Dart_info Dart_info;
/*!
The tuple of cell attributes. Equal to `CGAL::cpp11::tuple<>` if `Attributes` is not defined in the items class.
The tuple of cell attributes. Equal to `std::tuple<>` if `Attributes` is not defined in the items class.
*/
typedef Items::Dart_wrapper<Self>::Attributes Attributes;

2
Combinatorial_map/doc/Combinatorial_map/CGAL/Combinatorial_map_min_items.h
View File

@ -22,7 +22,7 @@ struct Combinatorial_map_min_items
struct Dart_wrapper
{
typedef CGAL::Dart<d, CMap> Dart;
typedef CGAL::cpp11::tuple<> Attributes;
typedef std::tuple<> Attributes;
};
};
\endcode

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

@ -221,7 +221,7 @@ struct Example_items_3
{
typedef double Dart_info;
typedef CGAL::Cell_attribute<CMap, int> Edge_attrib;
typedef CGAL::cpp11::tuple<void,Edge_attrib> Attributes;
typedef std::tuple<void,Edge_attrib> Attributes;
};
};
typedef CGAL::Combinatorial_map<3, Example_items_3> Example_custom_cmap3;

2
Combinatorial_map/doc/Combinatorial_map/Concepts/GenericMapItems.h
View File

@ -28,7 +28,7 @@ The following examples show two possible models of the `GenericMapItems` concept
{
typedef double Dart_info;
typedef CGAL::Cell_attribute<GMap, int> Edge_attrib;
typedef CGAL::cpp11::tuple<void,Edge_attrib> Attributes;
typedef std::tuple<void,Edge_attrib> Attributes;
};
};
\endcode

2
Combinatorial_map/examples/Combinatorial_map/map_3_dynamic_onmerge.cpp
View File

@ -10,7 +10,7 @@ struct Myitem
struct Dart_wrapper
{
typedef CGAL::Cell_attribute<CMap, double> Face_attribute; // A weight
typedef CGAL::cpp11::tuple<void,void,Face_attribute> Attributes;
typedef std::tuple<void,void,Face_attribute> Attributes;
};
};

2
Combinatorial_map/examples/Combinatorial_map/map_3_with_colored_facets.cpp
View File

@ -27,7 +27,7 @@ struct Myitem
{
typedef CGAL::Cell_attribute<CMap, int, CGAL::Tag_true,
Sum_functor, Divide_by_two_functor> Facet_attribute;
typedef CGAL::cpp11::tuple<void,void,Facet_attribute> Attributes;
typedef std::tuple<void,void,Facet_attribute> Attributes;
};
};

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

@ -294,7 +294,7 @@ namespace CGAL {
boost::unordered_map<typename CMap2::Dart_const_handle, Dart_handle>* dart_mapping=NULL)
{
CGAL::cpp11::tuple<> converters;
std::tuple<> converters;
Default_converter_dart_info<CMap2, Refs> dartinfoconverter;
Default_converter_cmap_0attributes_with_point<CMap2, Refs> pointconverter;
copy(amap, converters, dartinfoconverter, pointconverter, dart_mapping);
@ -1311,7 +1311,7 @@ namespace CGAL {
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(args...);
// Reinitialize the ref counting of the new attribute. This is normally
// not required except if create_attribute is used as "copy contructor".
@ -1328,7 +1328,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"erase_attribute<i> but i-attributes are disabled");
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).erase(h);
}
@ -1338,7 +1338,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"is_attribute_used<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).is_used(ah);
}
@ -1348,7 +1348,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"number_of_attributes<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).size();
}
@ -1377,7 +1377,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attributes<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers);
}
@ -1386,7 +1386,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attributes<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers);
}
@ -1402,7 +1402,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onsplit_functors);
}
@ -1418,7 +1418,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onsplit_functors);
}
@ -1434,7 +1434,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onmerge_functors);
}
// Get the ith dynamic onmerge functor (by reference so that we can
@ -1449,7 +1449,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onmerge_functors);
}

2
Combinatorial_map/include/CGAL/Combinatorial_map_min_items.h
View File

@ -43,7 +43,7 @@ namespace CGAL {
struct Dart_wrapper
{
typedef CGAL::Dart< d, Refs > Dart;
typedef CGAL::cpp11::tuple<> Attributes;
typedef std::tuple<> Attributes;
};
};

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

@ -212,7 +212,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
template<unsigned int i>
@ -221,7 +221,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
@ -233,7 +233,7 @@ namespace CGAL {
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"copy_attribute<i> called but i-attributes are disabled.");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(*ah);
this->template init_attribute_ref_counting<i>(res);
return res;
@ -377,7 +377,7 @@ namespace CGAL {
template<unsigned int i>
void display_attribute(typename Attribute_const_handle<i>::type ah) const
{ std::cout<< CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
{ std::cout<< std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).index(ah); }
protected:
@ -386,7 +386,7 @@ namespace CGAL {
void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(dh->mattribute_handles) = ah;
}

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

@ -186,7 +186,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_handles);
}
template<int i>
@ -194,7 +194,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_handles);
}
@ -299,7 +299,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_handles);
}
template<int i>
@ -307,7 +307,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_handles);
}
};

2
Combinatorial_map/include/CGAL/internal/Combinatorial_map_copy_functors.h
View File

@ -163,7 +163,7 @@ struct Get_convert_attribute_functor<Map1,Map2,i,Converters,false>
run( const Map1& cmap1, Map2& cmap2, typename Map1::Dart_const_handle dh1,
typename Map2::Dart_handle dh2, const Converters& converters)
{
return CGAL::cpp11::get<i>(converters) (cmap1, cmap2, dh1, dh2);
return std::get<i>(converters) (cmap1, cmap2, dh1, dh2);
}
};
// ****************************************************************************

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

@ -114,9 +114,9 @@ struct Swap_attributes_functor
template<unsigned int i>
static void run( CMap& cmap1,
CMap& cmap2)
{ CGAL::cpp11::get<CMap::Helper::template Dimension_index<i>::value>
{ std::get<CMap::Helper::template Dimension_index<i>::value>
(cmap1.mattribute_containers).swap(
CGAL::cpp11::get<CMap::Helper::template Dimension_index<i>::value>
std::get<CMap::Helper::template Dimension_index<i>::value>
(cmap2.mattribute_containers));
}
};
@ -159,9 +159,9 @@ struct Call_split_functor
run(amap.template get_attribute<i>(a1),
amap.template get_attribute<i>(a2));
// Dynamic version
if ( CGAL::cpp11::get<CMap::Helper::template Dimension_index<i>::value>
if ( std::get<CMap::Helper::template Dimension_index<i>::value>
(amap.m_onsplit_functors) )
CGAL::cpp11::get<CMap::Helper::template Dimension_index<i>::value>
std::get<CMap::Helper::template Dimension_index<i>::value>
(amap.m_onsplit_functors) (amap.template get_attribute<i>(a1),
amap.template get_attribute<i>(a2));
}
@ -196,9 +196,9 @@ struct Call_merge_functor
run(amap.template get_attribute<i>(a1),
amap.template get_attribute<i>(a2));
// Dynamic version
if ( CGAL::cpp11::get<CMap::Helper::template Dimension_index<i>::value>
if ( std::get<CMap::Helper::template Dimension_index<i>::value>
(amap.m_onmerge_functors) )
CGAL::cpp11::get<CMap::Helper::template Dimension_index<i>::value>
std::get<CMap::Helper::template Dimension_index<i>::value>
(amap.m_onmerge_functors) (amap.template get_attribute<i>(a1),
amap.template get_attribute<i>(a2));
}

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

@ -72,11 +72,11 @@ namespace CGAL
{ typedef CGAL::Tag_true type; };
// Get the type Attributes defined as inner type of T.
// If T::Attributes is not defined, defined CGAL::cpp11::tuple<> as type.
// If T::Attributes is not defined, defined std::tuple<> as type.
BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(Has_attributes_tuple,Attributes,false)
template<typename T, bool typedefined=Has_attributes_tuple<T>::value >
struct Get_attributes_tuple
{ typedef CGAL::cpp11::tuple<> type; };
{ typedef std::tuple<> type; };
template<typename T>
struct Get_attributes_tuple<T, true>
{ typedef typename T::Attributes type; };
@ -86,21 +86,21 @@ namespace CGAL
template<typename ... Items>
struct Convert_tuple_with_void;
template<typename ... Items>
struct Convert_tuple_with_void<CGAL::cpp11::tuple<Items...> >
struct Convert_tuple_with_void<std::tuple<Items...> >
{
typedef CGAL::cpp11::tuple<typename Convert_void<Items>::type... > type;
typedef std::tuple<typename Convert_void<Items>::type... > type;
};
// Length of a variadic template
template<typename ... T>
struct My_length;
template<typename T1, typename ... T>
struct My_length<CGAL::cpp11::tuple<T1, T...> >
struct My_length<std::tuple<T1, T...> >
{
static const int value = My_length<CGAL::cpp11::tuple<T...> >::value + 1;
static const int value = My_length<std::tuple<T...> >::value + 1;
};
template<>
struct My_length<CGAL::cpp11::tuple<> >
struct My_length<std::tuple<> >
{
static const int value = 0;
};
@ -109,17 +109,17 @@ namespace CGAL
template<class Type,class Tuple>
struct Number_of_type_in_tuple;
template<class Type,typename ... Items>
struct Number_of_type_in_tuple<Type,CGAL::cpp11::tuple<Type,Items...> >{
struct Number_of_type_in_tuple<Type,std::tuple<Type,Items...> >{
static const int value=Number_of_type_in_tuple
<Type,CGAL::cpp11::tuple<Items...> >::value+1;
<Type,std::tuple<Items...> >::value+1;
};
template<class Type,class Other, typename ... Items>
struct Number_of_type_in_tuple<Type,CGAL::cpp11::tuple<Other,Items...> >{
struct Number_of_type_in_tuple<Type,std::tuple<Other,Items...> >{
static const int value=Number_of_type_in_tuple
<Type,CGAL::cpp11::tuple<Items...> >::value;
<Type,std::tuple<Items...> >::value;
};
template<class Type>
struct Number_of_type_in_tuple<Type,CGAL::cpp11::tuple<> >{
struct Number_of_type_in_tuple<Type,std::tuple<> >{
static const int value=0;
};
@ -127,21 +127,21 @@ namespace CGAL
template<class Type, class Tuple>
struct Number_of_different_type_in_tuple;
template<class Type, typename Other, typename ... Items>
struct Number_of_different_type_in_tuple<Type,CGAL::cpp11::tuple
struct Number_of_different_type_in_tuple<Type,std::tuple
<Other, Items...> >
{
static const int value=Number_of_different_type_in_tuple
<Type,CGAL::cpp11::tuple<Items...> >::value+1;
<Type,std::tuple<Items...> >::value+1;
};
template<class Type, typename ... Items>
struct Number_of_different_type_in_tuple<Type, CGAL::cpp11::tuple
struct Number_of_different_type_in_tuple<Type, std::tuple
<Type,Items...> >
{
static const int value=Number_of_different_type_in_tuple
<Type,CGAL::cpp11::tuple<Items...> >::value;
<Type,std::tuple<Items...> >::value;
};
template<class Type>
struct Number_of_different_type_in_tuple<Type, CGAL::cpp11::tuple<> >
struct Number_of_different_type_in_tuple<Type, std::tuple<> >
{
static const int value=0;
};
@ -154,23 +154,23 @@ namespace CGAL
struct Nb_type_in_tuple_up_to_k;
template <class Type,int dim,int k,class T1,class ... T>
struct Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp11::tuple<T1,T...>,dim>
struct Nb_type_in_tuple_up_to_k<Type,k,std::tuple<T1,T...>,dim>
{
static const int pos= Nb_type_in_tuple_up_to_k
<Type,k,CGAL::cpp11::tuple<T...>,dim>::pos - 1;
<Type,k,std::tuple<T...>,dim>::pos - 1;
static const int value =
( pos==k ) ? ( boost::is_same<T1,Type>::value ? 0:-dim-1 )
: ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 1:0 )
+ Nb_type_in_tuple_up_to_k
<Type,k,CGAL::cpp11::tuple
<Type,k,std::tuple
<T...>,dim >::value)
:0
);
};
template <class Type,int dim,int k,class T1>
struct Nb_type_in_tuple_up_to_k<Type,k,CGAL::cpp11::tuple<T1>,dim >
struct Nb_type_in_tuple_up_to_k<Type,k,std::tuple<T1>,dim >
{
static const int pos=dim;
static const int value=(pos==k?
@ -187,23 +187,23 @@ namespace CGAL
template <class Type,int dim,int k,class T1,class ... T>
struct Nb_type_different_in_tuple_up_to_k<Type,k,
CGAL::cpp11::tuple<T1,T...>,dim>
std::tuple<T1,T...>,dim>
{
static const int pos = Nb_type_different_in_tuple_up_to_k
<Type,k,CGAL::cpp11::tuple<T...>,dim >::pos - 1;
<Type,k,std::tuple<T...>,dim >::pos - 1;
static const int value =
( pos==k ) ? ( boost::is_same<T1,Type>::value ? -dim-1 : 0 )
: ( ( pos<k ) ? ( ( boost::is_same<T1,Type>::value ? 0:1 )
+ Nb_type_different_in_tuple_up_to_k
<Type,k,CGAL::cpp11::tuple<T...>,dim >::value)
<Type,k,std::tuple<T...>,dim >::value)
:0
);
};
template <class Type,int dim,int k,class T1>
struct Nb_type_different_in_tuple_up_to_k<Type,k,
CGAL::cpp11::tuple<T1>,dim >
std::tuple<T1>,dim >
{
static const int pos=dim;
static const int value=(pos==k?
@ -215,38 +215,38 @@ namespace CGAL
template <template <class D> class Functor,class T>
struct Tuple_converter;
template <template <class D> class Functor,class ...T>
struct Tuple_converter<Functor,CGAL::cpp11::tuple<T...> >{
typedef CGAL::cpp11::tuple<typename Functor<T>::type... > type;
struct Tuple_converter<Functor,std::tuple<T...> >{
typedef std::tuple<typename Functor<T>::type... > type;
};
// To scan a given tuple, and keep only type different from Type
// to build the tuple Attribute_type.
template <class Type,class Res, class Tuple=CGAL::cpp11::tuple<> >
template <class Type,class Res, class Tuple=std::tuple<> >
struct Keep_type_different_of;
template < class Type,class ... Res >
struct Keep_type_different_of<Type,CGAL::cpp11::tuple<>,
CGAL::cpp11::tuple<Res...> >
struct Keep_type_different_of<Type,std::tuple<>,
std::tuple<Res...> >
{
typedef CGAL::cpp11::tuple<Res...> type;
typedef std::tuple<Res...> type;
};
template < class Type,class ... T, class ... Res >
struct Keep_type_different_of<Type,
CGAL::cpp11::tuple<Type,T ...>,
CGAL::cpp11::tuple<Res...> >
std::tuple<Type,T ...>,
std::tuple<Res...> >
{
typedef typename Keep_type_different_of
<Type,CGAL::cpp11::tuple<T ...>,CGAL::cpp11::tuple<Res...> >::type type;
<Type,std::tuple<T ...>,std::tuple<Res...> >::type type;
};
template < class Type, class Other, class ... T, class ... Res >
struct Keep_type_different_of<Type,CGAL::cpp11::tuple<Other,T...>,
CGAL::cpp11::tuple<Res...> >
struct Keep_type_different_of<Type,std::tuple<Other,T...>,
std::tuple<Res...> >
{
typedef typename Keep_type_different_of
<Type, CGAL::cpp11::tuple<T...>,
CGAL::cpp11::tuple<Res...,Other> >::type type;
<Type, std::tuple<T...>,
std::tuple<Res...,Other> >::type type;
};
//Helper class to statically call a functor
@ -335,18 +335,18 @@ namespace CGAL
template <class Functor,class Head, class ... Items,int n>
struct Foreach_static_restricted<Functor,
CGAL::cpp11::tuple<Head,Items...>,n>
std::tuple<Head,Items...>,n>
{
template <class ... T>
static void run(T& ... t){
Conditionnal_run<Functor,n,Head>::run(t...);
Foreach_static_restricted
<Functor,CGAL::cpp11::tuple<Items...>,n+1>::run(t...);
<Functor,std::tuple<Items...>,n+1>::run(t...);
}
};
template <class Functor,int n>
struct Foreach_static_restricted<Functor,CGAL::cpp11::tuple<>,n>{
struct Foreach_static_restricted<Functor,std::tuple<>,n>{
template <class ... T>
static void run(T& ... ){}
};
@ -359,18 +359,18 @@ namespace CGAL
template <class Functor,int j,class Head, class ... Items,int n>
struct Foreach_static_restricted_except<Functor, j,
CGAL::cpp11::tuple<Head,Items...>,n>
std::tuple<Head,Items...>,n>
{
template <class ... T>
static void run(T& ... t){
Conditionnal_run_except<Functor,n,j,Head>::run(t...);
Foreach_static_restricted_except
<Functor,j,CGAL::cpp11::tuple<Items...>,n+1>::run(t...);
<Functor,j,std::tuple<Items...>,n+1>::run(t...);
}
};
template <class Functor,int j,int n>
struct Foreach_static_restricted_except<Functor,j,CGAL::cpp11::tuple<>,n>
struct Foreach_static_restricted_except<Functor,j,std::tuple<>,n>
{
template <class ... T>
static void run(T& ... ){}
@ -382,7 +382,7 @@ namespace CGAL
struct Apply_functor_to_each_tuple_element
{
static void run(Tuple& t){
Functor() ( CGAL::cpp11::get<pos>(t) );
Functor() ( std::get<pos>(t) );
Apply_functor_to_each_tuple_element<Functor,Tuple,pos-1>::run(t);
}
};
@ -518,7 +518,7 @@ namespace CGAL
template<int d, int in_tuple=(d<CGAL::internal::My_length
<Attributes>::value)>
struct Attribute_type
{ typedef typename CGAL::cpp11::tuple_element<d,Attributes>::type type; };
{ typedef typename std::tuple_element<d,Attributes>::type type; };
template<int d>
struct Attribute_type<d,0>
@ -528,7 +528,7 @@ namespace CGAL
template<int d, class Type=typename Attribute_type<d>::type>
struct Attribute_handle
{
typedef typename CGAL::cpp11::tuple_element
typedef typename std::tuple_element
<Dimension_index<d>::value,Attribute_handles>::type type;
};
@ -540,7 +540,7 @@ namespace CGAL
template<int d, class Type=typename Attribute_type<d>::type>
struct Attribute_const_handle
{
typedef typename CGAL::cpp11::tuple_element
typedef typename std::tuple_element
<Dimension_index<d>::value, Attribute_const_handles>::type type;
};
@ -552,7 +552,7 @@ namespace CGAL
template<int d, class Type=typename Attribute_type<d>::type>
struct Attribute_iterator
{
typedef typename CGAL::cpp11::tuple_element
typedef typename std::tuple_element
<Dimension_index<d>::value, Attribute_iterators>::type type;
};
@ -564,7 +564,7 @@ namespace CGAL
template<int d, class Type=typename Attribute_type<d>::type>
struct Attribute_const_iterator
{
typedef typename CGAL::cpp11::tuple_element
typedef typename std::tuple_element
<Dimension_index<d>::value, Attribute_const_iterators>::type type;
};
@ -576,7 +576,7 @@ namespace CGAL
template<int d, class Type=typename Attribute_type<d>::type>
struct Attribute_range
{
typedef typename CGAL::cpp11::tuple_element
typedef typename std::tuple_element
<Dimension_index<d>::value, Attribute_ranges>::type type;
};
@ -588,7 +588,7 @@ namespace CGAL
template<int d, class Type=typename Attribute_type<d>::type>
struct Attribute_const_range
{
typedef const typename CGAL::cpp11::tuple_element
typedef const typename std::tuple_element
<Dimension_index<d>::value, Attribute_ranges >::type type;
};

18
Combinatorial_map/test/Combinatorial_map/Combinatorial_map_copy_test.cpp
View File

@ -17,7 +17,7 @@ struct Map_2_dart_items
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Double_attrib, void, Double_attrib> Attributes;
typedef std::tuple<Double_attrib, void, Double_attrib> Attributes;
};
};
@ -32,7 +32,7 @@ struct Map_2_dart_max_items_3
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, Int_attrib,
typedef std::tuple<Int_attrib, Int_attrib,
Double_attrib> Attributes;
};
};
@ -46,7 +46,7 @@ struct Map_3_dart_items_3
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Double_attrib, void,
typedef std::tuple<Double_attrib, void,
Int_attrib, Double_attrib> Attributes;
};
};
@ -62,7 +62,7 @@ struct Map_3_dart_max_items_3
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, Int_attrib,
typedef std::tuple<Int_attrib, Int_attrib,
Int_attrib, Double_attrib> Attributes;
};
};
@ -91,7 +91,7 @@ public:
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, void, Int_attrib> Attributes;
typedef std::tuple<Int_attrib, void, Int_attrib> Attributes;
};
};
@ -103,7 +103,7 @@ struct Map_dart_items_4
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, void,
typedef std::tuple<Int_attrib, void,
Int_attrib, void, Int_attrib>
Attributes;
};
@ -119,7 +119,7 @@ struct Map_dart_max_items_4
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, Int_attrib,
typedef std::tuple<Int_attrib, Int_attrib,
Int_attrib, Int_attrib, Double_attrib>
Attributes;
};
@ -512,7 +512,7 @@ bool testCopy()
CGAL::Default_converter_cmap_attributes<Map9,Map5,2> c2;
CGAL::Cast_converter_cmap_attributes<Map9,Map5,3> c3;
CGAL::cpp11::tuple<CGAL::Cast_converter_cmap_attributes<Map9,Map5,0>,
std::tuple<CGAL::Cast_converter_cmap_attributes<Map9,Map5,0>,
CGAL::Default_converter_cmap_attributes<Map9,Map5,1>,
CGAL::Default_converter_cmap_attributes<Map9,Map5,2>,
CGAL::Cast_converter_cmap_attributes<Map9,Map5,3> > myconverters
@ -530,7 +530,7 @@ bool testCopy()
CGAL::Default_converter_cmap_attributes<Map5,Map9,2> cb2;
CGAL::Cast_converter_cmap_attributes<Map5,Map9,3> cb3;
CGAL::cpp11::tuple<CGAL::Cast_converter_cmap_attributes<Map5,Map9,0>,
std::tuple<CGAL::Cast_converter_cmap_attributes<Map5,Map9,0>,
CGAL::Default_converter_cmap_attributes<Map5,Map9,1>,
CGAL::Default_converter_cmap_attributes<Map5,Map9,2>,
CGAL::Cast_converter_cmap_attributes<Map5,Map9,3> > myconverters2

2
Combinatorial_map/test/Combinatorial_map/Combinatorial_map_deprecated_test.cpp
View File

@ -17,7 +17,7 @@ struct My_items
struct Dart_wrapper
{
typedef CGAL::Dart< 3, Refs > Dart;
typedef CGAL::cpp11::tuple<> Attributes;
typedef std::tuple<> Attributes;
};
};

14
Combinatorial_map/test/Combinatorial_map/Combinatorial_map_test.cpp
View File

@ -16,7 +16,7 @@ struct Map_2_dart_items
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Double_attrib, void, Double_attrib> Attributes;
typedef std::tuple<Double_attrib, void, Double_attrib> Attributes;
};
};
@ -31,7 +31,7 @@ struct Map_2_dart_max_items_3
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, Int_attrib,
typedef std::tuple<Int_attrib, Int_attrib,
Double_attrib> Attributes;
};
};
@ -45,7 +45,7 @@ struct Map_3_dart_items_3
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Double_attrib, void,
typedef std::tuple<Double_attrib, void,
Int_attrib, Double_attrib> Attributes;
};
};
@ -61,7 +61,7 @@ struct Map_3_dart_max_items_3
typedef CGAL::Cell_attribute< Refs, int, CGAL::Tag_true > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double, CGAL::Tag_true > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, Int_attrib,
typedef std::tuple<Int_attrib, Int_attrib,
Int_attrib, Double_attrib> Attributes;
};
};
@ -89,7 +89,7 @@ public:
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, void, Int_attrib> Attributes;
typedef std::tuple<Int_attrib, void, Int_attrib> Attributes;
};
};
@ -101,7 +101,7 @@ struct Map_dart_items_4
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, void,
typedef std::tuple<Int_attrib, void,
Int_attrib, void, Int_attrib>
Attributes;
};
@ -117,7 +117,7 @@ struct Map_dart_max_items_4
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib, Int_attrib,
typedef std::tuple<Int_attrib, Int_attrib,
Int_attrib, Double_attrib, Double_attrib>
Attributes;
};

44
Convex_hull_2/include/CGAL/Convex_hull_2/ch_akl_toussaint_impl.h
View File

@ -46,7 +46,7 @@ namespace internal{
template <class ForwardIterator, class Traits>
inline
cpp11::tuple<ForwardIterator,ForwardIterator,ForwardIterator,ForwardIterator>
std::tuple<ForwardIterator,ForwardIterator,ForwardIterator,ForwardIterator>
ch_nswe_point_with_order( ForwardIterator first, ForwardIterator last,
ForwardIterator& n,
ForwardIterator& s,
@ -81,7 +81,7 @@ ch_nswe_point_with_order( ForwardIterator first, ForwardIterator last,
ForwardIterator iterators[4]={w,e,n,s};
std::sort(positions,positions+4);
return cpp11::make_tuple(
return std::make_tuple(
iterators[positions[0].second],
iterators[positions[1].second],
iterators[positions[2].second],
@ -92,7 +92,7 @@ ch_nswe_point_with_order( ForwardIterator first, ForwardIterator last,
template <class RandomAccessIterator, class Traits>
inline
cpp11::tuple<RandomAccessIterator,RandomAccessIterator,RandomAccessIterator,RandomAccessIterator>
std::tuple<RandomAccessIterator,RandomAccessIterator,RandomAccessIterator,RandomAccessIterator>
ch_nswe_point_with_order( RandomAccessIterator first, RandomAccessIterator last,
RandomAccessIterator& n,
RandomAccessIterator& s,
@ -105,7 +105,7 @@ ch_nswe_point_with_order( RandomAccessIterator first, RandomAccessIterator last,
RandomAccessIterator iterators[4]={w,e,n,s};
std::sort(iterators,iterators+4);
return cpp11::make_tuple(
return std::make_tuple(
iterators[0],
iterators[1],
iterators[2],
@ -117,7 +117,7 @@ ch_nswe_point_with_order( RandomAccessIterator first, RandomAccessIterator last,
//sorted according to their positions in the range [first,last]
template <class ForwardIterator, class Traits>
inline
cpp11::tuple<ForwardIterator,ForwardIterator,ForwardIterator,ForwardIterator>
std::tuple<ForwardIterator,ForwardIterator,ForwardIterator,ForwardIterator>
ch_nswe_point_with_order( ForwardIterator first, ForwardIterator last,
ForwardIterator& n,
ForwardIterator& s,
@ -242,7 +242,7 @@ ch_akl_toussaint(ForwardIterator first, ForwardIterator last,
if (first == last) return result;
ForwardIterator n, s, e, w;
cpp11::tuple<ForwardIterator,ForwardIterator,ForwardIterator,ForwardIterator> ranges=
std::tuple<ForwardIterator,ForwardIterator,ForwardIterator,ForwardIterator> ranges=
internal::ch_nswe_point_with_order( first, last, n, s, w, e, ch_traits);
if (equal_points(*n, *s) )
@ -266,32 +266,32 @@ ch_akl_toussaint(ForwardIterator first, ForwardIterator last,
CGAL_ch_postcondition_code( ForwardIterator save_first = first; )
int duplicated_exteme_points = (cpp11::get<0>(ranges)==cpp11::get<1>(ranges)?1:0) +
(cpp11::get<1>(ranges)==cpp11::get<2>(ranges)?1:0) +
(cpp11::get<2>(ranges)==cpp11::get<3>(ranges)?1:0);
int duplicated_exteme_points = (std::get<0>(ranges)==std::get<1>(ranges)?1:0) +
(std::get<1>(ranges)==std::get<2>(ranges)?1:0) +
(std::get<2>(ranges)==std::get<3>(ranges)?1:0);
//several calls to avoid filter failures when using n,s,e,w
if (duplicated_exteme_points)
{
internal::ch_akl_toussaint_assign_points_to_regions_deg(first,cpp11::get<0>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions_deg(first,std::get<0>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
if ( cpp11::get<0>(ranges)!=cpp11::get<1>(ranges) )
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<0>(ranges)),cpp11::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
if ( std::get<0>(ranges)!=std::get<1>(ranges) )
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(std::get<0>(ranges)),std::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
if ( cpp11::get<1>(ranges)!=cpp11::get<2>(ranges) )
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<1>(ranges)),cpp11::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
if ( std::get<1>(ranges)!=std::get<2>(ranges) )
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(std::get<1>(ranges)),std::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
if ( cpp11::get<2>(ranges)!=cpp11::get<3>(ranges) )
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<2>(ranges)),cpp11::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
if ( std::get<2>(ranges)!=std::get<3>(ranges) )
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(std::get<2>(ranges)),std::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(cpp11::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions_deg(std::next(std::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,duplicated_exteme_points,ch_traits);
}
else{
internal::ch_akl_toussaint_assign_points_to_regions(first,cpp11::get<0>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<0>(ranges)),cpp11::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<1>(ranges)),cpp11::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<2>(ranges)),cpp11::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(cpp11::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(first,std::get<0>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(std::get<0>(ranges)),std::get<1>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(std::get<1>(ranges)),std::get<2>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(std::get<2>(ranges)),std::get<3>(ranges),left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
internal::ch_akl_toussaint_assign_points_to_regions(std::next(std::get<3>(ranges)),last,left_turn,e,w,n,s,region1,region2,region3,region4,ch_traits);
}
#if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \

2
Generalized_map/doc/Generalized_map/CGAL/Generalized_map.h
View File

@ -64,7 +64,7 @@ Information associated with darts. Equal to `void` if `Dart_info` is not defined
typedef Items::Dart_wrapper<Self>::Dart_info Dart_info;
/*!
The tuple of cell attributes. Equal to `CGAL::cpp11::tuple<>` if `Attributes` is not defined in the items class.
The tuple of cell attributes. Equal to `std::tuple<>` if `Attributes` is not defined in the items class.
*/
typedef Items::Dart_wrapper<Self>::Attributes Attributes;

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

@ -220,7 +220,7 @@ struct Example_items_3
{
typedef double Dart_info;
typedef CGAL::Cell_attribute<GMap, int> Edge_attrib;
typedef CGAL::cpp11::tuple<void,Edge_attrib> Attributes;
typedef std::tuple<void,Edge_attrib> Attributes;
};
};
typedef CGAL::Generalized_map<3, Example_items_3> Example_custom_gmap3;

2
Generalized_map/examples/Generalized_map/gmap_3_dynamic_onmerge.cpp
View File

@ -10,7 +10,7 @@ struct Myitem
struct Dart_wrapper
{
typedef CGAL::Cell_attribute<GMap, double> Face_attribute; // A weight
typedef CGAL::cpp11::tuple<void,void,Face_attribute> Attributes;
typedef std::tuple<void,void,Face_attribute> Attributes;
};
};

2
Generalized_map/examples/Generalized_map/gmap_3_with_colored_facets.cpp
View File

@ -27,7 +27,7 @@ struct Myitem
{
typedef CGAL::Cell_attribute<GMap, int, CGAL::Tag_true,
Sum_functor, Divide_by_two_functor> Facet_attribute;
typedef CGAL::cpp11::tuple<void,void,Facet_attribute> Attributes;
typedef std::tuple<void,void,Facet_attribute> Attributes;
};
};

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

@ -269,7 +269,7 @@ namespace CGAL {
void copy(const GMap2& amap,
boost::unordered_map<typename GMap2::Dart_const_handle, Dart_handle>* dart_mapping=NULL)
{
CGAL::cpp11::tuple<> converters;
std::tuple<> converters;
Default_converter_dart_info<GMap2, Refs> dartinfoconverter;
Default_converter_cmap_0attributes_with_point<GMap2, Refs> pointconverter;
copy(amap, converters, dartinfoconverter, pointconverter, dart_mapping);
@ -1136,7 +1136,7 @@ namespace CGAL {
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"create_attribute<i> but i-attributes are disabled");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(args...);
// Reinitialize the ref counting of the new attribute. This is normally
// not required except if create_attribute is used as "copy contructor".
@ -1151,7 +1151,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"erase_attribute<i> but i-attributes are disabled");
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).erase(h);
}
@ -1161,7 +1161,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"is_attribute_used<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).is_used(ah);
}
@ -1171,7 +1171,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"number_of_attributes<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).size();
}
@ -1200,7 +1200,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attributes<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers);
}
@ -1209,7 +1209,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attributes<i> but i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers);
}
@ -1225,7 +1225,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onsplit_functors);
}
@ -1241,7 +1241,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onsplit_functors);
}
@ -1257,7 +1257,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onmerge_functors);
}
// Get the ith dynamic onmerge functor (by reference so that we can
@ -1272,7 +1272,7 @@ namespace CGAL {
"onsplit_functor<i> but "
"i-attributes are disabled");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(m_onmerge_functors);
}

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

@ -208,7 +208,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
template<unsigned int i>
@ -217,7 +217,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
@ -229,7 +229,7 @@ namespace CGAL {
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"copy_attribute<i> called but i-attributes are disabled.");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(*ah);
this->template init_attribute_ref_counting<i>(res);
return res;
@ -371,7 +371,7 @@ namespace CGAL {
template<unsigned int i>
void display_attribute(typename Attribute_const_handle<i>::type ah) const
{ std::cout<< CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
{ std::cout<< std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).index(ah); }
protected:
@ -380,7 +380,7 @@ namespace CGAL {
void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(dh->mattribute_handles) = ah;
}

12
Generalized_map/test/Generalized_map/Generalized_map_test.cpp
View File

@ -30,7 +30,7 @@ struct Myitems_2
typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_true,Sum_functor,
Divide_by_two_functor> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib>
Attributes;
};
};
@ -44,7 +44,7 @@ struct Myitems_2c
typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_false,Sum_functor,
Divide_by_two_functor> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib>
Attributes;
};
};
@ -57,7 +57,7 @@ struct Myitems_3
typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_true,Sum_functor,
Divide_by_two_functor> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib>
Attributes;
};
};
@ -71,7 +71,7 @@ struct Myitems_3c
typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_false,Sum_functor,
Divide_by_two_functor> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib>
Attributes;
};
};
@ -85,7 +85,7 @@ struct Myitems_4
typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_true,Sum_functor,
Divide_by_two_functor> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
Attributes;
};
};
@ -99,7 +99,7 @@ struct Myitems_4c
typedef CGAL::Cell_attribute<GMAP,int,CGAL::Tag_false,Sum_functor,
Divide_by_two_functor> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
Attributes;
};
};

14
Intersections_2/benchmark/Intersections_2/variant_any_object.cpp
View File

@ -198,16 +198,16 @@ struct Do_f : Vec_holder {
void operator()(const Segment& s1, const Segment& s2) {
CGAL::Dispatch_or_drop_output_iterator<CGAL::cpp0x::tuple<Point,Segment>,
CGAL::cpp0x::tuple<Iter1,Iter2>
CGAL::Dispatch_or_drop_output_iterator<std::tuple<Point,Segment>,
std::tuple<Iter1,Iter2>
> do_it(std::back_inserter(*p), std::back_inserter(*s));
intersect_do_iterator(s1, s2, K(), do_it);
}
};
cpp0x::tuple<int, int, int> intersect_each_variant_overload(const Vector& segs) {
cpp0x::tuple<int, int, int> ret = cpp0x::make_tuple(0, 0, 0);
std::tuple<int, int, int> intersect_each_variant_overload(const Vector& segs) {
std::tuple<int, int, int> ret = std::make_tuple(0, 0, 0);
typedef Intersection_traits<K, Segment, Segment> Traits;
typedef Traits::result_type result_type;
@ -220,13 +220,13 @@ cpp0x::tuple<int, int, int> intersect_each_variant_overload(const Vector& segs)
// with c++0x
auto v = make_overload(
std::make_tuple(std::function<void(const Segment&)>(
[&ret](const Segment& s) { (void)s; ++(cpp0x::get<1>(ret)); }),
[&ret](const Segment& s) { (void)s; ++(std::get<1>(ret)); }),
std::function<void(const Point&)>(
[&ret](const Point& p) { (void)p; ++(cpp0x::get<0>(ret)); })));
[&ret](const Point& p) { (void)p; ++(std::get<0>(ret)); })));
boost::apply_visitor(v, *obj);
} else {
++(cpp0x::get<2>(ret));
++(std::get<2>(ret));
}
}
}

2
Kernel_23/examples/Kernel_23/intersections.cpp
View File

@ -48,7 +48,7 @@ int main()
std::vector<Segment> segments;
typedef CGAL::Dispatch_output_iterator<
CGAL::cpp11::tuple<Point,Segment>, CGAL::cpp11::tuple< std::back_insert_iterator<std::vector<Point> >,
std::tuple<Point,Segment>, std::tuple< std::back_insert_iterator<std::vector<Point> >,
std::back_insert_iterator<std::vector<Segment> > > >
Dispatcher;

4
Linear_cell_complex/benchmark/Linear_cell_complex_2/lcc_performance_2.h
View File

@ -31,7 +31,7 @@ public:
typedef CGAL::Cell_attribute_with_point<LCC, LCCVector_3, CGAL::Tag_true> Vertex;
typedef CGAL::Cell_attribute<LCC, LCCVector_3, CGAL::Tag_true> Face;
typedef CGAL::cpp0x::tuple<Vertex,void,Face> Attributes;
typedef std::tuple<Vertex,void,Face> Attributes;
};
};
@ -50,7 +50,7 @@ public:
typedef CGAL::Cell_attribute_for_index_with_point<LCC, LCCVector_3, CGAL::Tag_true> Vertex;
typedef CGAL::Cell_attribute_for_index<LCC, LCCVector_3, CGAL::Tag_true> Face;
typedef CGAL::cpp0x::tuple<Vertex,void,Face> Attributes;
typedef std::tuple<Vertex,void,Face> Attributes;
};
};
typedef CGAL::Linear_cell_complex_for_index<2, 3, MyTraitsLCC, MyItemsLCCWithIndex> LCC;

4
Linear_cell_complex/benchmark/Linear_cell_complex_3/lcc_performance_3.h
View File

@ -49,7 +49,7 @@ struct MyItem
typedef CGAL::Cell_attribute<Refs, Info_for_volume, CGAL::Tag_true> Vol_attribute;
typedef CGAL::cpp0x::tuple<Vertex_attribute, void, void, Vol_attribute> Attributes;
typedef std::tuple<Vertex_attribute, void, void, Vol_attribute> Attributes;
};
};
@ -68,7 +68,7 @@ struct MyItem
typedef CGAL::Cell_attribute_for_index<Refs, Info_for_volume, CGAL::Tag_true> Vol_attribute;
typedef CGAL::cpp0x::tuple<Vertex_attribute, void, void, Vol_attribute> Attributes;
typedef std::tuple<Vertex_attribute, void, void, Vol_attribute> Attributes;
};
};

2
Linear_cell_complex/demo/Linear_cell_complex/typedefs.h
View File

@ -158,7 +158,7 @@ public:
typedef CGAL::Cell_attribute_with_point< Refs > Vertex_attrib;
typedef CGAL::Cell_attribute< Refs, Volume_info> Volume_attrib;
typedef CGAL::cpp11::tuple<Vertex_attrib,void,void,
typedef std::tuple<Vertex_attrib,void,void,
Volume_attrib> Attributes;
};
};

2
Linear_cell_complex/doc/Linear_cell_complex/CGAL/Linear_cell_complex_min_items.h
View File

@ -22,7 +22,7 @@ struct Linear_cell_complex_min_items
struct Dart_wrapper
{
typedef CGAL::Cell_attribute_with_point<LCC> Vertex_attrib;
typedef CGAL::cpp11::tuple<Vertex_attrib> Attributes;
typedef std::tuple<Vertex_attrib> Attributes;
};
};

2
Linear_cell_complex/examples/Linear_cell_complex/linear_cell_complex_3_with_colored_vertices.cpp
View File

@ -18,7 +18,7 @@ struct Myitem
Average_functor >
Vertex_attribute;
typedef CGAL::cpp11::tuple<Vertex_attribute> Attributes;
typedef std::tuple<Vertex_attribute> Attributes;
};
};

10
Linear_cell_complex/include/CGAL/CMap_linear_cell_complex_storages.h
View File

@ -235,7 +235,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
template<unsigned int i>
@ -244,7 +244,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
@ -256,7 +256,7 @@ namespace CGAL {
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"copy_attribute<i> called but i-attributes are disabled.");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(*ah);
this->template init_attribute_ref_counting<i>(res);
return res;
@ -414,7 +414,7 @@ namespace CGAL {
template<unsigned int i>
void display_attribute(typename Attribute_const_handle<i>::type ah) const
{ std::cout<< CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
{ std::cout<< std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).index(ah); }
protected:
@ -423,7 +423,7 @@ namespace CGAL {
void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(dh->mattribute_handles) = ah;
}

10
Linear_cell_complex/include/CGAL/GMap_linear_cell_complex_storages.h
View File

@ -227,7 +227,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
template<unsigned int i>
@ -236,7 +236,7 @@ namespace CGAL {
{
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"attribute<i> called but i-attributes are disabled.");
return CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
return std::get<Helper::template Dimension_index<i>::value>
(ADart->mattribute_handles);
}
@ -248,7 +248,7 @@ namespace CGAL {
CGAL_static_assertion_msg(Helper::template Dimension_index<i>::value>=0,
"copy_attribute<i> called but i-attributes are disabled.");
typename Attribute_handle<i>::type res=
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).emplace(*ah);
this->template init_attribute_ref_counting<i>(res);
return res;
@ -404,7 +404,7 @@ namespace CGAL {
template<unsigned int i>
void display_attribute(typename Attribute_const_handle<i>::type ah) const
{ std::cout<< CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
{ std::cout<< std::get<Helper::template Dimension_index<i>::value>
(mattribute_containers).index(ah); }
protected:
@ -413,7 +413,7 @@ namespace CGAL {
void basic_set_dart_attribute(Dart_handle dh,
typename Attribute_handle<i>::type ah)
{
CGAL::cpp11::get<Helper::template Dimension_index<i>::value>
std::get<Helper::template Dimension_index<i>::value>
(dh->mattribute_handles) = ah;
}

2
Linear_cell_complex/include/CGAL/Linear_cell_complex_bgl_min_items.h
View File

@ -36,7 +36,7 @@ namespace CGAL {
typedef CGAL::Tag_true Darts_with_id;
typedef CGAL::Cell_attribute_with_point_and_id<LCC> Vertex_attribute;
typedef CGAL::Cell_attribute_with_id<LCC> Face_attribute;
typedef CGAL::cpp11::tuple<Vertex_attribute, void, Face_attribute> Attributes;
typedef std::tuple<Vertex_attribute, void, Face_attribute> Attributes;
};
};

4
Linear_cell_complex/include/CGAL/Linear_cell_complex_min_items.h
View File

@ -50,7 +50,7 @@ namespace CGAL {
typedef CGAL::Dart<d, LCC> Dart;
typedef CGAL::Cell_attribute_with_point<LCC> Vertex_attrib;
typedef CGAL::cpp11::tuple<Vertex_attrib> Attributes;
typedef std::tuple<Vertex_attrib> Attributes;
};
};
#else
@ -61,7 +61,7 @@ namespace CGAL {
struct Dart_wrapper
{
typedef CGAL::Cell_attribute_with_point<LCC> Vertex_attrib;
typedef CGAL::cpp11::tuple<Vertex_attrib> Attributes;
typedef std::tuple<Vertex_attrib> Attributes;
};
};
#endif

4
Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_2_test.cpp
View File

@ -50,7 +50,7 @@ struct Myitems_2b
{
typedef MonInfo Dart_info;
typedef Myattrib<LCC> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib>
Attributes;
};
};
@ -61,7 +61,7 @@ struct Myitems_2c
struct Dart_wrapper
{
typedef Myattrib<LCC> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib>
Attributes;
};
};

4
Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_3_test.cpp
View File

@ -50,7 +50,7 @@ struct Myitems_3b
{
typedef MonInfo Dart_info;
typedef Myattrib<LCC> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib>
Attributes;
};
};
@ -61,7 +61,7 @@ struct Myitems_3c
struct Dart_wrapper
{
typedef Myattrib<LCC> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib>
Attributes;
};
};

4
Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_4_test.cpp
View File

@ -54,7 +54,7 @@ struct Myitems_4b
typedef MonInfo Dart_info;
typedef Myattrib<LCC> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
Attributes;
};
};
@ -65,7 +65,7 @@ struct Myitems_4c
struct Dart_wrapper
{
typedef Myattrib<LCC> myattrib;
typedef CGAL::cpp11::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
typedef std::tuple<myattrib, myattrib, myattrib, myattrib,myattrib>
Attributes;
};
};

18
Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_copy_test.cpp
View File

@ -19,7 +19,7 @@ struct Map_2_dart_items
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::Cell_attribute_with_point< Refs, double > Double_attrib_wp;
typedef CGAL::cpp11::tuple<Double_attrib_wp, void, Double_attrib> Attributes;
typedef std::tuple<Double_attrib_wp, void, Double_attrib> Attributes;
};
};
@ -35,7 +35,7 @@ struct Map_2_dart_max_items_3
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib_wp, Int_attrib,
typedef std::tuple<Int_attrib_wp, Int_attrib,
Double_attrib> Attributes;
};
};
@ -52,7 +52,7 @@ struct Map_3_dart_items_3
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::Cell_attribute_with_point< Refs, double > Double_attrib_wp;
typedef CGAL::cpp11::tuple<Double_attrib_wp, void,
typedef std::tuple<Double_attrib_wp, void,
Int_attrib, Double_attrib> Attributes;
};
};
@ -69,7 +69,7 @@ struct Map_3_dart_max_items_3
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib_wp, Int_attrib,
typedef std::tuple<Int_attrib_wp, Int_attrib,
Int_attrib, Double_attrib> Attributes;
};
};
@ -86,7 +86,7 @@ public:
typedef CGAL::Cell_attribute_with_point< Refs, int > Int_attrib_wp;
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::cpp11::tuple<Int_attrib_wp, void, Int_attrib> Attributes;
typedef std::tuple<Int_attrib_wp, void, Int_attrib> Attributes;
};
};
@ -114,7 +114,7 @@ struct Map_dart_items_4
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib_wp, void,
typedef std::tuple<Int_attrib_wp, void,
Int_attrib, void, Int_attrib>
Attributes;
};
@ -131,7 +131,7 @@ struct Map_dart_max_items_4
typedef CGAL::Cell_attribute< Refs, int > Int_attrib;
typedef CGAL::Cell_attribute< Refs, double > Double_attrib;
typedef CGAL::cpp11::tuple<Int_attrib_wp, Int_attrib,
typedef std::tuple<Int_attrib_wp, Int_attrib,
Int_attrib, Int_attrib, Double_attrib>
Attributes;
};
@ -775,7 +775,7 @@ bool testCopy()
CGAL::Default_converter_cmap_attributes<Map9,Map5,2> c2;
CGAL::Cast_converter_cmap_attributes<Map9,Map5,3> c3;
CGAL::cpp11::tuple<CGAL::Cast_converter_cmap_attributes<Map9,Map5,0>,
std::tuple<CGAL::Cast_converter_cmap_attributes<Map9,Map5,0>,
CGAL::Default_converter_cmap_attributes<Map9,Map5,1>,
CGAL::Default_converter_cmap_attributes<Map9,Map5,2>,
CGAL::Cast_converter_cmap_attributes<Map9,Map5,3> > myconverters
@ -808,7 +808,7 @@ bool testCopy()
CGAL::Default_converter_cmap_attributes<Map5,Map9,2> cb2;
CGAL::Cast_converter_cmap_attributes<Map5,Map9,3> cb3;
CGAL::cpp11::tuple<CGAL::Cast_converter_cmap_attributes<Map5,Map9,0>,
std::tuple<CGAL::Cast_converter_cmap_attributes<Map5,Map9,0>,
CGAL::Default_converter_cmap_attributes<Map5,Map9,1>,
CGAL::Default_converter_cmap_attributes<Map5,Map9,2>,
CGAL::Cast_converter_cmap_attributes<Map5,Map9,3> > myconverters2

4
Mesh_2/include/CGAL/Constrained_voronoi_diagram_2.h
View File

@ -44,8 +44,8 @@ public:
typedef typename Cdt::Geom_traits::Ray_2 Ray;
typedef typename Cdt::Geom_traits::Point_2 Point;
typedef CGAL::Dispatch_output_iterator<
CGAL::cpp11::tuple<Segment, Ray>,
CGAL::cpp11::tuple<std::back_insert_iterator<std::vector<Segment> >,
std::tuple<Segment, Ray>,
std::tuple<std::back_insert_iterator<std::vector<Segment> >,
std::back_insert_iterator<std::vector<Ray> > >
> Construction_dispatcher;

4
Mesh_3/archive/applications/lanteri_utils.h
View File

@ -12,7 +12,7 @@
template <typename Iterator> // better be RandomAccessIterator, because
// std::distance() is used
CGAL::cpp11::tuple<
std::tuple<
typename std::iterator_traits<Iterator>::value_type,
typename std::iterator_traits<Iterator>::value_type,
typename std::iterator_traits<Iterator>::value_type,
@ -40,7 +40,7 @@ compute_max_min_sum_size(Iterator begin, Iterator end)
const size_type size = std::distance(begin, end);
return CGAL::cpp11::make_tuple(maximum, minimum, sum, size);
return std::make_tuple(maximum, minimum, sum, size);
}
void output_legend(std::ostream* out_stream = &std::cout, std::string prefix = "")

2
Mesh_3/doc/Mesh_3/Concepts/MeshDomainWithFeatures_3.h
View File

@ -159,7 +159,7 @@ get_corners(OutputIterator corners) const;
Fills `curves` with the curves
of the input domain.
`curves` value type must be
`CGAL::cpp11::tuple<Curve_index,std::pair<Point_3,%Index>,std::pair<Point_3,%Index> >`.
`std::tuple<Curve_index,std::pair<Point_3,%Index>,std::pair<Point_3,%Index> >`.
If the curve corresponding to an entry
in `curves` is not a loop, the pair of associated points should
belong to

2
Mesh_3/doc/Mesh_3/Concepts/MeshDomain_3.h
View File

@ -111,7 +111,7 @@ Returns type of `Construct_intersection` queries.
dimension of the lower dimensional face of the input complex on which the intersection
point lies and `%Index` is the index of this face.
*/
typedef CGAL::cpp11::tuple<Point_3, Index, int> Intersection;
typedef std::tuple<Point_3, Index, int> Intersection;
/*!
A function object to construct

2
Mesh_3/examples/Mesh_3/mesh_hybrid_mesh_domain.cpp
View File

@ -46,7 +46,7 @@ public:
typedef K R;
typedef K::Point_3 Point_3;
typedef CGAL::cpp11::tuple<Point_3, Index, int> Intersection;
typedef std::tuple<Point_3, Index, int> Intersection;
CGAL::Bbox_3 bbox() const {
return implicit_domain.bbox() + polyhedron_domain.bbox();

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

@ -314,7 +314,7 @@ public:
// access Function type from inherited class
typedef Function Fct;
typedef CGAL::cpp11::tuple<Point_3,Index,int> Intersection;
typedef std::tuple<Point_3,Index,int> Intersection;
typedef typename BGT::FT FT;
@ -979,7 +979,7 @@ Construct_initial_points::operator()(OutputIterator pts,
Surface_patch surface = r_domain_.do_intersect_surface_object()(random_seg);
if ( surface )
{
const Point_3 intersect_pt = CGAL::cpp11::get<0>(
const Point_3 intersect_pt = std::get<0>(
r_domain_.construct_intersection_object()(random_seg));
*pts++ = std::make_pair(intersect_pt,
r_domain_.index_from_surface_patch_index(*surface));

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

@ -1233,9 +1233,9 @@ private:
Intersection intersection = construct_intersection(dual);
Surface_patch surface =
(CGAL::cpp0x::get<2>(intersection) == 0) ? Surface_patch() :
(std::get<2>(intersection) == 0) ? Surface_patch() :
Surface_patch(
domain_.surface_patch_index(CGAL::cpp0x::get<1>(intersection)));
domain_.surface_patch_index(std::get<1>(intersection)));
#endif // CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
@ -1259,7 +1259,7 @@ private:
#endif // NOT CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
// Update facet surface center
Bare_point surface_center = CGAL::cpp0x::get<0>(intersection);
Bare_point surface_center = std::get<0>(intersection);
facet.first->set_facet_surface_center(facet.second, surface_center);
facet_m.first->set_facet_surface_center(facet_m.second, surface_center);
}
@ -3392,7 +3392,7 @@ project_on_surface_aux(const Bare_point& p,
domain_.do_intersect_surface_object();
if ( do_intersect(proj_segment) )
return CGAL::cpp0x::get<0>(construct_intersection(proj_segment));
return std::get<0>(construct_intersection(proj_segment));
else
return ref_point;
@ -3400,8 +3400,8 @@ project_on_surface_aux(const Bare_point& p,
typedef typename MD::Intersection Intersection;
Intersection intersection = construct_intersection(proj_segment);
if(CGAL::cpp0x::get<2>(intersection) == 2)
return CGAL::cpp0x::get<0>(intersection);
if(std::get<2>(intersection) == 2)
return std::get<0>(intersection);
else
return ref_point;

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

@ -84,7 +84,7 @@ protected:
// The sizing field info is stored inside the move vector because it is computed
// when the move is computed. This is because the parallel version uses the threadsafe
// version of incident_cells (which thus requires points to not be moving yet)
typedef std::vector<cpp11::tuple<typename Tr::Vertex_handle, Vector_3, FT> >
typedef std::vector<std::tuple<typename Tr::Vertex_handle, Vector_3, FT> >
Moves_vector;
typedef unsigned int Nb_frozen_points_type;
@ -129,7 +129,7 @@ protected:
typedef typename Gt::FT FT;
typedef typename Gt::Vector_3 Vector_3;
typedef typename Tr::Lock_data_structure Lock_data_structure;
typedef tbb::concurrent_vector<cpp11::tuple<typename Tr::Vertex_handle, Vector_3, FT> >
typedef tbb::concurrent_vector<std::tuple<typename Tr::Vertex_handle, Vector_3, FT> >
Moves_vector;
typedef tbb::atomic<unsigned int> Nb_frozen_points_type ;
@ -423,7 +423,7 @@ private:
//note : this is not happening for Lloyd and ODT so it's commented
// maybe for a new global optimizer it should be de-commented
m_moves.push_back(cpp11::make_tuple(oldv, move, size));
m_moves.push_back(std::make_tuple(oldv, move, size));
}
else // CGAL::NULL_VECTOR == move
{
@ -511,13 +511,13 @@ private:
{
for( size_t i = r.begin() ; i != r.end() ; ++i)
{
const Vertex_handle& v = cpp11::get<0>(m_moves[i]);
const Vector_3& move = cpp11::get<1>(m_moves[i]);
const Vertex_handle& v = std::get<0>(m_moves[i]);
const Vector_3& move = std::get<1>(m_moves[i]);
// Get size at new position
if ( MGO::Sizing_field::is_vertex_update_needed )
{
FT size = cpp11::get<2>(m_moves[i]);
FT size = std::get<2>(m_moves[i]);
// Move point
bool could_lock_zone;
@ -836,7 +836,7 @@ compute_moves(Moving_vertices_set& moving_vertices)
size = sizing_field_(new_position, oldv);
}
moves.push_back(cpp11::make_tuple(oldv, move, size));
moves.push_back(std::make_tuple(oldv, move, size));
}
else // CGAL::NULL_VECTOR == move
{
@ -954,12 +954,12 @@ update_mesh(const Moves_vector& moves,
it != moves.end() ;
++it )
{
const Vertex_handle& v = cpp11::get<0>(*it);
const Vector_3& move = cpp11::get<1>(*it);
const Vertex_handle& v = std::get<0>(*it);
const Vector_3& move = std::get<1>(*it);
// Get size at new position
if ( Sizing_field::is_vertex_update_needed )
{
FT size = cpp11::get<2>(*it);
FT size = std::get<2>(*it);
#ifdef CGAL_MESH_3_OPTIMIZER_VERBOSE
std::cout << "Moving #" << it - moves.begin()

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

@ -895,7 +895,7 @@ Protect_edges_sizing_field<C3T3, MD, Sf>::
insert_balls_on_edges()
{
// Get features
typedef CGAL::cpp11::tuple<Curve_index,
typedef std::tuple<Curve_index,
std::pair<Bare_point,Index>,
std::pair<Bare_point,Index> > Feature_tuple;
typedef std::vector<Feature_tuple> Input_features;
@ -907,17 +907,17 @@ insert_balls_on_edges()
for ( typename Input_features::iterator fit = input_features.begin(),
end = input_features.end() ; fit != end ; ++fit )
{
const Curve_index& curve_index = CGAL::cpp11::get<0>(*fit);
const Curve_index& curve_index = std::get<0>(*fit);
if ( ! is_treated(curve_index) )
{
#if CGAL_MESH_3_PROTECTION_DEBUG & 1
std::cerr << "** treat curve #" << curve_index << std::endl;
#endif
const Bare_point& p = CGAL::cpp11::get<1>(*fit).first;
const Bare_point& q = CGAL::cpp11::get<2>(*fit).first;
const Bare_point& p = std::get<1>(*fit).first;
const Bare_point& q = std::get<2>(*fit).first;
const Index& p_index = CGAL::cpp11::get<1>(*fit).second;
const Index& q_index = CGAL::cpp11::get<2>(*fit).second;
const Index& p_index = std::get<1>(*fit).second;
const Index& q_index = std::get<2>(*fit).second;
Vertex_handle vp,vq;
if ( ! domain_.is_loop(curve_index) )

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

@ -79,15 +79,15 @@ namespace Mesh_3 {
public:
Facet_to_refine_is_not_zombie() {}
bool operator()(const CGAL::cpp11::tuple<
bool operator()(const std::tuple<
Facet, unsigned int, Facet, unsigned int> &f) const
{
#ifdef _DEBUG
/*
int f1_current_erase_counter = CGAL::cpp11::get<0>(f).first->erase_counter();
int f1_saved_erase_counter = CGAL::cpp11::get<1>(f);
int f2_current_erase_counter = CGAL::cpp11::get<2>(f).first->erase_counter();
int f2_saved_erase_counter = CGAL::cpp11::get<3>(f);
int f1_current_erase_counter = std::get<0>(f).first->erase_counter();
int f1_saved_erase_counter = std::get<1>(f);
int f2_current_erase_counter = std::get<2>(f).first->erase_counter();
int f2_saved_erase_counter = std::get<3>(f);
*/
//f1_current_erase_counter - f1_saved_erase_counter + f2_current_erase_counter - f2_saved_erase_counter == 1
@ -99,7 +99,7 @@ namespace Mesh_3 {
#endif
std::stringstream sstr;
Facet facet = CGAL::cpp11::get<0>(f);
Facet facet = std::get<0>(f);
sstr << "Facet 1 { " << std::endl
<< " - " << *facet.first->vertex((facet.second+1)%4) << std::endl
<< " - " << *facet.first->vertex((facet.second+2)%4) << std::endl
@ -107,7 +107,7 @@ namespace Mesh_3 {
<< " - 4th vertex in cell: " << *facet.first->vertex(facet.second) << std::endl
<< "}" << std::endl;
facet = CGAL::cpp11::get<2>(f);
facet = std::get<2>(f);
sstr << "Facet 2 { " << std::endl
<< " - " << *facet.first->vertex((facet.second+1)%4) << std::endl
<< " - " << *facet.first->vertex((facet.second+2)%4) << std::endl
@ -119,8 +119,8 @@ namespace Mesh_3 {
std::cerr << s << std::endl;
}*/
#endif
return (CGAL::cpp11::get<0>(f).first->erase_counter() == CGAL::cpp11::get<1>(f)
&& CGAL::cpp11::get<2>(f).first->erase_counter() == CGAL::cpp11::get<3>(f) );
return (std::get<0>(f).first->erase_counter() == std::get<1>(f)
&& std::get<2>(f).first->erase_counter() == std::get<3>(f) );
}
};
@ -149,11 +149,11 @@ protected:
#if defined(CGAL_MESH_3_USE_LAZY_SORTED_REFINEMENT_QUEUE) \
|| defined(CGAL_MESH_3_USE_LAZY_UNSORTED_REFINEMENT_QUEUE)
CGAL::cpp11::tuple<Facet, unsigned int, Facet, unsigned int>
std::tuple<Facet, unsigned int, Facet, unsigned int>
from_facet_to_refinement_queue_element(const Facet &facet,
const Facet &mirror) const
{
return CGAL::cpp11::make_tuple(
return std::make_tuple(
facet, facet.first->erase_counter(),
mirror, mirror.first->erase_counter());
}
@ -163,7 +163,7 @@ public:
Facet extract_element_from_container_value(const Container_element &e) const
{
// We get the first Facet inside the tuple
return CGAL::cpp11::get<0>(e);
return std::get<0>(e);
}
#else
@ -208,11 +208,11 @@ protected:
m_last_vertex_index.local() = i;
}
CGAL::cpp11::tuple<Facet, unsigned int, Facet, unsigned int>
std::tuple<Facet, unsigned int, Facet, unsigned int>
from_facet_to_refinement_queue_element(const Facet &facet,
const Facet &mirror) const
{
return CGAL::cpp11::make_tuple(
return std::make_tuple(
facet, facet.first->erase_counter(),
mirror, mirror.first->erase_counter());
}
@ -222,7 +222,7 @@ public:
Facet extract_element_from_container_value(const Container_element &e) const
{
// We get the first Facet inside the tuple
return CGAL::cpp11::get<0>(e);
return std::get<0>(e);
}
protected:
@ -406,7 +406,7 @@ protected:
typedef typename MeshDomain::Index Index;
typedef typename boost::optional<
CGAL::cpp11::tuple<Surface_patch_index, Index, Bare_point> >
std::tuple<Surface_patch_index, Index, Bare_point> >
Facet_properties;
@ -651,7 +651,7 @@ template<class Tr,
Meshes::Filtered_multimap_container
# endif
<
CGAL::cpp11::tuple<typename Tr::Facet, unsigned int,
std::tuple<typename Tr::Facet, unsigned int,
typename Tr::Facet, unsigned int>,
typename Criteria::Facet_quality,
Facet_to_refine_is_not_zombie<typename Tr::Facet>,
@ -661,7 +661,7 @@ template<class Tr,
# ifdef CGAL_MESH_3_USE_LAZY_UNSORTED_REFINEMENT_QUEUE
Meshes::Filtered_deque_container
<
CGAL::cpp11::tuple<typename Tr::Facet, unsigned int,
std::tuple<typename Tr::Facet, unsigned int,
typename Tr::Facet, unsigned int>,
typename Criteria::Facet_quality,
Facet_to_refine_is_not_zombie<typename Tr::Facet>,
@ -670,7 +670,7 @@ template<class Tr,
# elif defined(CGAL_MESH_3_USE_LAZY_SORTED_REFINEMENT_QUEUE)
Meshes::Filtered_multimap_container
<
CGAL::cpp11::tuple<typename Tr::Facet, unsigned int,
std::tuple<typename Tr::Facet, unsigned int,
typename Tr::Facet, unsigned int>,
typename Criteria::Facet_quality,
Facet_to_refine_is_not_zombie<typename Tr::Facet>,
@ -689,7 +689,7 @@ template<class Tr,
# ifdef CGAL_MESH_3_USE_LAZY_UNSORTED_REFINEMENT_QUEUE
Meshes::Filtered_deque_container
<
CGAL::cpp11::tuple<typename Tr::Facet, unsigned int,
std::tuple<typename Tr::Facet, unsigned int,
typename Tr::Facet, unsigned int>,
typename Criteria::Facet_quality,
Facet_to_refine_is_not_zombie<typename Tr::Facet>,
@ -698,7 +698,7 @@ template<class Tr,
# elif defined(CGAL_MESH_3_USE_LAZY_SORTED_REFINEMENT_QUEUE)
Meshes::Filtered_multimap_container
<
CGAL::cpp11::tuple<typename Tr::Facet, unsigned int,
std::tuple<typename Tr::Facet, unsigned int,
typename Tr::Facet, unsigned int>,
typename Criteria::Facet_quality,
Facet_to_refine_is_not_zombie<typename Tr::Facet>,
@ -1155,9 +1155,9 @@ number_of_bad_elements_impl()
}
//const Surface_patch_index& surface_index = CGAL::cpp11::get<0>(*properties);
//const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
//const Bare_point& surface_center = CGAL::cpp11::get<2>(*properties);
//const Surface_patch_index& surface_index = std::get<0>(*properties);
//const Index& surface_center_index = std::get<1>(*properties);
//const Bare_point& surface_center = std::get<2>(*properties);
// Facet is on surface: set facet properties
//set_facet_surface_center(facet, surface_center, surface_center_index);
@ -1340,9 +1340,9 @@ conflicts_zone_impl(const Weighted_point& point
this->compute_facet_properties(facet, properties, /*force_exact=*/true);
if ( properties )
{
const Surface_patch_index& surface_index = CGAL::cpp11::get<0>(*properties);
const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
const Bare_point& surface_center = CGAL::cpp11::get<2>(*properties);
const Surface_patch_index& surface_index = std::get<0>(*properties);
const Index& surface_center_index = std::get<1>(*properties);
const Bare_point& surface_center = std::get<2>(*properties);
// Facet is on surface: set facet properties
this->set_facet_surface_center(facet, surface_center, surface_center_index);
@ -1402,9 +1402,9 @@ conflicts_zone_impl(const Weighted_point& point
this->compute_facet_properties(facet, properties, /*force_exact=*/true);
if ( properties )
{
const Surface_patch_index& surface_index = CGAL::cpp11::get<0>(*properties);
const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
const Bare_point& surface_center = CGAL::cpp11::get<2>(*properties);
const Surface_patch_index& surface_index = std::get<0>(*properties);
const Index& surface_center_index = std::get<1>(*properties);
const Bare_point& surface_center = std::get<2>(*properties);
// Facet is on surface: set facet properties
this->set_facet_surface_center(facet, surface_center, surface_center_index);
@ -1570,9 +1570,9 @@ treat_new_facet(Facet& facet)
compute_facet_properties(facet, properties);
if ( properties )
{
const Surface_patch_index& surface_index = CGAL::cpp11::get<0>(*properties);
const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
const Bare_point& surface_center = CGAL::cpp11::get<2>(*properties);
const Surface_patch_index& surface_index = std::get<0>(*properties);
const Index& surface_center_index = std::get<1>(*properties);
const Bare_point& surface_center = std::get<2>(*properties);
// Facet is on surface: set facet properties
set_facet_surface_center(facet, surface_center, surface_center_index);
@ -1666,18 +1666,18 @@ compute_facet_properties(const Facet& facet,
Intersection intersect = construct_intersection(segment);
#ifdef CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
// In the following, CGAL::cpp11::get<2>(intersect) == 0 is a way to
// In the following, std::get<2>(intersect) == 0 is a way to
// test "intersect == Intersection()" (aka empty intersection), but
// the later does not work.
Surface_patch surface =
(CGAL::cpp11::get<2>(intersect) == 0) ? Surface_patch() :
(std::get<2>(intersect) == 0) ? Surface_patch() :
Surface_patch(
r_oracle_.surface_patch_index(CGAL::cpp11::get<1>(intersect)));
r_oracle_.surface_patch_index(std::get<1>(intersect)));
if(surface)
#endif // CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
fp = Facet_properties(CGAL::cpp11::make_tuple(*surface,
CGAL::cpp11::get<1>(intersect),
CGAL::cpp11::get<0>(intersect)));
fp = Facet_properties(std::make_tuple(*surface,
std::get<1>(intersect),
std::get<0>(intersect)));
}
}
// If the dual is a ray
@ -1708,15 +1708,15 @@ compute_facet_properties(const Facet& facet,
Intersection intersect = construct_intersection(ray);
#ifdef CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
Surface_patch surface =
(CGAL::cpp11::get<2>(intersect) == 0) ? Surface_patch() :
(std::get<2>(intersect) == 0) ? Surface_patch() :
Surface_patch(
r_oracle_.surface_patch_index(CGAL::cpp11::get<1>(intersect)));
r_oracle_.surface_patch_index(std::get<1>(intersect)));
if(surface)
#endif // CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
{
fp = Facet_properties(CGAL::cpp11::make_tuple(*surface,
CGAL::cpp11::get<1>(intersect),
CGAL::cpp11::get<0>(intersect)));
fp = Facet_properties(std::make_tuple(*surface,
std::get<1>(intersect),
std::get<0>(intersect)));
}
}
}

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

@ -159,9 +159,9 @@ void initialize_triangulation_from_labeled_image(C3T3& c3t3,
const Bare_point test = it->first + v;
const typename Mesh_domain::Intersection intersect =
construct_intersection(Segment_3(it->first, test));
if (CGAL::cpp11::get<2>(intersect) != 0)
if (std::get<2>(intersect) != 0)
{
const Bare_point& bpi = CGAL::cpp11::get<0>(intersect);
const Bare_point& bpi = std::get<0>(intersect);
Weighted_point pi = cwp(bpi);
// This would cause trouble to optimizers
@ -223,7 +223,7 @@ void initialize_triangulation_from_labeled_image(C3T3& c3t3,
}
if (pi_inside_protecting_sphere)
continue;
const typename Mesh_domain::Index index = CGAL::cpp11::get<1>(intersect);
const typename Mesh_domain::Index index = std::get<1>(intersect);
/// The following lines show how to insert initial points in the
/// `c3t3` object. [insert initial points]

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

@ -492,8 +492,8 @@ polylines_to_protect
{
using CGAL::cpp11::array;
using CGAL::cpp11::tuple;
using CGAL::cpp11::get;
using std::tuple;
using std::get;
typedef array<int, 3> Pixel;

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

@ -717,7 +717,7 @@ public:
OutputIterator get_corners(OutputIterator out) const;
/// Implements `MeshDomainWithFeatures_3::get_curves()`.
/// OutputIterator value type is CGAL::cpp11::tuple<Curve_index,
/// OutputIterator value type is std::tuple<Curve_index,
/// std::pair<Point_3,Index>, std::pair<Point_3,Index> >
template <typename OutputIterator>
OutputIterator get_curves(OutputIterator out) const;
@ -971,7 +971,7 @@ get_curves(OutputIterator out) const
q_index = p_index;
}
*out++ = CGAL::cpp11::make_tuple(eit->first,
*out++ = std::make_tuple(eit->first,
std::make_pair(p,p_index),
std::make_pair(q,q_index));
}

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

@ -201,7 +201,7 @@ public:
typedef typename Mesh_3::internal::Index_generator<
Subdomain_index, Surface_patch_index>::type Index;
typedef CGAL::cpp11::tuple<Point_3,Index,int> Intersection;
typedef std::tuple<Point_3,Index,int> Intersection;
typedef typename IGT::FT FT;
@ -835,13 +835,13 @@ Construct_initial_points::operator()(OutputIterator pts,
#ifdef CGAL_MESH_3_NO_LONGER_CALLS_DO_INTERSECT_3
Intersection intersection = r_domain_.construct_intersection_object()(ray_shot);
if(CGAL::cpp0x::get<2>(intersection) != 0) {
if(std::get<2>(intersection) != 0) {
#else
if(r_domain_.do_intersect_surface_object()(ray_shot)) {
Intersection intersection = r_domain_.construct_intersection_object()(ray_shot);
#endif
*pts++ = std::make_pair(CGAL::cpp0x::get<0>(intersection),
CGAL::cpp0x::get<1>(intersection));
*pts++ = std::make_pair(std::get<0>(intersection),
std::get<1>(intersection));
--i;

8
Mesh_3/test/Mesh_3/test_domain_with_polyline_features.cpp
View File

@ -59,7 +59,7 @@ class Domain_with_polyline_tester
typedef std::vector<std::pair<Ci, Point> > Corners_vector;
typedef std::pair<Point, Index> P_and_i;
typedef CGAL::cpp11::tuple<Csi,P_and_i,P_and_i> Curve_tuple;
typedef std::tuple<Csi,P_and_i,P_and_i> Curve_tuple;
typedef std::vector<Curve_tuple> Curves_vector;
public:
@ -202,12 +202,12 @@ private:
Point get_first_point(const Curve_tuple& tuple) const
{
return CGAL::cpp11::get<1>(tuple).first;
return std::get<1>(tuple).first;
}
Point get_second_point(const Curve_tuple& tuple) const
{
return CGAL::cpp11::get<2>(tuple).first;
return std::get<2>(tuple).first;
}
Csi get_curve_index() const
@ -221,7 +221,7 @@ private:
Csi get_curve_index(const Curve_tuple& tuple) const
{
return CGAL::cpp11::get<0>(tuple);
return std::get<0>(tuple);
}
bool near_equal(const double d1, const double d2) const

30
Mesh_3/test/Mesh_3/test_labeled_mesh_domain_3.cpp
View File

@ -212,52 +212,52 @@ private:
{
Segment_3 s(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.));
Intersection i = construct_intersection(s);
assert(CGAL::cpp11::get<0>(i) != Point_3(1., 0., 0.));
Index ii = CGAL::cpp11::get<1>(i);
assert(std::get<0>(i) != Point_3(1., 0., 0.));
Index ii = std::get<1>(i);
assert(boost::get<Surface_patch_index>(&ii));
assert(CGAL::cpp11::get<2>(i) == 2);
assert(std::get<2>(i) == 2);
}
{
Segment_3 s(Point_3(1.5, 1.5, 0.), Point_3(1.5, 0., 0.));
Intersection i = construct_intersection(s);
Index ii = CGAL::cpp11::get<1>(i);
Index ii = std::get<1>(i);
assert(boost::get<Subdomain_index>(&ii));
assert(CGAL::cpp11::get<2>(i) == 0);
assert(std::get<2>(i) == 0);
}
{
Ray_3 r(Point_3(CGAL::ORIGIN), Vector_3(1., 0., 0.));
Intersection i = construct_intersection(r);
assert(CGAL::cpp11::get<0>(i) != Point_3(1., 0., 0.));
Index ii = CGAL::cpp11::get<1>(i);
assert(std::get<0>(i) != Point_3(1., 0., 0.));
Index ii = std::get<1>(i);
assert(boost::get<Surface_patch_index>(&ii));
assert(CGAL::cpp11::get<2>(i) == 2);
assert(std::get<2>(i) == 2);
}
{
Ray_3 r(Point_3(1.5, 0., 0.), Vector_3(0., 1., 0.));
Intersection i = construct_intersection(r);
Index ii = CGAL::cpp11::get<1>(i);
Index ii = std::get<1>(i);
assert(boost::get<Subdomain_index>(&ii));
assert(CGAL::cpp11::get<2>(i) == 0);
assert(std::get<2>(i) == 0);
}
{
Line_3 l(Point_3(CGAL::ORIGIN), Point_3(1.5, 0., 0.));
Intersection i = construct_intersection(l);
assert(CGAL::cpp11::get<0>(i) != Point_3(1., 0., 0.));
Index ii = CGAL::cpp11::get<1>(i);
assert(std::get<0>(i) != Point_3(1., 0., 0.));
Index ii = std::get<1>(i);
assert(boost::get<Surface_patch_index>(&ii));
assert(CGAL::cpp11::get<2>(i) == 2);
assert(std::get<2>(i) == 2);
}
{
Line_3 l(Point_3(1.5, 0., 0.), Point_3(1.5, 0.5, 0.));
Intersection i = construct_intersection(l);
Index ii = CGAL::cpp11::get<1>(i);
Index ii = std::get<1>(i);
assert(boost::get<Subdomain_index>(&ii));
assert(CGAL::cpp11::get<2>(i) == 0);
assert(std::get<2>(i) == 0);
}
}
};

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

@ -43,7 +43,7 @@ template <class Base_> struct Kernel_2_interface : public Base_ {
typedef typename Get_type<Base, Point_tag>::type Point_2;
typedef typename Get_type<Base, Vector_tag>::type Vector_2;
typedef typename Get_type<Base, Segment_tag>::type Segment_2;
typedef cpp0x::tuple<Point_2,Point_2,Point_2> Triangle_2; // triangulation insists...
typedef std::tuple<Point_2,Point_2,Point_2> Triangle_2; // triangulation insists...
template <class T,int i> struct Help_2p_i {
typedef typename Get_functor<Base, T>::type LT;
typedef typename LT::result_type result_type;

4
NewKernel_d/include/CGAL/NewKernel_d/Kernel_3_interface.h
View File

@ -43,8 +43,8 @@ template <class Base_> struct Kernel_3_interface : public Base_ {
typedef typename Get_type<Base, Point_tag>::type Point_3;
typedef typename Get_type<Base, Vector_tag>::type Vector_3;
typedef typename Get_type<Base, Segment_tag>::type Segment_3;
typedef cpp0x::tuple<Point_3,Point_3,Point_3> Triangle_3; // placeholder
typedef cpp0x::tuple<Point_3,Point_3,Point_3,Point_3> Tetrahedron_3; // placeholder
typedef std::tuple<Point_3,Point_3,Point_3> Triangle_3; // placeholder
typedef std::tuple<Point_3,Point_3,Point_3,Point_3> Tetrahedron_3; // placeholder
struct Compare_xyz_3 {
typedef typename Get_functor<Base, Compare_lexicographically_tag>::type CL;
typedef typename CL::result_type result_type;

6
NewKernel_d/include/CGAL/NewKernel_d/utils.h
View File

@ -233,14 +233,14 @@ struct Has_type_different_from <T, No, true>
typename N_increasing_indices<sizeof...(U)>::type());
}
#else
#define CGAL_VAR(Z,N,_) cpp0x::get<N>(t)
#define CGAL_VAR(Z,N,_) std::get<N>(t)
#define CGAL_CODE(Z,N,_) template<class Res, class F BOOST_PP_COMMA_IF(N) BOOST_PP_ENUM_PARAMS(N,class U)> \
inline Res call_on_tuple_elements(F const&f, \
cpp0x::tuple<BOOST_PP_ENUM_PARAMS(N,U)> const&t) { \
std::tuple<BOOST_PP_ENUM_PARAMS(N,U)> const&t) { \
return f(BOOST_PP_ENUM(N,CGAL_VAR,)); \
}
template<class Res, class F>
inline Res call_on_tuple_elements(F const&f, cpp0x::tuple<>) {
inline Res call_on_tuple_elements(F const&f, std::tuple<>) {
return f();
}
BOOST_PP_REPEAT_FROM_TO(1, 8, CGAL_CODE, _ )

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

@ -1678,7 +1678,7 @@ public:
typename PointOutputIterator,
typename IndexOutputIterator,
typename IndexPairOutputIterator>
CGAL::cpp11::tuple<
std::tuple<
PointOutputIterator,
IndexOutputIterator,
IndexPairOutputIterator>
@ -1736,7 +1736,7 @@ public:
*segments++ = std::make_pair(pos_a, pos_b);
}
return CGAL::cpp11::make_tuple(points, isolated_points, segments);
return std::make_tuple(points, isolated_points, segments);
}
/*!

12
Periodic_3_mesh_3/include/CGAL/Periodic_3_mesh_3/Protect_edges_sizing_field.h
View File

@ -1887,7 +1887,7 @@ Protect_edges_sizing_field<C3T3, MD, Sf>::
insert_balls_on_edges()
{
// Get features
typedef CGAL::cpp11::tuple<Curve_index,
typedef std::tuple<Curve_index,
std::pair<Bare_point,Index>,
std::pair<Bare_point,Index> > Feature_tuple;
typedef std::vector<Feature_tuple> Input_features;
@ -1899,18 +1899,18 @@ insert_balls_on_edges()
for(typename Input_features::iterator fit = input_features.begin(),
end = input_features.end() ; fit != end ; ++fit)
{
const Curve_index& curve_index = CGAL::cpp11::get<0>(*fit);
const Curve_index& curve_index = std::get<0>(*fit);
if(! is_treated(curve_index))
{
#if CGAL_MESH_3_PROTECTION_DEBUG & 1
std::cerr << "** treat curve #" << curve_index << std::endl;
std::cerr << "is it a loop? " << domain_.is_loop(curve_index) << std::endl;
#endif
const Bare_point& p = CGAL::cpp11::get<1>(*fit).first;
const Bare_point& q = CGAL::cpp11::get<2>(*fit).first;
const Bare_point& p = std::get<1>(*fit).first;
const Bare_point& q = std::get<2>(*fit).first;
const Index& p_index = CGAL::cpp11::get<1>(*fit).second;
const Index& q_index = CGAL::cpp11::get<2>(*fit).second;
const Index& p_index = std::get<1>(*fit).second;
const Index& q_index = std::get<2>(*fit).second;
Vertex_handle vp,vq;
if(! domain_.is_loop(curve_index))

2
Point_set_processing_3/examples/Point_set_processing_3/read_ply_points_with_colors_example.cpp
View File

@ -14,7 +14,7 @@ typedef Kernel::Vector_3 Vector;
typedef CGAL::cpp11::array<unsigned char, 3> Color;
// Point with normal, color and intensity
typedef CGAL::cpp11::tuple<Point, Vector, Color, int> PNCI;
typedef std::tuple<Point, Vector, Color, int> PNCI;
typedef CGAL::Nth_of_tuple_property_map<0, PNCI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PNCI> Normal_map;
typedef CGAL::Nth_of_tuple_property_map<2, PNCI> Color_map;

4
Point_set_processing_3/examples/Point_set_processing_3/write_ply_points_example.cpp
View File

@ -14,7 +14,7 @@ typedef Kernel::Vector_3 Vector;
typedef CGAL::cpp11::array<unsigned char, 4> Color;
// Point with normal, color and intensity
typedef CGAL::cpp11::tuple<Point, Color, int> PCI;
typedef std::tuple<Point, Color, int> PCI;
typedef CGAL::Nth_of_tuple_property_map<0, PCI> Point_map;
typedef CGAL::Nth_of_tuple_property_map<1, PCI> Color_map;
typedef CGAL::Nth_of_tuple_property_map<2, PCI> Intensity_map;
@ -44,7 +44,7 @@ int main(int, char**)
std::vector<PCI> points; // store points
for (int i = 0; i < 10; ++ i)
points.push_back (CGAL::cpp11::make_tuple (Point (i / 10., i / 20., i / 30.),
points.push_back (std::make_tuple (Point (i / 10., i / 20., i / 30.),
CGAL::make_array ((unsigned char)(255 / (i + 1)),
(unsigned char)(192 / (i + 1)),
(unsigned char)(128 / (i + 1)),

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_mesh_union_and_intersection.cpp
View File

@ -44,7 +44,7 @@ int main(int argc, char* argv[])
output,
params::all_default(), // mesh1 named parameters
params::all_default(), // mesh2 named parameters
CGAL::cpp11::make_tuple(
std::make_tuple(
params::vertex_point_map(get(boost::vertex_point, out_union)), // named parameters for out_union
params::vertex_point_map(get(boost::vertex_point, out_intersection)), // named parameters for out_intersection
params::all_default(), // named parameters for mesh1-mesh2 not used

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example.cpp
View File

@ -32,7 +32,7 @@ int main(int argc, char* argv[])
{
std::vector<Facet_handle> patch_facets;
std::vector<Vertex_handle> patch_vertices;
bool success = CGAL::cpp11::get<0>(
bool success = std::get<0>(
CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(
poly,
h,

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example_LCC.cpp
View File

@ -35,7 +35,7 @@ int main(int argc, char* argv[])
{
std::vector<face_descriptor> patch_facets;
std::vector<vertex_descriptor> patch_vertices;
bool success = CGAL::cpp11::get<0>(
bool success = std::get<0>(
CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(
mesh,
h,

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example_OM.cpp
View File

@ -35,7 +35,7 @@ int main(int argc, char* argv[])
{
std::vector<face_descriptor> patch_facets;
std::vector<vertex_descriptor> patch_vertices;
bool success = CGAL::cpp11::get<0>(
bool success = std::get<0>(
CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(
mesh,
h,

2
Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example_SM.cpp
View File

@ -34,7 +34,7 @@ int main(int argc, char* argv[])
{
std::vector<face_descriptor> patch_facets;
std::vector<vertex_descriptor> patch_vertices;
bool success = CGAL::cpp11::get<0>(
bool success = std::get<0>(
CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(
mesh,
h,

58
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h
View File

@ -255,7 +255,7 @@ bool does_bound_a_volume(const TriangleMesh& tm)
Corefinement::No_mark<TriangleMesh> \
> ::type Ecm_out_##I; \
Ecm_out_##I ecm_out_##I = \
boost::choose_param( boost::get_param(cpp11::get<I>(nps_out), internal_np::edge_is_constrained), \
boost::choose_param( boost::get_param(std::get<I>(nps_out), internal_np::edge_is_constrained), \
Corefinement::No_mark<TriangleMesh>() );
@ -355,7 +355,7 @@ corefine_and_compute_boolean_operations(
const cpp11::array< boost::optional<TriangleMesh*>,4>& output,
const NamedParameters1& np1,
const NamedParameters2& np2,
const cpp11::tuple<NamedParametersOut0,
const std::tuple<NamedParametersOut0,
NamedParametersOut1,
NamedParametersOut2,
NamedParametersOut3>& nps_out)
@ -386,29 +386,29 @@ corefine_and_compute_boolean_operations(
// that is not requested, the default vpm does not have the same value type as the
// input map, a dummy default vpm is used so that calls to get/put can be compiled
// (even if not used).
typedef cpp11::tuple<
typedef std::tuple<
Corefinement::TweakedGetVertexPointMap<Point_3, NamedParametersOut0, TriangleMesh>,
Corefinement::TweakedGetVertexPointMap<Point_3, NamedParametersOut1, TriangleMesh>,
Corefinement::TweakedGetVertexPointMap<Point_3, NamedParametersOut2, TriangleMesh>,
Corefinement::TweakedGetVertexPointMap<Point_3, NamedParametersOut3, TriangleMesh>
> Vpm_out_tuple_helper;
typedef cpp11::tuple<
boost::optional< typename cpp11::tuple_element<0, Vpm_out_tuple_helper>::type::type >,
boost::optional< typename cpp11::tuple_element<1, Vpm_out_tuple_helper>::type::type >,
boost::optional< typename cpp11::tuple_element<2, Vpm_out_tuple_helper>::type::type >,
boost::optional< typename cpp11::tuple_element<3, Vpm_out_tuple_helper>::type::type >
typedef std::tuple<
boost::optional< typename std::tuple_element<0, Vpm_out_tuple_helper>::type::type >,
boost::optional< typename std::tuple_element<1, Vpm_out_tuple_helper>::type::type >,
boost::optional< typename std::tuple_element<2, Vpm_out_tuple_helper>::type::type >,
boost::optional< typename std::tuple_element<3, Vpm_out_tuple_helper>::type::type >
> Vpm_out_tuple;
Vpm_out_tuple vpm_out_tuple(
Corefinement::get_vpm<Point_3>(cpp11::get<0>(nps_out), output[0],
typename cpp11::tuple_element<0, Vpm_out_tuple_helper>::type::Use_default_tag()),
Corefinement::get_vpm<Point_3>(cpp11::get<1>(nps_out), output[1],
typename cpp11::tuple_element<1, Vpm_out_tuple_helper>::type::Use_default_tag()),
Corefinement::get_vpm<Point_3>(cpp11::get<2>(nps_out), output[2],
typename cpp11::tuple_element<2, Vpm_out_tuple_helper>::type::Use_default_tag()),
Corefinement::get_vpm<Point_3>(cpp11::get<3>(nps_out), output[3],
typename cpp11::tuple_element<3, Vpm_out_tuple_helper>::type::Use_default_tag())
Corefinement::get_vpm<Point_3>(std::get<0>(nps_out), output[0],
typename std::tuple_element<0, Vpm_out_tuple_helper>::type::Use_default_tag()),
Corefinement::get_vpm<Point_3>(std::get<1>(nps_out), output[1],
typename std::tuple_element<1, Vpm_out_tuple_helper>::type::Use_default_tag()),
Corefinement::get_vpm<Point_3>(std::get<2>(nps_out), output[2],
typename std::tuple_element<2, Vpm_out_tuple_helper>::type::Use_default_tag()),
Corefinement::get_vpm<Point_3>(std::get<3>(nps_out), output[3],
typename std::tuple_element<3, Vpm_out_tuple_helper>::type::Use_default_tag())
);
if (&tm1==&tm2)
@ -421,13 +421,13 @@ corefine_and_compute_boolean_operations(
copy_face_graph(tm1,
*(*output[Corefinement::UNION]),
parameters::vertex_point_map(vpm1),
parameters::vertex_point_map(*cpp11::get<Corefinement::UNION>(vpm_out_tuple)));
parameters::vertex_point_map(*std::get<Corefinement::UNION>(vpm_out_tuple)));
if (output[Corefinement::INTERSECTION] != boost::none)
if (&tm1 != *output[Corefinement::INTERSECTION])
copy_face_graph(tm1,
*(*output[Corefinement::INTERSECTION]),
parameters::vertex_point_map(vpm1),
parameters::vertex_point_map(*cpp11::get<Corefinement::INTERSECTION>(vpm_out_tuple)));
parameters::vertex_point_map(*std::get<Corefinement::INTERSECTION>(vpm_out_tuple)));
if (output[Corefinement::TM1_MINUS_TM2] != boost::none)
if (&tm1 == *output[Corefinement::TM1_MINUS_TM2])
@ -456,7 +456,7 @@ corefine_and_compute_boolean_operations(
copy_face_graph(tm2,
*(*output[Corefinement::UNION]),
parameters::vertex_point_map(vpm2),
parameters::vertex_point_map(*cpp11::get<Corefinement::UNION>(vpm_out_tuple)));
parameters::vertex_point_map(*std::get<Corefinement::UNION>(vpm_out_tuple)));
if (output[Corefinement::INTERSECTION] != boost::none)
clear(*(*output[Corefinement::INTERSECTION]));
if (output[Corefinement::TM1_MINUS_TM2] != boost::none)
@ -466,7 +466,7 @@ corefine_and_compute_boolean_operations(
copy_face_graph(tm2,
*(*output[Corefinement::TM2_MINUS_TM1]),
parameters::vertex_point_map(vpm2),
parameters::vertex_point_map(*cpp11::get<Corefinement::TM2_MINUS_TM1>(vpm_out_tuple)));
parameters::vertex_point_map(*std::get<Corefinement::TM2_MINUS_TM1>(vpm_out_tuple)));
return CGAL::make_array(true, true, true, true);
}
else
@ -478,7 +478,7 @@ corefine_and_compute_boolean_operations(
copy_face_graph(tm1,
*(*output[Corefinement::UNION]),
parameters::vertex_point_map(vpm1),
parameters::vertex_point_map(*cpp11::get<Corefinement::UNION>(vpm_out_tuple)));
parameters::vertex_point_map(*std::get<Corefinement::UNION>(vpm_out_tuple)));
if (output[Corefinement::INTERSECTION] != boost::none)
clear(*(*output[Corefinement::INTERSECTION]));
if (output[Corefinement::TM2_MINUS_TM1] != boost::none)
@ -488,7 +488,7 @@ corefine_and_compute_boolean_operations(
copy_face_graph(tm1,
*(*output[Corefinement::TM1_MINUS_TM2]),
parameters::vertex_point_map(vpm1),
parameters::vertex_point_map(*cpp11::get<Corefinement::TM1_MINUS_TM2>(vpm_out_tuple)));
parameters::vertex_point_map(*std::get<Corefinement::TM1_MINUS_TM2>(vpm_out_tuple)));
return CGAL::make_array(true, true, true, true);
}
@ -520,7 +520,7 @@ corefine_and_compute_boolean_operations(
CGAL_COREF_SET_OUTPUT_EDGE_MARK_MAP(3)
// In the current version all types must be the same so an array would be fine
typedef cpp11::tuple<Ecm_out_0, Ecm_out_1, Ecm_out_2, Ecm_out_3>
typedef std::tuple<Ecm_out_0, Ecm_out_1, Ecm_out_2, Ecm_out_3>
Edge_mark_map_tuple;
// Face index point maps
@ -598,7 +598,7 @@ corefine_and_compute_boolean_operations(
using namespace CGAL::Polygon_mesh_processing::parameters;
return corefine_and_compute_boolean_operations(tm1, tm2, output,
all_default(), all_default(),
cpp11::make_tuple(all_default(), all_default(),
std::make_tuple(all_default(), all_default(),
all_default(), all_default()));
}
@ -613,7 +613,7 @@ corefine_and_compute_boolean_operations(
using namespace CGAL::Polygon_mesh_processing::parameters;
return corefine_and_compute_boolean_operations(tm1, tm2, output,
np1, all_default(),
cpp11::make_tuple(all_default(), all_default(),
std::make_tuple(all_default(), all_default(),
all_default(), all_default()));
}
@ -629,7 +629,7 @@ corefine_and_compute_boolean_operations(
using namespace CGAL::Polygon_mesh_processing::parameters;
return corefine_and_compute_boolean_operations(tm1, tm2, output,
np1, np2,
cpp11::make_tuple(all_default(), all_default(),
std::make_tuple(all_default(), all_default(),
all_default(), all_default()));
}
@ -720,7 +720,7 @@ corefine_and_compute_union( TriangleMesh& tm1,
return
corefine_and_compute_boolean_operations(tm1, tm2, output, np1, np2,
cpp11::make_tuple(np_out,
std::make_tuple(np_out,
all_default(),
all_default(),
all_default()))
@ -752,7 +752,7 @@ corefine_and_compute_intersection( TriangleMesh& tm1,
return
corefine_and_compute_boolean_operations(tm1, tm2, output, np1, np2,
cpp11::make_tuple(all_default(),
std::make_tuple(all_default(),
np_out,
all_default(),
all_default()))
@ -785,7 +785,7 @@ corefine_and_compute_difference( TriangleMesh& tm1,
return
corefine_and_compute_boolean_operations(tm1, tm2, output, np1, np2,
cpp11::make_tuple(all_default(),
std::make_tuple(all_default(),
all_default(),
np_out,
all_default()))

36
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/Face_graph_output_builder.h
View File

@ -86,7 +86,7 @@ class Face_graph_output_builder
Ecm_bind<TriangleMesh, No_mark<TriangleMesh> >
>::type EdgeMarkMapBind;
typedef typename Default::Get<EdgeMarkMapTuple_,
cpp11::tuple< No_mark<TriangleMesh>,
std::tuple< No_mark<TriangleMesh>,
No_mark<TriangleMesh>,
No_mark<TriangleMesh>,
No_mark<TriangleMesh> > >::type EdgeMarkMapTuple;
@ -292,16 +292,16 @@ class Face_graph_output_builder
switch (tuple_id)
{
case 0:
mark_edges(cpp11::get<0>(edge_mark_maps),edges);
mark_edges(std::get<0>(edge_mark_maps),edges);
break;
case 1:
mark_edges(cpp11::get<1>(edge_mark_maps),edges);
mark_edges(std::get<1>(edge_mark_maps),edges);
break;
case 2:
mark_edges(cpp11::get<2>(edge_mark_maps),edges);
mark_edges(std::get<2>(edge_mark_maps),edges);
break;
default:
mark_edges(cpp11::get<3>(edge_mark_maps),edges);
mark_edges(std::get<3>(edge_mark_maps),edges);
}
}
@ -319,20 +319,20 @@ class Face_graph_output_builder
switch (tuple_id)
{
case 0:
mark_edges(cpp11::get<0>(edge_mark_maps),edges);
mark_edges(std::get<0>(edge_mark_maps),edges);
break;
case 1:
mark_edges(cpp11::get<1>(edge_mark_maps),edges);
mark_edges(std::get<1>(edge_mark_maps),edges);
break;
case 2:
mark_edges(cpp11::get<2>(edge_mark_maps),edges);
mark_edges(std::get<2>(edge_mark_maps),edges);
break;
default:
mark_edges(cpp11::get<3>(edge_mark_maps),edges);
mark_edges(std::get<3>(edge_mark_maps),edges);
}
}
void mark_edges(const cpp11::tuple<No_mark<TriangleMesh>,
void mark_edges(const std::tuple<No_mark<TriangleMesh>,
No_mark<TriangleMesh>,
No_mark<TriangleMesh>,
No_mark<TriangleMesh> >&,
@ -340,7 +340,7 @@ class Face_graph_output_builder
int)
{} // nothing to do
void mark_edges(const cpp11::tuple<No_mark<TriangleMesh>,
void mark_edges(const std::tuple<No_mark<TriangleMesh>,
No_mark<TriangleMesh>,
No_mark<TriangleMesh>,
No_mark<TriangleMesh> >&,
@ -1400,10 +1400,10 @@ public:
BO_type == TM2_MINUS_TM1, BO_type == TM1_MINUS_TM2, \
polylines, \
intersection_edges1, intersection_edges2, \
vpm1, vpm2, *cpp11::get<BO_type>(output_vpms), \
vpm1, vpm2, *std::get<BO_type>(output_vpms), \
marks_on_input_edges.ecm1, \
marks_on_input_edges.ecm2, \
cpp11::get<BO_type>(out_edge_mark_maps), \
std::get<BO_type>(out_edge_mark_maps), \
shared_edges, \
user_visitor \
)
@ -1486,7 +1486,7 @@ public:
vpm1, vpm2, \
marks_on_input_edges.ecm1, \
marks_on_input_edges.ecm2, \
cpp11::get<BO_type>(out_edge_mark_maps), \
std::get<BO_type>(out_edge_mark_maps), \
disconnected_patches_edge_to_tm2_edge, \
user_visitor)
CGAL_COREF_FUNCTION_CALL(inplace_operation_tm1)
@ -1505,7 +1505,7 @@ public:
vpm1, \
marks_on_input_edges.ecm2, \
marks_on_input_edges.ecm1, \
cpp11::get<BO_type>(out_edge_mark_maps), \
std::get<BO_type>(out_edge_mark_maps), \
disconnected_patches_edge_to_tm2_edge, \
user_visitor)
CGAL_COREF_FUNCTION_CALL(inplace_operation_tm2)
@ -1526,7 +1526,7 @@ public:
#define CGAL_COREF_FUNCTION_CALL_DEF(BO_type) \
copy_edge_mark<TriangleMesh>( \
tm1, marks_on_input_edges.ecm1, \
cpp11::get<BO_type>(out_edge_mark_maps))
std::get<BO_type>(out_edge_mark_maps))
CGAL_COREF_FUNCTION_CALL(inplace_operation_tm1)
#undef CGAL_COREF_FUNCTION_CALL_DEF
@ -1614,7 +1614,7 @@ public:
vpm2, \
marks_on_input_edges.ecm1, \
marks_on_input_edges.ecm2, \
cpp11::get<BO_type>(out_edge_mark_maps), \
std::get<BO_type>(out_edge_mark_maps), \
polylines, \
user_visitor \
)
@ -1656,7 +1656,7 @@ public:
vpm1, \
marks_on_input_edges.ecm2, \
marks_on_input_edges.ecm1, \
cpp11::get<BO_type>(out_edge_mark_maps), \
std::get<BO_type>(out_edge_mark_maps), \
polylines, \
user_visitor);
CGAL_COREF_FUNCTION_CALL(inplace_operation_tm2)

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/intersect_triangle_and_segment_3.h
View File

@ -36,7 +36,7 @@ namespace Corefinement{
template<class TriangleMesh,class Point_3>
cpp11::tuple<Intersection_type,
std::tuple<Intersection_type,
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor,
bool,bool>
find_intersection(const Point_3& p, const Point_3& q, //segment
@ -47,7 +47,7 @@ find_intersection(const Point_3& p, const Point_3& q, //segment
{
typedef boost::graph_traits<TriangleMesh> GT;
typedef typename GT::halfedge_descriptor halfedge_descriptor;
typedef cpp11::tuple<Intersection_type,halfedge_descriptor,bool,bool> result_type;
typedef std::tuple<Intersection_type,halfedge_descriptor,bool,bool> result_type;
Orientation ab=orientation(p,q,a,b);
Orientation bc=orientation(p,q,b,c);
@ -88,7 +88,7 @@ find_intersection(const Point_3& p, const Point_3& q, //segment
template<class TriangleMesh, class VertexPointMap>
cpp11::tuple<Intersection_type,
std::tuple<Intersection_type,
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor,
bool,bool>
intersection_type(
@ -101,7 +101,7 @@ intersection_type(
{
typedef boost::graph_traits<TriangleMesh> GT;
typedef typename GT::halfedge_descriptor halfedge_descriptor;
typedef cpp11::tuple<Intersection_type,halfedge_descriptor,bool,bool> result_type;
typedef std::tuple<Intersection_type,halfedge_descriptor,bool,bool> result_type;
typedef typename boost::property_traits<VertexPointMap>::reference Point_ref;
typedef typename boost::property_traits<VertexPointMap>::value_type Point_3;
typedef typename Kernel_traits<Point_3>::Kernel Kernel;

32
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/intersection_impl.h
View File

@ -544,7 +544,7 @@ class Intersection_of_triangle_meshes
{
CGAL_assertion( &tm1 < &tm2 || &tm1==&tm2 );
typedef cpp11::tuple<Intersection_type,
typedef std::tuple<Intersection_type,
Intersection_type,
halfedge_descriptor,
halfedge_descriptor> Key;
@ -573,7 +573,7 @@ class Intersection_of_triangle_meshes
{
Node_id node_id;
bool is_new_node;
cpp11::tie(node_id, is_new_node) =
std::tie(node_id, is_new_node) =
get_or_create_node(ipt,current_node,coplanar_node_map,tm1,tm2);
cpln_nodes.push_back(node_id);
@ -651,14 +651,14 @@ class Intersection_of_triangle_meshes
const TriangleMesh& tm2,
const VertexPointMap& vpm1,
const VertexPointMap& vpm2,
cpp11::tuple<Intersection_type,
std::tuple<Intersection_type,
halfedge_descriptor,
bool,bool> inter_res)
{
if ( cpp11::get<3>(inter_res) ) // is edge target in triangle plane
if ( std::get<3>(inter_res) ) // is edge target in triangle plane
nodes.add_new_node(get(vpm1, target(h_1,tm1)));
else{
if (cpp11::get<3>(inter_res)) // is edge source in triangle plane
if (std::get<3>(inter_res)) // is edge source in triangle plane
nodes.add_new_node(get(vpm1, source(h_1,tm1)));
else
nodes.add_new_node(h_1,f_2,tm1,tm2,vpm1,vpm2);
@ -672,7 +672,7 @@ class Intersection_of_triangle_meshes
const VertexPointMap& vpm2,
Node_id& current_node)
{
typedef cpp11::tuple<Intersection_type, halfedge_descriptor, bool,bool> Inter_type;
typedef std::tuple<Intersection_type, halfedge_descriptor, bool,bool> Inter_type;
for(typename Edge_to_faces::iterator it=tm1_edge_to_tm2_faces.begin();
@ -685,16 +685,16 @@ class Intersection_of_triangle_meshes
face_descriptor f_2=*fset.begin();
Inter_type res=intersection_type(h_1,f_2,tm1,tm2,vpm1,vpm2);
Intersection_type type=cpp11::get<0>(res);
Intersection_type type=std::get<0>(res);
//handle degenerate case: one extremity of edge belong to f_2
std::vector<halfedge_descriptor> all_edges;
if ( cpp11::get<3>(res) ) // is edge target in triangle plane
if ( std::get<3>(res) ) // is edge target in triangle plane
std::copy(halfedges_around_target(h_1,tm1).first,
halfedges_around_target(h_1,tm1).second,
std::back_inserter(all_edges));
else{
if ( cpp11::get<2>(res) ) // is edge source in triangle plane
if ( std::get<2>(res) ) // is edge source in triangle plane
std::copy(halfedges_around_source(h_1,tm1).first,
halfedges_around_source(h_1,tm1).second,
std::back_inserter(all_edges));
@ -706,7 +706,7 @@ class Intersection_of_triangle_meshes
// #ifdef USE_DETECTION_MULTIPLE_DEFINED_EDGES
// check_coplanar_edges(std::next(all_edges.begin()),
// all_edges.end(),CGAL::cpp11::get<1>(res),type);
// all_edges.end(),std::get<1>(res),type);
// #endif
typename std::vector<halfedge_descriptor>::iterator it_edge=all_edges.begin();
@ -725,11 +725,11 @@ class Intersection_of_triangle_meshes
// Case when the edge pierces the face in its interior.
case ON_FACE:
{
CGAL_assertion(f_2==face(cpp11::get<1>(res),tm2));
CGAL_assertion(f_2==face(std::get<1>(res),tm2));
Node_id node_id=++current_node;
add_new_node(h_1,f_2,tm1,tm2,vpm1,vpm2,res);
visitor.new_node_added(node_id,ON_FACE,h_1,halfedge(f_2,tm2),tm1,tm2,CGAL::cpp11::get<3>(res),CGAL::cpp11::get<2>(res));
visitor.new_node_added(node_id,ON_FACE,h_1,halfedge(f_2,tm2),tm1,tm2,std::get<3>(res),std::get<2>(res));
for (;it_edge!=all_edges.end();++it_edge){
add_intersection_point_to_face_and_all_edge_incident_faces(f_2,*it_edge,tm2,tm1,node_id);
//erase face from the list to test intersection with it_edge
@ -749,8 +749,8 @@ class Intersection_of_triangle_meshes
{
Node_id node_id=++current_node;
add_new_node(h_1,f_2,tm1,tm2,vpm1,vpm2,res);
halfedge_descriptor h_2=cpp11::get<1>(res);
visitor.new_node_added(node_id,ON_EDGE,h_1,h_2,tm1,tm2,cpp11::get<3>(res),cpp11::get<2>(res));
halfedge_descriptor h_2=std::get<1>(res);
visitor.new_node_added(node_id,ON_EDGE,h_1,h_2,tm1,tm2,std::get<3>(res),std::get<2>(res));
for (;it_edge!=all_edges.end();++it_edge){
if ( it_edge!=all_edges.begin() ){
typename Edge_to_faces::iterator it_ets=tm1_edge_to_tm2_faces.find(edge(*it_edge,tm1));
@ -766,10 +766,10 @@ class Intersection_of_triangle_meshes
case ON_VERTEX:
{
Node_id node_id=++current_node;
halfedge_descriptor h_2=cpp11::get<1>(res);
halfedge_descriptor h_2=std::get<1>(res);
nodes.add_new_node(get(vpm2, target(h_2,tm2))); //we use the original vertex to create the node
//before it was ON_FACE but do not remember why, probably a bug...
visitor.new_node_added(node_id,ON_VERTEX,h_1,h_2,tm1,tm2,cpp11::get<3>(res),cpp11::get<2>(res));
visitor.new_node_added(node_id,ON_VERTEX,h_1,h_2,tm1,tm2,std::get<3>(res),std::get<2>(res));
for (;it_edge!=all_edges.end();++it_edge){
if ( it_edge!=all_edges.begin() ){
typename Edge_to_faces::iterator it_ets=tm1_edge_to_tm2_faces.find(edge(*it_edge,tm1));

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h
View File

@ -349,7 +349,7 @@ struct Polygon_soup_orienter
do{
P_ID other_p_id;
cpp11::tie(next, other_p_id) = next_cw_vertex_around_source(v_id, next, polygons, edges, marked_edges);
std::tie(next, other_p_id) = next_cw_vertex_around_source(v_id, next, polygons, edges, marked_edges);
if (next==v_id) break;
visited_polygons.insert(other_p_id);
if( !first_pass)
@ -362,7 +362,7 @@ struct Polygon_soup_orienter
next = neighbors[0];
do{
P_ID other_p_id;
cpp11::tie(next, other_p_id) = next_ccw_vertex_around_target(next, v_id, polygons, edges, marked_edges);
std::tie(next, other_p_id) = next_ccw_vertex_around_target(next, v_id, polygons, edges, marked_edges);
if (next==v_id) break;
visited_polygons.insert(other_p_id);
if( !first_pass)
@ -417,7 +417,7 @@ struct Polygon_soup_orienter
do{
P_ID other_p_id;
cpp11::tie(next, other_p_id) = next_cw_vertex_around_source(v_id, next, polygons, edges, marked_edges);
std::tie(next, other_p_id) = next_cw_vertex_around_source(v_id, next, polygons, edges, marked_edges);
if (next==v_id) break;
visited_polygons.insert(other_p_id);
}
@ -428,7 +428,7 @@ struct Polygon_soup_orienter
next = neighbors[0];
do{
P_ID other_p_id;
cpp11::tie(next, other_p_id) = next_ccw_vertex_around_target(next, v_id, polygons, edges, marked_edges);
std::tie(next, other_p_id) = next_ccw_vertex_around_target(next, v_id, polygons, edges, marked_edges);
if (next==v_id) break;
visited_polygons.insert(other_p_id);
}

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h
View File

@ -2462,7 +2462,7 @@ bool remove_self_intersections(TriangleMesh& tm, const NamedParameters& np)
break;
}
cpp11::tie(all_fixed, topology_issue) =
std::tie(all_fixed, topology_issue) =
remove_self_intersections_one_step(tm, faces_to_remove, vpm, step, preserve_genus, verbose);
if (all_fixed && topology_issue)
{

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h
View File

@ -107,7 +107,7 @@ void fill_pairs(const Halfedge& he,
{
typename Border_halfedge_map::iterator set_it;
bool insertion_ok;
CGAL::cpp11::tie(set_it, insertion_ok)
std::tie(set_it, insertion_ok)
= border_halfedge_map.insert(std::make_pair(he,std::make_pair(1,0)));
if ( !insertion_ok ){ // we found already a halfedge with the points

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h
View File

@ -246,7 +246,7 @@ namespace Polygon_mesh_processing {
typename FaceOutputIterator,
typename VertexOutputIterator,
typename NamedParameters>
CGAL::cpp11::tuple<bool, FaceOutputIterator, VertexOutputIterator>
std::tuple<bool, FaceOutputIterator, VertexOutputIterator>
triangulate_refine_and_fair_hole(PolygonMesh& pmesh,
typename boost::graph_traits<PolygonMesh>::halfedge_descriptor border_halfedge,
FaceOutputIterator face_out,
@ -267,13 +267,13 @@ namespace Polygon_mesh_processing {
bool fair_success = fair(pmesh, patch, np);
vertex_out = std::copy(patch.begin(), patch.end(), vertex_out);
return CGAL::cpp11::make_tuple(fair_success, face_out, vertex_out);
return std::make_tuple(fair_success, face_out, vertex_out);
}
template<typename PolygonMesh,
typename FaceOutputIterator,
typename VertexOutputIterator>
CGAL::cpp11::tuple<bool, FaceOutputIterator, VertexOutputIterator>
std::tuple<bool, FaceOutputIterator, VertexOutputIterator>
triangulate_refine_and_fair_hole(PolygonMesh& pmesh,
typename boost::graph_traits<PolygonMesh>::halfedge_descriptor border_halfedge,
FaceOutputIterator face_out,

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_slicer.h
View File

@ -239,7 +239,7 @@ class Polygon_mesh_slicer
if (face(hd, m_tmesh)!=graph_traits::null_face())
{
cpp11::tie(itm, new_insertion) =
std::tie(itm, new_insertion) =
al_edge_map.insert( std::pair< halfedge_descriptor, AL_vertex_pair >
(hd, AL_vertex_pair(vd, AL_graph::null_vertex())) );
if (!new_insertion)
@ -255,7 +255,7 @@ class Polygon_mesh_slicer
hd=opposite(hd, m_tmesh);
if (face(hd, m_tmesh)!=graph_traits::null_face())
{
cpp11::tie(itm, new_insertion) =
std::tie(itm, new_insertion) =
al_edge_map.insert( std::pair< halfedge_descriptor, AL_vertex_pair >
(hd, AL_vertex_pair(vd, AL_graph::null_vertex())) );
if (!new_insertion)
@ -460,7 +460,7 @@ public:
// Each coplanar edge is connecting two nodes
// handle source
cpp11::tie(it_insert1, is_new) =
std::tie(it_insert1, is_new) =
vertices.insert(
Vertex_pair(
source(ed,m_tmesh), AL_graph::null_vertex()
@ -472,7 +472,7 @@ public:
al_graph[it_insert1->second]=it_insert1->first;
}
// handle target
cpp11::tie(it_insert2, is_new) =
std::tie(it_insert2, is_new) =
vertices.insert(
Vertex_pair(
target(ed,m_tmesh), AL_graph::null_vertex()

2
Polygon_mesh_processing/test/Polygon_mesh_processing/test_corefinement_and_constraints.cpp
View File

@ -174,7 +174,7 @@ void test_bool_op_no_copy(
output,
params::edge_is_constrained_map(ecm1),
params::edge_is_constrained_map(ecm2),
CGAL::cpp11::make_tuple(params::edge_is_constrained_map(ecm_out_union),
std::make_tuple(params::edge_is_constrained_map(ecm_out_union),
params::edge_is_constrained_map(ecm_out_inter),
params::no_parameters(params::edge_is_constrained_map(ecm_out_union)),
params::no_parameters(params::edge_is_constrained_map(ecm_out_union))));

4
Polyhedron/demo/Polyhedron/Plugins/PMP/Hole_filling_plugin.cpp
View File

@ -667,7 +667,7 @@ bool Polyhedron_demo_hole_filling_plugin::fill
bool success;
if(weight_index == 0) {
success = CGAL::cpp11::get<0>(CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(poly,
success = std::get<0>(CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(poly,
it, std::back_inserter(patch), CGAL::Emptyset_iterator(),
CGAL::Polygon_mesh_processing::parameters::weight_calculator
(CGAL::internal::Uniform_weight_fairing<Face_graph>(poly)).
@ -676,7 +676,7 @@ bool Polyhedron_demo_hole_filling_plugin::fill
use_delaunay_triangulation(use_DT)));
}
else {
success = CGAL::cpp11::get<0>(CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(poly,
success = std::get<0>(CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole(poly,
it, std::back_inserter(patch), CGAL::Emptyset_iterator(),
CGAL::Polygon_mesh_processing::parameters::weight_calculator(CGAL::internal::Cotangent_weight_with_voronoi_area_fairing<Face_graph>(poly)).
density_control_factor(alpha).

4
Polyhedron/demo/Polyhedron/Plugins/PMP/Orient_soup_plugin.cpp
View File

@ -350,7 +350,7 @@ void Polyhedron_demo_orient_soup_plugin::getNMPoints(
do{
std::size_t other_p_id;
CGAL::cpp11::tie(next, other_p_id) = PSO::next_cw_vertex_around_source(v_id, next, item->polygons(), edges, m_edges);
std::tie(next, other_p_id) = PSO::next_cw_vertex_around_source(v_id, next, item->polygons(), edges, m_edges);
if (next==v_id) break;
visited_polygons.insert(other_p_id);
}
@ -361,7 +361,7 @@ void Polyhedron_demo_orient_soup_plugin::getNMPoints(
next = neighbors[0];
do{
std::size_t other_p_id;
CGAL::cpp11::tie(next, other_p_id) = PSO::next_ccw_vertex_around_target(next, v_id, item->polygons(), edges, m_edges);
std::tie(next, other_p_id) = PSO::next_ccw_vertex_around_target(next, v_id, item->polygons(), edges, m_edges);
if (next==v_id) break;
visited_polygons.insert(other_p_id);
}

4
Polyhedron_IO/include/CGAL/IO/PLY_reader.h
View File

@ -58,7 +58,7 @@ namespace CGAL{
return false;
}
cpp11::tuple<std::vector<Integer>, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_face;
std::tuple<std::vector<Integer>, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_face;
if (has_colors)
{
@ -225,7 +225,7 @@ namespace CGAL{
return false;
}
cpp11::tuple<Point_3, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_vertex;
std::tuple<Point_3, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_vertex;
if (has_colors)
{

2
Property_map/include/CGAL/property_map.h
View File

@ -347,7 +347,7 @@ struct Nth_of_tuple_property_map<N,std::tuple<T...> >
{
typedef std::tuple<T...> Tuple;
typedef Tuple key_type;
typedef typename cpp11::tuple_element<N,Tuple>::type value_type;
typedef typename std::tuple_element<N,Tuple>::type value_type;
typedef const value_type& reference;
typedef boost::lvalue_property_map_tag category;

8
STL_Extension/doc/STL_Extension/CGAL/iterator.h
View File

@ -115,8 +115,8 @@ must be a subset of the parameters of `V`. Should the
\cgalHeading{Parameters}
\tparam V must be a `CGAL::cpp11::tuple<...>` of the types of values to be accepted and dispatched.
\tparam O must be a `CGAL::cpp11::tuple<...>` of the types of corresponding output iterators.
\tparam V must be a `std::tuple<...>` of the types of values to be accepted and dispatched.
\tparam O must be a `std::tuple<...>` of the types of corresponding output iterators.
\cgalModels `OutputIterator`
@ -205,8 +205,8 @@ can be a list of arbitrary types.
\cgalHeading{Parameters}
\tparam V must be a `CGAL::cpp11::tuple<...>` of the types of values to be accepted and dispatched.
\tparam O must be a `CGAL::cpp11::tuple<...>` of the types of corresponding output iterators.
\tparam V must be a `std::tuple<...>` of the types of values to be accepted and dispatched.
\tparam O must be a `std::tuple<...>` of the types of corresponding output iterators.
\cgalModels `OutputIterator`

43
STL_Extension/doc/STL_Extension/CGAL/tuple.h
View File

@ -1,43 +0,0 @@
namespace CGAL {
namespace cpp11 {
/*!
\ingroup PkgSTLExtensionRef
An object of the class `cpp11::tuple` represents a heterogeneous tuple of elements
of the types specified in parameters, which are in variadic number.
There is actually no class in namespace `CGAL::cpp11` with this name, but a using declaration which
imports a class from another namespace. By order of priority: the one in namespace
`std` is used (provided by C++0x), if not found, then the one in namespace
`std::tr1` is used (provided by TR1), and finally, the fallback solution
is taken from Boost.
\cgalHeading{Parameters}
The parameters `...` are the value types.
\cgalHeading{Free functions and helper classes}
Some free functions part of the standard interface of `tuple` are also
brought in namespace `CGAL::cpp11` with using declarations, these are `make_tuple`,
`get`, `tie`. Like in C++0x, the `get` function template is
specialized so that it can take `std::pair` as argument.
Two standard helper classes are also provided for convenience (`tuple_size` and `tuple_element`).
*/
template< typename ... >
class tuple {
public:
}; /* end cpp11::tuple */
} /* end namespace cpp11 */
} /* end namespace CGAL */

4
STL_Extension/doc/STL_Extension/CGAL/utility.h
View File

@ -14,7 +14,7 @@ model of container, though, because it does not support the standard
methods (such as iterators) for accessing the elements of a
container.
`CGAL::cpp11::tuple` or `CGAL::cpp11::array` instead for new uses.
`std::tuple` or `CGAL::cpp11::array` instead for new uses.
@ -237,7 +237,7 @@ elements. It is not actually a model of container, though, because
it does not support the standard methods (such as iterators) for
accessing the elements of a container.
`CGAL::cpp11::tuple` or `CGAL::cpp11::array` instead for new uses.
`std::tuple` or `CGAL::cpp11::array` instead for new uses.

4
STL_Extension/examples/STL_Extension/Dispatch_output_iterator.cpp
View File

@ -10,8 +10,8 @@ int main()
std::vector<char> c;
typedef CGAL::Dispatch_output_iterator<
CGAL::cpp0x::tuple<int, double, char>,
CGAL::cpp0x::tuple<std::back_insert_iterator< std::vector<int> >,
std::tuple<int, double, char>,
std::tuple<std::back_insert_iterator< std::vector<int> >,
std::back_insert_iterator< std::vector<double> >,
std::back_insert_iterator< std::vector<char> >
> > Dispatch;

44
STL_Extension/include/CGAL/iterator.h
View File

@ -1286,7 +1286,7 @@ struct Output_visitor : boost::static_visitor<OutputIterator&> {
namespace internal {
template < typename D, typename V = cpp11::tuple<>, typename O = cpp11::tuple<> >
template < typename D, typename V = std::tuple<>, typename O = std::tuple<> >
struct Derivator
{
typedef Derivator<D, V, O> Self;
@ -1297,11 +1297,11 @@ struct Derivator
};
template < typename D, typename V1, typename O1, typename... V, typename... O>
struct Derivator<D, cpp11::tuple<V1, V...>, cpp11::tuple<O1, O...> >
: public Derivator<D, cpp11::tuple<V...>, cpp11::tuple<O...> >
struct Derivator<D, std::tuple<V1, V...>, std::tuple<O1, O...> >
: public Derivator<D, std::tuple<V...>, std::tuple<O...> >
{
typedef Derivator<D, cpp11::tuple<V1, V...>, cpp11::tuple<O1, O...> > Self;
typedef Derivator<D, cpp11::tuple<V...>, cpp11::tuple<O...> > Base;
typedef Derivator<D, std::tuple<V1, V...>, std::tuple<O1, O...> > Self;
typedef Derivator<D, std::tuple<V...>, std::tuple<O...> > Base;
Self& operator=(const Self&) = delete;
@ -1309,15 +1309,15 @@ struct Derivator<D, cpp11::tuple<V1, V...>, cpp11::tuple<O1, O...> >
D& operator=(const V1& v)
{
* cpp11::get< D::size - sizeof...(V) - 1 >(static_cast<typename D::Iterator_tuple&>(static_cast<D&>(*this))) ++ = v;
* std::get< D::size - sizeof...(V) - 1 >(static_cast<typename D::Iterator_tuple&>(static_cast<D&>(*this))) ++ = v;
return static_cast<D&>(*this);
}
template <class Tuple>
void tuple_dispatch(const Tuple& t)
{
* cpp11::get< D::size - sizeof...(V) - 1 >(static_cast<typename D::Iterator_tuple&>(static_cast<D&>(*this))) ++ =
cpp11::get< D::size - sizeof...(V) - 1 >(t);
* std::get< D::size - sizeof...(V) - 1 >(static_cast<typename D::Iterator_tuple&>(static_cast<D&>(*this))) ++ =
std::get< D::size - sizeof...(V) - 1 >(t);
static_cast<Base&>(*this).tuple_dispatch(t);
}
};
@ -1331,9 +1331,9 @@ template < typename V, typename O >
class Dispatch_output_iterator;
template < typename... V, typename... O >
class Dispatch_output_iterator < cpp11::tuple<V...>, cpp11::tuple<O...> >
: private internal::Derivator<Dispatch_output_iterator< cpp11::tuple<V...>, cpp11::tuple<O...> >, cpp11::tuple<V...>, cpp11::tuple<O...> >
, public cpp11::tuple<O...>
class Dispatch_output_iterator < std::tuple<V...>, std::tuple<O...> >
: private internal::Derivator<Dispatch_output_iterator< std::tuple<V...>, std::tuple<O...> >, std::tuple<V...>, std::tuple<O...> >
, public std::tuple<O...>
{
CGAL_static_assertion_msg(sizeof...(V) == sizeof...(O),
"The number of explicit template parameters has to match the number of arguments");
@ -1345,8 +1345,8 @@ class Dispatch_output_iterator < cpp11::tuple<V...>, cpp11::tuple<O...> >
public:
typedef cpp11::tuple<O...> Iterator_tuple;
typedef cpp11::tuple<V...> Value_type_tuple;
typedef std::tuple<O...> Iterator_tuple;
typedef std::tuple<V...> Value_type_tuple;
typedef std::output_iterator_tag iterator_category;
typedef void value_type;
@ -1364,7 +1364,7 @@ public:
using Base::operator=;
using Base::tuple_dispatch;
Dispatch_output_iterator(O... o) : cpp11::tuple<O...>(o...) {}
Dispatch_output_iterator(O... o) : std::tuple<O...>(o...) {}
Dispatch_output_iterator(const Dispatch_output_iterator&)=default;
@ -1403,7 +1403,7 @@ public:
const Iterator_tuple& get_iterator_tuple() const { return *this; }
Self& operator=(const cpp11::tuple<V...>& t)
Self& operator=(const std::tuple<V...>& t)
{
tuple_dispatch(t);
return *this;
@ -1411,10 +1411,10 @@ public:
};
template < typename... V, typename... O>
Dispatch_output_iterator<cpp11::tuple<V...>, cpp11::tuple<O...> >
Dispatch_output_iterator<std::tuple<V...>, std::tuple<O...> >
dispatch_output(O... o)
{
return Dispatch_output_iterator<cpp11::tuple<V...>, cpp11::tuple<O...> > (o...);
return Dispatch_output_iterator<std::tuple<V...>, std::tuple<O...> > (o...);
}
@ -1425,11 +1425,11 @@ template < typename V, typename O >
class Dispatch_or_drop_output_iterator;
template < typename... V, typename... O >
class Dispatch_or_drop_output_iterator < cpp11::tuple<V...>, cpp11::tuple<O...> >
: public Dispatch_output_iterator< cpp11::tuple<V...>, cpp11::tuple<O...> >
class Dispatch_or_drop_output_iterator < std::tuple<V...>, std::tuple<O...> >
: public Dispatch_output_iterator< std::tuple<V...>, std::tuple<O...> >
{
typedef Dispatch_or_drop_output_iterator Self;
typedef Dispatch_output_iterator< cpp11::tuple<V...>, cpp11::tuple<O...> > Base;
typedef Dispatch_output_iterator< std::tuple<V...>, std::tuple<O...> > Base;
template <typename D, typename V_, typename O_>
friend struct internal::Derivator;
@ -1454,10 +1454,10 @@ public:
template < typename... V, typename... O>
inline
Dispatch_or_drop_output_iterator<cpp11::tuple<V...>, cpp11::tuple<O...> >
Dispatch_or_drop_output_iterator<std::tuple<V...>, std::tuple<O...> >
dispatch_or_drop_output(O... o)
{
return Dispatch_or_drop_output_iterator<cpp11::tuple<V...>, cpp11::tuple<O...> >(o...);
return Dispatch_or_drop_output_iterator<std::tuple<V...>, std::tuple<O...> >(o...);
}
} //namespace CGAL

201
STL_Extension/include/CGAL/tuple.h
View File

@ -21,225 +21,32 @@
#ifndef CGAL_TUPLE_H
#define CGAL_TUPLE_H
// A wrapper around C++0x, TR1 or Boost tuple<>.
// Together with the Is_in_tuple<> tool.
#include <CGAL/config.h>
// workaround issue in the tuple implementation of libc++
// by falling back onto boost's
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
#include <cstddef>
#if defined( _LIBCPP_VERSION ) // check if libc++ is used
#define CGAL_CFG_NO_CPP0X_TUPLE
#endif
#if !defined(__clang__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ <= 4) && (__GNUC_MINOR__ <= 4)
#define CGAL_CFG_NO_CPP0X_TUPLE
#define CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
#endif
#endif
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
# include <tuple>
#else
# include <boost/tuple/tuple.hpp>
# include <boost/tuple/tuple_comparison.hpp>
# include <utility>
#endif
namespace CGAL {
namespace cpp11 {
#ifndef CGAL_CFG_NO_CPP0X_TUPLE
using std::tuple;
using std::make_tuple;
using std::tie;
using std::get;
using std::tuple_size;
using std::tuple_element;
#else
using boost::tuple;
using boost::make_tuple;
using boost::tie;
using boost::get;
//tuple_size
template <class T>
struct tuple_size:public boost::tuples::length<T> {};
//tuple_element
template <int N,class T>
struct tuple_element: public boost::tuples::element<N,T>{};
#endif
#if defined(CGAL_CFG_NO_CPP0X_TUPLE)
// If not C++11 tuple, we need to add get<N>(std::pair).
////////////////////////////////////////////////////////////
// //
// Allow CGAL::cpp11::get<N>(std::pair), if N==0 or N==1. //
// //
// That is already in TR1 and C++11, but not in Boost. //
// //
////////////////////////////////////////////////////////////
template <std::size_t N, typename T1, typename T2>
struct pair_get;
template <typename T1, typename T2>
struct pair_get<0, T1, T2> {
static T1& get(std::pair<T1, T2>& pair) { return pair.first; }
static const T1& get(const std::pair<T1, T2>& pair) { return pair.first; }
}; // end specialization struct pair_get<0, T2, T2>
template <typename T1, typename T2>
struct pair_get<1, T1, T2> {
static T2& get(std::pair<T1, T2>& pair) { return pair.second; }
static const T2& get(const std::pair<T1, T2>& pair) { return pair.second; }
}; // end specialization struct pair_get<0, T2, T2>
template <std::size_t N, typename T1, typename T2>
inline typename boost::tuples::element<N, boost::tuple<T1, T2> >::type&
get(std::pair<T1, T2>& pair) {
return pair_get<N, T1, T2>::get(pair);
}
template <std::size_t N, typename T1, typename T2>
inline const typename boost::tuples::element<N, boost::tuple<T1, T2> >::type&
get(const std::pair<T1, T2>& pair) {
return pair_get<N, T1, T2>::get(pair);
}
#endif // end if not C++11 tuple
} // cpp11
namespace cpp0x = cpp11;
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
// Tool to test whether a type V is among the types of a tuple<...> = T.
template <typename V, typename T>
struct Is_in_tuple;
template <typename V, typename T0, typename... T>
struct Is_in_tuple <V, cpp11::tuple<T0, T...> >
struct Is_in_tuple <V, std::tuple<T0, T...> >
{
static const bool value = Is_in_tuple<V, cpp11::tuple<T...> >::value;
static const bool value = Is_in_tuple<V, std::tuple<T...> >::value;
};
template <typename V, typename... T>
struct Is_in_tuple <V, cpp11::tuple<V, T...> >
struct Is_in_tuple <V, std::tuple<V, T...> >
{
static const bool value = true;
};
template <typename V>
struct Is_in_tuple <V, cpp11::tuple<> >
struct Is_in_tuple <V, std::tuple<> >
{
static const bool value = false;
};
#else
// Non-variadic version
template <typename V,typename T>
struct Is_in_tuple;
template <typename V,typename T0,typename T1>
struct Is_in_tuple <V,cpp11::tuple<T0,T1> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1> >::value;
};
template <typename V, typename T0,typename T1,typename T2>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3,T4> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3,T4> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4,typename T5>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3,T4,T5> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3,T4,T5> >::value;
};
template <typename V, typename T0,typename T1,typename T2,typename T3,typename T4,typename T5,typename T6>
struct Is_in_tuple <V, cpp11::tuple<T0,T1,T2,T3,T4,T5,T6> >
{
static const bool value = Is_in_tuple<V,cpp11::tuple<T1,T2,T3,T4,T5,T6> >::value;
};
//Conclusions
template <typename V,typename T1>
struct Is_in_tuple <V,cpp11::tuple<T1> >
{
static const bool value = false;
};
template <typename V>
struct Is_in_tuple <V,cpp11::tuple<V> >
{
static const bool value = true;
};
template <typename V,typename T1>
struct Is_in_tuple <V,cpp11::tuple<V,T1> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3,typename T4>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3,T4> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3,typename T4,typename T5>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3,T4,T5> >
{
static const bool value = true;
};
template <typename V,typename T1,typename T2,typename T3,typename T4,typename T5,typename T6>
struct Is_in_tuple <V,cpp11::tuple<V,T1,T2,T3,T4,T5,T6> >
{
static const bool value = true;
};
#endif
} //namespace CGAL
#endif // CGAL_TUPLE_H

2
STL_Extension/include/CGAL/utility.h
View File

@ -35,7 +35,7 @@
#include <boost/functional/hash.hpp>
// The Triple and Quadruple classes are NOT RECOMMENDED anymore.
// We recommend that you use cpp11::tuple or cpp11::array instead
// We recommend that you use std::tuple or cpp11::array instead
// for new uses.
namespace CGAL {

16
STL_Extension/test/STL_Extension/test_dispatch_output.cpp
View File

@ -31,12 +31,12 @@ void complete_test(std::vector<T1> data1,std::list<T2> data2){
typedef
CGAL::Dispatch_output_iterator<
CGAL::cpp11::tuple<T1,T2 >,CGAL::cpp11::tuple< T1*,std::back_insert_iterator<std::vector<T2> > >
std::tuple<T1,T2 >,std::tuple< T1*,std::back_insert_iterator<std::vector<T2> > >
> Dispatcher;
typedef
CGAL::Dispatch_or_drop_output_iterator<
CGAL::cpp11::tuple<T1,T2 >,CGAL::cpp11::tuple< T1*,std::back_insert_iterator<std::vector<T2> > >
std::tuple<T1,T2 >,std::tuple< T1*,std::back_insert_iterator<std::vector<T2> > >
> Dropper;
assert(data1.size()==4);
@ -76,12 +76,12 @@ void complete_test(std::vector<T1> data1,std::list<T2> data2){
T1* d;
CGAL::cpp11::tie(d, bck_ins) = disp;
CGAL::cpp11::tie(d, bck_ins) = drop;
std::tie(d, bck_ins) = disp;
std::tie(d, bck_ins) = drop;
//testing putting the tuple directly
CGAL::cpp11::tuple<T1,T2> tuple =
CGAL::cpp11::make_tuple(*data1.begin(), *data2.begin());
std::tuple<T1,T2> tuple =
std::make_tuple(*data1.begin(), *data2.begin());
*disp++ = tuple;
assert(cont_2.size()==2 * data2.size()+1);
@ -97,8 +97,8 @@ void variant_test() {
std::vector<double> b;
std::vector<char> c;
typedef CGAL::Dispatch_output_iterator<
CGAL::cpp0x::tuple<int, double, char>,
CGAL::cpp0x::tuple<std::back_insert_iterator< std::vector<int> >,
std::tuple<int, double, char>,
std::tuple<std::back_insert_iterator< std::vector<int> >,
std::back_insert_iterator< std::vector<double> >,
std::back_insert_iterator< std::vector<char> >
> > Dispatch;

2
STL_Extension/test/STL_Extension/test_namespaces.cpp
View File

@ -17,7 +17,7 @@ int main()
CGAL::cpp11::array<int, 3> arr2;
CGAL::cpp0x::tuple<double, int> tuple;
CGAL::cpp11::tuple<double, int> tuple2;
std::tuple<double, int> tuple2;
CGAL_USE(tuple);
CGAL_USE(tuple2);

36
STL_Extension/test/STL_Extension/test_stl_extension.cpp
View File

@ -8109,19 +8109,19 @@ void test_Quadruple()
}
void test_tuple(){
typedef CGAL::cpp11::tuple<> T0;
typedef CGAL::cpp11::tuple<int,int> T1;
typedef CGAL::cpp11::tuple<int,My_to_int,int,int> T2;
typedef std::tuple<> T0;
typedef std::tuple<int,int> T1;
typedef std::tuple<int,My_to_int,int,int> T2;
CGAL_USE_TYPE(T0);
CGAL_USE_TYPE(T2);
CGAL_static_assertion( CGAL::cpp11::tuple_size<T0>::value == 0 );
CGAL_static_assertion( CGAL::cpp11::tuple_size<T1>::value == 2 );
CGAL_static_assertion( CGAL::cpp11::tuple_size<T2>::value == 4 );
CGAL_static_assertion( (boost::is_same<CGAL::cpp11::tuple_element<1,T2>::type,My_to_int>::value) );
CGAL_static_assertion( std::tuple_size<T0>::value == 0 );
CGAL_static_assertion( std::tuple_size<T1>::value == 2 );
CGAL_static_assertion( std::tuple_size<T2>::value == 4 );
CGAL_static_assertion( (boost::is_same<std::tuple_element<1,T2>::type,My_to_int>::value) );
T1 t1=CGAL::cpp11::make_tuple(1,2);
T1 t1_2=CGAL::cpp11::make_tuple(1,2);
T1 t1=std::make_tuple(1,2);
T1 t1_2=std::make_tuple(1,2);
assert(t1==t1_2); // test the equality operator
@ -8132,21 +8132,21 @@ void test_tuple(){
// GNU/g++ version 4.1.2 does not default-initialize correctly
// std::tr1::tuple.
// Test CGAL::cpp11::tie
// Test std::tie
int i1=-1,i2=-1;
CGAL::cpp11::tie(i1,i2)=t1;
assert( CGAL::cpp11::get<0>(t1)==i1 );
assert( CGAL::cpp11::get<1>(t1)==i2 );
std::tie(i1,i2)=t1;
assert( std::get<0>(t1)==i1 );
assert( std::get<1>(t1)==i2 );
// Test CGAL::cpp11::get for a pair
// Test std::get for a pair
double d = 1;
std::pair<int, double *> pair(-3, &d);
const std::pair<int, double *> const_pair(2, &d);
assert(CGAL::cpp11::get<0>(pair) == -3);
assert(CGAL::cpp11::get<1>(pair) == &d);
assert(CGAL::cpp11::get<0>(const_pair) == 2);
assert(CGAL::cpp11::get<1>(const_pair) == &d);
assert(std::get<0>(pair) == -3);
assert(std::get<1>(pair) == &d);
assert(std::get<0>(const_pair) == 2);
assert(std::get<1>(const_pair) == &d);
}
void test_prev_next()

16
Segment_Delaunay_graph_Linf_2/include/CGAL/Segment_Delaunay_graph_Linf_2/Voronoi_vertex_ring_C2.h
View File

@ -1890,15 +1890,15 @@ private:
// tocheck
const cpp11::tuple<
const std::tuple<
const Site_2 &, const Site_2 &, const Site_2 &> sites =
r_.is_segment() ? sdg_tuple_maker(p_, q_, r_) :
(p_.is_segment() ? sdg_tuple_maker(q_, r_, p_) :
sdg_tuple_maker(r_, p_, q_) );
const Site_2 & p1 = cpp11::get<0>(sites);
const Site_2 & p2 = cpp11::get<1>(sites);
const Site_2 & s = cpp11::get<2>(sites);
const Site_2 & p1 = std::get<0>(sites);
const Site_2 & p2 = std::get<1>(sites);
const Site_2 & s = std::get<2>(sites);
const RT d_fine = (CGAL::min)(CGAL::abs(scalediffdvtx),
CGAL::abs(scalediffdvty));
@ -2039,15 +2039,15 @@ private:
// tocheck
const cpp11::tuple<
const std::tuple<
const Site_2 &, const Site_2 &, const Site_2 &> sites =
p_.is_point() ? sdg_tuple_maker(p_, q_, r_) :
(q_.is_point() ? sdg_tuple_maker(q_, r_, p_) :
sdg_tuple_maker(r_, p_, q_) );
const Site_2 & pt_site = cpp11::get<0>(sites);
const Site_2 & s1 = cpp11::get<1>(sites);
const Site_2 & s2 = cpp11::get<2>(sites);
const Site_2 & pt_site = std::get<0>(sites);
const Site_2 & s1 = std::get<1>(sites);
const Site_2 & s2 = std::get<2>(sites);
const bool is_s1src_s2 = is_endpoint_of(s1.source_site(), s2);
const bool is_s1trg_s2 = is_endpoint_of(s1.target_site(), s2);

54
Segment_Delaunay_graph_Linf_2/include/CGAL/Side_of_bounded_square_2.h
View File

@ -48,10 +48,10 @@ namespace CGAL {
typedef typename K::FT FT;
typedef typename K::Comparison_result Comparison_result;
typedef CGAL::cpp11::tuple<const bool, const bool,
typedef std::tuple<const bool, const bool,
const bool, const bool, const size_t> SmallerEqTuple;
typedef CGAL::cpp11::tuple<FT const *, FT const *,
typedef std::tuple<FT const *, FT const *,
const bool, const bool, const bool,
Point_2 const *, Point_2 const *> MinMaxTuple;
@ -164,7 +164,7 @@ namespace CGAL {
(max_p == &p)? &pt_p : (max_p == &q)? &pt_q : &pt_r;
CGAL_SDG_DEBUG(std::cout << "debug minmax cmppq=" << cmppq
<< " cmppr=" << cmppr << " cmpqr=" << cmpqr << std::endl; );
return CGAL::cpp11::make_tuple(
return std::make_tuple(
min_p, max_p, samepq, samepr, sameqr, pt_min_p, pt_max_p);
}
@ -197,7 +197,7 @@ namespace CGAL {
at_bot = cymint == EQUAL;
if (at_bot) { ++count_eq; }
}
return CGAL::cpp11::make_tuple(
return std::make_tuple(
at_rgt, at_top, at_lft, at_bot, count_eq);
}
@ -214,22 +214,22 @@ namespace CGAL {
//compute the minimum x and maximum x
const FT px (p.x()), qx (q.x()), rx (r.x());
MinMaxTuple tupx = minmax(px, qx, rx, p, q, r);
FT const * lft_p = CGAL::cpp11::get<0>(tupx);
FT const * rgt_p = CGAL::cpp11::get<1>(tupx);
const bool samex_pq = CGAL::cpp11::get<2>(tupx);
const bool samex_pr = CGAL::cpp11::get<3>(tupx);
const bool samex_qr = CGAL::cpp11::get<4>(tupx);
FT const * lft_p = std::get<0>(tupx);
FT const * rgt_p = std::get<1>(tupx);
const bool samex_pq = std::get<2>(tupx);
const bool samex_pr = std::get<3>(tupx);
const bool samex_qr = std::get<4>(tupx);
CGAL_assertion(lft_p != NULL);
CGAL_assertion(rgt_p != NULL);
//compute the minimum y and maximum y
const FT py (p.y()), qy (q.y()), ry (r.y());
MinMaxTuple tupy = minmax(py, qy, ry, p, q, r);
FT const * bot_p = CGAL::cpp11::get<0>(tupy);
FT const * top_p = CGAL::cpp11::get<1>(tupy);
const bool samey_pq = CGAL::cpp11::get<2>(tupy);
const bool samey_pr = CGAL::cpp11::get<3>(tupy);
const bool samey_qr = CGAL::cpp11::get<4>(tupy);
FT const * bot_p = std::get<0>(tupy);
FT const * top_p = std::get<1>(tupy);
const bool samey_pq = std::get<2>(tupy);
const bool samey_pr = std::get<3>(tupy);
const bool samey_qr = std::get<4>(tupy);
CGAL_assertion(bot_p != NULL);
CGAL_assertion(top_p != NULL);
@ -373,10 +373,10 @@ namespace CGAL {
else {
CGAL_assertion( is_bot_input && is_top_input );
Point_2 const * const pt_lft_p =
(is_lft_input)? CGAL::cpp11::get<5>(tupx) : NULL;
(is_lft_input)? std::get<5>(tupx) : NULL;
Point_2 const * const pt_rgt_p =
(is_rgt_input)? CGAL::cpp11::get<6>(tupx) : NULL;
Point_2 const * const pt_top_p = CGAL::cpp11::get<6>(tupy);
(is_rgt_input)? std::get<6>(tupx) : NULL;
Point_2 const * const pt_top_p = std::get<6>(tupy);
if ((pt_top_p != pt_lft_p) && (pt_top_p != pt_rgt_p)) {
// lower the bottom side
fix1 = *top_p - *rgt_p + *lft_p;
@ -385,7 +385,7 @@ namespace CGAL {
}
else {
CGAL_assertion_code(
Point_2 const * const pt_bot_p = CGAL::cpp11::get<5>(tupy);)
Point_2 const * const pt_bot_p = std::get<5>(tupy);)
CGAL_assertion(
(pt_bot_p != pt_lft_p) && (pt_bot_p != pt_rgt_p) );
// augment the top side
@ -420,11 +420,11 @@ namespace CGAL {
}
else {
CGAL_assertion( is_lft_input && is_rgt_input );
Point_2 const * const pt_lft_p = CGAL::cpp11::get<5>(tupx);
Point_2 const * const pt_lft_p = std::get<5>(tupx);
Point_2 const * const pt_bot_p =
(is_bot_input) ? CGAL::cpp11::get<5>(tupy) : NULL;
(is_bot_input) ? std::get<5>(tupy) : NULL;
Point_2 const * const pt_top_p =
(is_top_input) ? CGAL::cpp11::get<6>(tupy) : NULL;
(is_top_input) ? std::get<6>(tupy) : NULL;
// find the movable side or sides of the rectangle
if ((pt_lft_p != pt_bot_p) && (pt_lft_p != pt_top_p)) {
// augment the right side
@ -433,7 +433,7 @@ namespace CGAL {
is_rgt_input = false;
} else {
CGAL_assertion_code(
Point_2 const * const pt_rgt_p = CGAL::cpp11::get<6>(tupx);)
Point_2 const * const pt_rgt_p = std::get<6>(tupx);)
CGAL_assertion(
(pt_rgt_p != pt_bot_p) && (pt_rgt_p != pt_top_p) );
// diminish from the left side
@ -469,7 +469,7 @@ namespace CGAL {
// here, each comparison value is either SMALLER or EQUAL
const SmallerEqTuple tup =
analyze_smalleq(cxtmax, cytmax, cxmint, cymint);
const size_t count_eq = CGAL::cpp11::get<4>(tup);
const size_t count_eq = std::get<4>(tup);
CGAL_assertion( count_eq <= 2 );
if (count_eq == 0) {
CGAL_assertion( cxmint == SMALLER && cxtmax == SMALLER &&
@ -498,7 +498,7 @@ namespace CGAL {
return ON_BOUNDED_SIDE;
}
const bool at_lft = CGAL::cpp11::get<2>(tup);
const bool at_lft = std::get<2>(tup);
if (is_lft_input && at_lft) {
CGAL_assertion(cxmint == EQUAL);
CGAL_SDG_DEBUG(std::cout
@ -512,7 +512,7 @@ namespace CGAL {
}
}
const bool at_rgt = CGAL::cpp11::get<0>(tup);
const bool at_rgt = std::get<0>(tup);
if (is_rgt_input && at_rgt) {
CGAL_assertion(cxtmax == EQUAL);
CGAL_SDG_DEBUG(std::cout
@ -526,7 +526,7 @@ namespace CGAL {
}
}
const bool at_bot = CGAL::cpp11::get<3>(tup);
const bool at_bot = std::get<3>(tup);
if (is_bot_input && at_bot) {
CGAL_assertion(cymint == EQUAL);
CGAL_SDG_DEBUG(std::cout
@ -540,7 +540,7 @@ namespace CGAL {
}
}
const bool at_top = CGAL::cpp11::get<1>(tup);
const bool at_top = std::get<1>(tup);
if (is_top_input && at_top) {
CGAL_assertion(cytmax == EQUAL);
CGAL_SDG_DEBUG(std::cout

20
Spatial_searching/include/CGAL/Orthogonal_incremental_neighbor_search.h
View File

@ -53,7 +53,7 @@ namespace CGAL {
typedef typename Tree::Node_const_handle Node_const_handle;
typedef std::pair<Point_d,FT> Point_with_transformed_distance;
typedef CGAL::cpp11::tuple<Node_const_handle,FT,std::vector<FT> > Node_with_distance;
typedef std::tuple<Node_const_handle,FT,std::vector<FT> > Node_with_distance;
typedef std::vector<Node_with_distance*> Node_with_distance_vector;
typedef std::vector<Point_with_transformed_distance*> Point_with_transformed_distance_vector;
@ -107,7 +107,7 @@ namespace CGAL {
bool
operator() (Node_with_distance* n1, Node_with_distance* n2) const
{
return (search_nearest) ? (CGAL::cpp11::get<1>(*n1) > CGAL::cpp11::get<1>(*n2)) : (CGAL::cpp11::get<1>(*n2) > CGAL::cpp11::get<1>(*n1));
return (search_nearest) ? (std::get<1>(*n1) > std::get<1>(*n2)) : (std::get<1>(*n2) > std::get<1>(*n1));
}
};
@ -173,7 +173,7 @@ namespace CGAL {
PriorityQueue.push(The_Root);
// rd is the distance of the top of the priority queue to q
rd=CGAL::cpp11::get<1>(*The_Root);
rd=std::get<1>(*The_Root);
Compute_the_next_nearest_neighbour();
}
else{
@ -185,7 +185,7 @@ namespace CGAL {
PriorityQueue.push(The_Root);
// rd is the distance of the top of the priority queue to q
rd=CGAL::cpp11::get<1>(*The_Root);
rd=std::get<1>(*The_Root);
Compute_the_next_furthest_neighbour();
}
@ -276,8 +276,8 @@ namespace CGAL {
// otherwise browse the tree further
while ((!next_neighbour_found) && (!PriorityQueue.empty())) {
Node_with_distance* The_node_top=PriorityQueue.top();
Node_const_handle N= CGAL::cpp11::get<0>(*The_node_top);
dists = CGAL::cpp11::get<2>(*The_node_top);
Node_const_handle N= std::get<0>(*The_node_top);
dists = std::get<2>(*The_node_top);
PriorityQueue.pop();
delete The_node_top;
FT copy_rd=rd;
@ -331,7 +331,7 @@ namespace CGAL {
// hence update rd
if (!(PriorityQueue.empty())) {
rd = CGAL::cpp11::get<1>(*PriorityQueue.top());
rd = std::get<1>(*PriorityQueue.top());
next_neighbour_found =
(multiplication_factor*rd >
Item_PriorityQueue.top()->second);
@ -362,8 +362,8 @@ namespace CGAL {
// otherwise browse the tree further
while ((!next_neighbour_found) && (!PriorityQueue.empty())) {
Node_with_distance* The_node_top=PriorityQueue.top();
Node_const_handle N= CGAL::cpp11::get<0>(*The_node_top);
dists = CGAL::cpp11::get<2>(*The_node_top);
Node_const_handle N= std::get<0>(*The_node_top);
dists = std::get<2>(*The_node_top);
PriorityQueue.pop();
delete The_node_top;
FT copy_rd=rd;
@ -416,7 +416,7 @@ namespace CGAL {
// hence update rd
if (!(PriorityQueue.empty())) {
rd = CGAL::cpp11::get<1>(*PriorityQueue.top());
rd = std::get<1>(*PriorityQueue.top());
next_neighbour_found =
(multiplication_factor*rd <
Item_PriorityQueue.top()->second);

4
Surface_mesh/benchmark/lcc_performance_2.h
View File

@ -32,7 +32,7 @@ public:
typedef CGAL::Cell_attribute_with_point<LCC, LCCVector_3, CGAL::Tag_true> Vertex;
typedef CGAL::Cell_attribute<LCC, LCCVector_3, CGAL::Tag_true> Face;
typedef CGAL::cpp0x::tuple<Vertex,void,Face> Attributes;
typedef std::tuple<Vertex,void,Face> Attributes;
};
};
@ -51,7 +51,7 @@ public:
typedef CGAL::Cell_attribute_for_index_with_point<LCC, LCCVector_3, CGAL::Tag_true> Vertex;
typedef CGAL::Cell_attribute_for_index<LCC, LCCVector_3, CGAL::Tag_true> Face;
typedef CGAL::cpp0x::tuple<Vertex,void,Face> Attributes;
typedef std::tuple<Vertex,void,Face> Attributes;
};
};
typedef CGAL::Linear_cell_complex_for_index<2, 3, MyTraitsLCC, MyItemsLCCWithIndex> LCC;

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