replace cpp11::tuple by std::tuple

Alpha_shapes_3/include/CGAL/Alpha_shape_3.h

@@ -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);
+      Dispatch_or_drop_output_iterator<std::tuple<CGAL::Object>, std::tuple<OutputIterator> > out(it);
-      return cpp11::template get<0>( filtration_with_alpha_values(out) );
+      return std::template get<0>( filtration_with_alpha_values(out) );
    }
 
   private: 

BGL/doc/BGL/CGAL/Linear_cell_complex_bgl_min_items.h

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

CGAL_ipelets/demo/CGAL_ipelets/arrangement.cpp

@@ -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(),
+      Curve_2( std::get<0>(*it).center(),
-               sqrt(CGAL::to_double(CGAL::cpp11::get<0>(*it).squared_radius())),
+               sqrt(CGAL::to_double(std::get<0>(*it).squared_radius())),
-               CGAL::cpp11::get<3>(*it),
+               std::get<3>(*it),
-               Traits::Point_2(CGAL::cpp11::get<1>(*it).x(),CGAL::cpp11::get<1>(*it).y()),
+               Traits::Point_2(std::get<1>(*it).x(),std::get<1>(*it).y()),
-               Traits::Point_2(CGAL::cpp11::get<2>(*it).x(),CGAL::cpp11::get<2>(*it).y())
+               Traits::Point_2(std::get<2>(*it).x(),std::get<2>(*it).y())
              )
       );
 

CGAL_ipelets/include/CGAL/CGAL_Ipelet_base_v6.h

@@ -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()),
+      IpeVector ipeS=IpeVector( CGAL::to_double(std::get<1>(arc).x()),
-                                CGAL::to_double(CGAL::cpp11::get<1>(arc).y()));//convert ot ipe format
+                                CGAL::to_double(std::get<1>(arc).y()));//convert ot ipe format
-      IpeVector ipeT=IpeVector( CGAL::to_double(CGAL::cpp11::get<2>(arc).x()),
+      IpeVector ipeT=IpeVector( CGAL::to_double(std::get<2>(arc).x()),
-                                CGAL::to_double(CGAL::cpp11::get<2>(arc).y()));//convert ot ipe format
+                                CGAL::to_double(std::get<2>(arc).y()));//convert ot ipe format
-      SSP_ipe->AppendArc(IpeMatrix(sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),0,
+      SSP_ipe->AppendArc(IpeMatrix(sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),0,
-                                   0,(CGAL::cpp11::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
+                                   0,(std::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
-                                     sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),
+                                     sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),
-                                   CGAL::to_double(CGAL::cpp11::get<0>(arc).center().x()),
+                                   CGAL::to_double(std::get<0>(arc).center().x()),
-                                   CGAL::to_double(CGAL::cpp11::get<0>(arc).center().y())),
+                                   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)?
+      const Point_2* source=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
-                            &CGAL::cpp11::get<1>(object):&CGAL::cpp11::get<2>(object);
+                            &std::get<1>(object):&std::get<2>(object);
-      const Point_2* target=(CGAL::cpp11::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
+      const Point_2* target=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
-                            &CGAL::cpp11::get<2>(object):&CGAL::cpp11::get<1>(object);
+                            &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)?
+        const Point_2* arc_s=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
-                             &CGAL::cpp11::get<1>(*it_arc):&CGAL::cpp11::get<2>(*it_arc);
+                             &std::get<1>(*it_arc):&std::get<2>(*it_arc);
-        const Point_2* arc_t=(CGAL::cpp11::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
+        const Point_2* arc_t=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
-                             &CGAL::cpp11::get<2>(*it_arc):&CGAL::cpp11::get<1>(*it_arc);        
+                             &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 

CGAL_ipelets/include/CGAL/CGAL_Ipelet_base_v7.h

@@ -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()),
+      ipe::Vector ipeS=ipe::Vector( CGAL::to_double(std::get<1>(arc).x()),
-                                CGAL::to_double(CGAL::cpp11::get<1>(arc).y()));//convert ot ipe format
+                                CGAL::to_double(std::get<1>(arc).y()));//convert ot ipe format
-      ipe::Vector ipeT=ipe::Vector( CGAL::to_double(CGAL::cpp11::get<2>(arc).x()),
+      ipe::Vector ipeT=ipe::Vector( CGAL::to_double(std::get<2>(arc).x()),
-                                CGAL::to_double(CGAL::cpp11::get<2>(arc).y()));//convert ot ipe format
+                                CGAL::to_double(std::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,
+      SSP_ipe->appendArc(ipe::Matrix(sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),0,
-                                   0,(CGAL::cpp11::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
+                                   0,(std::get<3>(arc)==CGAL::COUNTERCLOCKWISE?1:-1)*
-                                     sqrt(CGAL::to_double(CGAL::cpp11::get<0>(arc).squared_radius())),
+                                     sqrt(CGAL::to_double(std::get<0>(arc).squared_radius())),
-                                   CGAL::to_double(CGAL::cpp11::get<0>(arc).center().x()),
+                                   CGAL::to_double(std::get<0>(arc).center().x()),
-                                   CGAL::to_double(CGAL::cpp11::get<0>(arc).center().y())),
+                                   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)?
+      const Point_2* source=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
-                            &CGAL::cpp11::get<1>(object):&CGAL::cpp11::get<2>(object);
+                            &std::get<1>(object):&std::get<2>(object);
-      const Point_2* target=(CGAL::cpp11::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
+      const Point_2* target=(std::get<3>(object)==CGAL::COUNTERCLOCKWISE)?
-                            &CGAL::cpp11::get<2>(object):&CGAL::cpp11::get<1>(object);
+                            &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)?
+        const Point_2* arc_s=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
-                             &CGAL::cpp11::get<1>(*it_arc):&CGAL::cpp11::get<2>(*it_arc);
+                             &std::get<1>(*it_arc):&std::get<2>(*it_arc);
-        const Point_2* arc_t=(CGAL::cpp11::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
+        const Point_2* arc_t=(std::get<3>(*it_arc)==CGAL::COUNTERCLOCKWISE)?
-                             &CGAL::cpp11::get<2>(*it_arc):&CGAL::cpp11::get<1>(*it_arc);        
+                             &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 

Combinatorial_map/doc/Combinatorial_map/CGAL/Combinatorial_map.h

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

Combinatorial_map/doc/Combinatorial_map/CGAL/Combinatorial_map_min_items.h

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

Combinatorial_map/doc/Combinatorial_map/Combinatorial_map.txt

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

Combinatorial_map/doc/Combinatorial_map/Concepts/GenericMapItems.h

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

Combinatorial_map/examples/Combinatorial_map/map_3_dynamic_onmerge.cpp

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

Combinatorial_map/examples/Combinatorial_map/map_3_with_colored_facets.cpp

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

Combinatorial_map/include/CGAL/Combinatorial_map.h

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

Combinatorial_map/include/CGAL/Combinatorial_map_min_items.h

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

Combinatorial_map/include/CGAL/Combinatorial_map_storages.h

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

Combinatorial_map/include/CGAL/Dart.h

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

Combinatorial_map/include/CGAL/internal/Combinatorial_map_copy_functors.h

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

Combinatorial_map/include/CGAL/internal/Combinatorial_map_internal_functors.h

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

Combinatorial_map/include/CGAL/internal/Combinatorial_map_utility.h

@@ -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...> >{
+    struct Tuple_converter<Functor,std::tuple<T...> >{
-      typedef CGAL::cpp11::tuple<typename Functor<T>::type... > type;
+      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<>,
+    struct Keep_type_different_of<Type,std::tuple<>,
-                                  CGAL::cpp11::tuple<Res...> >
+                                  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 ...>,
+                                  std::tuple<Type,T ...>,
-                                  CGAL::cpp11::tuple<Res...> >
+                                  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...>,
+    struct Keep_type_different_of<Type,std::tuple<Other,T...>,
-                                  CGAL::cpp11::tuple<Res...> >
+                                  std::tuple<Res...> >
     {
       typedef typename Keep_type_different_of
-      <Type, CGAL::cpp11::tuple<T...>,
+      <Type, std::tuple<T...>,
-       CGAL::cpp11::tuple<Res...,Other> >::type type;
+       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;
       };
 

Combinatorial_map/test/Combinatorial_map/Combinatorial_map_copy_test.cpp

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

Combinatorial_map/test/Combinatorial_map/Combinatorial_map_deprecated_test.cpp

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

Combinatorial_map/test/Combinatorial_map/Combinatorial_map_test.cpp

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

Convex_hull_2/include/CGAL/Convex_hull_2/ch_akl_toussaint_impl.h

@@ -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) +
+  int duplicated_exteme_points =  (std::get<0>(ranges)==std::get<1>(ranges)?1:0) +
-                                  (cpp11::get<1>(ranges)==cpp11::get<2>(ranges)?1:0) +
+                                  (std::get<1>(ranges)==std::get<2>(ranges)?1:0) +
-                                  (cpp11::get<2>(ranges)==cpp11::get<3>(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) )
+    if ( std::get<0>(ranges)!=std::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);
+      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) )
+    if ( std::get<1>(ranges)!=std::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);
+      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) )
+    if ( std::get<2>(ranges)!=std::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);
+      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(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(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(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(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(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(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(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(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(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) \

Generalized_map/doc/Generalized_map/CGAL/Generalized_map.h

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

Generalized_map/doc/Generalized_map/Generalized_map.txt

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

Generalized_map/examples/Generalized_map/gmap_3_dynamic_onmerge.cpp

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

Generalized_map/examples/Generalized_map/gmap_3_with_colored_facets.cpp

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

Generalized_map/include/CGAL/Generalized_map.h

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

Generalized_map/include/CGAL/Generalized_map_storages.h

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

Generalized_map/test/Generalized_map/Generalized_map_test.cpp

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

Intersections_2/benchmark/Intersections_2/variant_any_object.cpp

@@ -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::Dispatch_or_drop_output_iterator<std::tuple<Point,Segment>,
-                                           CGAL::cpp0x::tuple<Iter1,Iter2>
+                                           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) {
+std::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> 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));
       }
     }
   }

Kernel_23/examples/Kernel_23/intersections.cpp

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

Linear_cell_complex/benchmark/Linear_cell_complex_2/lcc_performance_2.h

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

Linear_cell_complex/benchmark/Linear_cell_complex_3/lcc_performance_3.h

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

Linear_cell_complex/demo/Linear_cell_complex/typedefs.h

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

Linear_cell_complex/doc/Linear_cell_complex/CGAL/Linear_cell_complex_min_items.h

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

Linear_cell_complex/examples/Linear_cell_complex/linear_cell_complex_3_with_colored_vertices.cpp

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

Linear_cell_complex/include/CGAL/CMap_linear_cell_complex_storages.h

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

Linear_cell_complex/include/CGAL/GMap_linear_cell_complex_storages.h

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

Linear_cell_complex/include/CGAL/Linear_cell_complex_bgl_min_items.h

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

Linear_cell_complex/include/CGAL/Linear_cell_complex_min_items.h

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

Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_2_test.cpp

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

Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_3_test.cpp

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

Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_4_test.cpp

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

Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_copy_test.cpp

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

Mesh_2/include/CGAL/Constrained_voronoi_diagram_2.h

@@ -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>,
+    std::tuple<Segment, Ray>,
-    CGAL::cpp11::tuple<std::back_insert_iterator<std::vector<Segment> >,
+    std::tuple<std::back_insert_iterator<std::vector<Segment> >,
                        std::back_insert_iterator<std::vector<Ray> > >
     > Construction_dispatcher;
 

Mesh_3/archive/applications/lanteri_utils.h

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

Mesh_3/doc/Mesh_3/Concepts/MeshDomainWithFeatures_3.h

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

Mesh_3/doc/Mesh_3/Concepts/MeshDomain_3.h

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

Mesh_3/examples/Mesh_3/mesh_hybrid_mesh_domain.cpp

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

Mesh_3/include/CGAL/Labeled_mesh_domain_3.h

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

Mesh_3/include/CGAL/Mesh_3/C3T3_helpers.h

@@ -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)
+  if(std::get<2>(intersection) == 2)
-    return CGAL::cpp0x::get<0>(intersection);
+    return std::get<0>(intersection);
   else
     return ref_point;
 

Mesh_3/include/CGAL/Mesh_3/Mesh_global_optimizer.h

@@ -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 Vertex_handle& v = std::get<0>(m_moves[i]);
-        const Vector_3& move = cpp11::get<1>(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 Vertex_handle& v = std::get<0>(*it);
-      const Vector_3& move = cpp11::get<1>(*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()

Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h

@@ -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& p = std::get<1>(*fit).first;
-      const Bare_point& q = CGAL::cpp11::get<2>(*fit).first;
+      const Bare_point& q = std::get<2>(*fit).first;
 
-      const Index& p_index = CGAL::cpp11::get<1>(*fit).second;
+      const Index& p_index = std::get<1>(*fit).second;
-      const Index& q_index = CGAL::cpp11::get<2>(*fit).second;
+      const Index& q_index = std::get<2>(*fit).second;
 
       Vertex_handle vp,vq;
       if ( ! domain_.is_loop(curve_index) )

Mesh_3/include/CGAL/Mesh_3/Refine_facets_3.h

@@ -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_current_erase_counter = std::get<0>(f).first->erase_counter();
-      int f1_saved_erase_counter = CGAL::cpp11::get<1>(f);
+      int f1_saved_erase_counter = std::get<1>(f);
-      int f2_current_erase_counter = CGAL::cpp11::get<2>(f).first->erase_counter();
+      int f2_current_erase_counter = std::get<2>(f).first->erase_counter();
-      int f2_saved_erase_counter = CGAL::cpp11::get<3>(f);
+      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)
+      return (std::get<0>(f).first->erase_counter() == std::get<1>(f)
-        && CGAL::cpp11::get<2>(f).first->erase_counter() == CGAL::cpp11::get<3>(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 Surface_patch_index& surface_index = std::get<0>(*properties);
-      //const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
+      //const Index& surface_center_index = std::get<1>(*properties);
-      //const Bare_point& surface_center = CGAL::cpp11::get<2>(*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 Surface_patch_index& surface_index = std::get<0>(*properties);
-        const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
+        const Index& surface_center_index = std::get<1>(*properties);
-        const Bare_point& surface_center = CGAL::cpp11::get<2>(*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 Surface_patch_index& surface_index = std::get<0>(*properties);
-        const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
+        const Index& surface_center_index = std::get<1>(*properties);
-        const Bare_point& surface_center = CGAL::cpp11::get<2>(*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 Surface_patch_index& surface_index = std::get<0>(*properties);
-    const Index& surface_center_index = CGAL::cpp11::get<1>(*properties);
+    const Index& surface_center_index = std::get<1>(*properties);
-    const Bare_point& surface_center = CGAL::cpp11::get<2>(*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,
+      fp =  Facet_properties(std::make_tuple(*surface,
-                                    CGAL::cpp11::get<1>(intersect),
+                                    std::get<1>(intersect),
-                                    CGAL::cpp11::get<0>(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,
+        fp = Facet_properties(std::make_tuple(*surface,
-                                      CGAL::cpp11::get<1>(intersect),
+                                      std::get<1>(intersect),
-                                      CGAL::cpp11::get<0>(intersect)));
+                                      std::get<0>(intersect)));
       }
     }
   }

Mesh_3/include/CGAL/Mesh_3/initialize_triangulation_from_labeled_image.h

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

Mesh_3/include/CGAL/Mesh_3/polylines_to_protect.h

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

Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h

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

Mesh_3/include/CGAL/Polyhedral_mesh_domain_3.h

@@ -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),
+      *pts++ = std::make_pair(std::get<0>(intersection),
-                              CGAL::cpp0x::get<1>(intersection));
+                              std::get<1>(intersection));
 
       --i;
 

Mesh_3/test/Mesh_3/test_domain_with_polyline_features.cpp

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

Mesh_3/test/Mesh_3/test_labeled_mesh_domain_3.cpp

@@ -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.));
+		  assert(std::get<0>(i) != Point_3(1., 0., 0.));
-		  Index ii = CGAL::cpp11::get<1>(i);
+		  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.));
+		  assert(std::get<0>(i) != Point_3(1., 0., 0.));
-		  Index ii = CGAL::cpp11::get<1>(i);
+		  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.));
+		  assert(std::get<0>(i) != Point_3(1., 0., 0.));
-		  Index ii = CGAL::cpp11::get<1>(i);
+		  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);
 	  }
   }
 };

NewKernel_d/include/CGAL/NewKernel_d/Kernel_2_interface.h

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

NewKernel_d/include/CGAL/NewKernel_d/Kernel_3_interface.h

@@ -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 std::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,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;

NewKernel_d/include/CGAL/NewKernel_d/utils.h

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

Optimal_transportation_reconstruction_2/include/CGAL/Optimal_transportation_reconstruction_2.h

@@ -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);
   }
 
   /*!

Periodic_3_mesh_3/include/CGAL/Periodic_3_mesh_3/Protect_edges_sizing_field.h

@@ -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& p = std::get<1>(*fit).first;
-      const Bare_point& q = CGAL::cpp11::get<2>(*fit).first;
+      const Bare_point& q = std::get<2>(*fit).first;
 
-      const Index& p_index = CGAL::cpp11::get<1>(*fit).second;
+      const Index& p_index = std::get<1>(*fit).second;
-      const Index& q_index = CGAL::cpp11::get<2>(*fit).second;
+      const Index& q_index = std::get<2>(*fit).second;
 
       Vertex_handle vp,vq;
       if(! domain_.is_loop(curve_index))

Point_set_processing_3/examples/Point_set_processing_3/read_ply_points_with_colors_example.cpp

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

Point_set_processing_3/examples/Point_set_processing_3/write_ply_points_example.cpp

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

Polygon_mesh_processing/examples/Polygon_mesh_processing/corefinement_mesh_union_and_intersection.cpp

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

Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example.cpp

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

Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example_LCC.cpp

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

Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example_OM.cpp

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

Polygon_mesh_processing/examples/Polygon_mesh_processing/hole_filling_example_SM.cpp

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h

@@ -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<
+  typedef std::tuple<
-    boost::optional< typename cpp11::tuple_element<0, Vpm_out_tuple_helper>::type::type >,
+    boost::optional< typename std::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 std::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 std::tuple_element<2, Vpm_out_tuple_helper>::type::type >,
-    boost::optional< typename cpp11::tuple_element<3, 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],
+    Corefinement::get_vpm<Point_3>(std::get<0>(nps_out), output[0],
-                                   typename cpp11::tuple_element<0, Vpm_out_tuple_helper>::type::Use_default_tag()),
+                                   typename std::tuple_element<0, Vpm_out_tuple_helper>::type::Use_default_tag()),
-    Corefinement::get_vpm<Point_3>(cpp11::get<1>(nps_out), output[1],
+    Corefinement::get_vpm<Point_3>(std::get<1>(nps_out), output[1],
-                                   typename cpp11::tuple_element<1, Vpm_out_tuple_helper>::type::Use_default_tag()),
+                                   typename std::tuple_element<1, Vpm_out_tuple_helper>::type::Use_default_tag()),
-    Corefinement::get_vpm<Point_3>(cpp11::get<2>(nps_out), output[2],
+    Corefinement::get_vpm<Point_3>(std::get<2>(nps_out), output[2],
-                                   typename cpp11::tuple_element<2, Vpm_out_tuple_helper>::type::Use_default_tag()),
+                                   typename std::tuple_element<2, Vpm_out_tuple_helper>::type::Use_default_tag()),
-    Corefinement::get_vpm<Point_3>(cpp11::get<3>(nps_out), output[3],
+    Corefinement::get_vpm<Point_3>(std::get<3>(nps_out), output[3],
-                                   typename cpp11::tuple_element<3, Vpm_out_tuple_helper>::type::Use_default_tag())
+                                   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()))

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/Face_graph_output_builder.h

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/intersect_triangle_and_segment_3.h

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/intersection_impl.h

@@ -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);
+            halfedge_descriptor h_2=std::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));
+            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));

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orient_polygon_soup.h

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_hole.h

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

Polygon_mesh_processing/include/CGAL/Polygon_mesh_slicer.h

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

Polygon_mesh_processing/test/Polygon_mesh_processing/test_corefinement_and_constraints.cpp

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

Polyhedron/demo/Polyhedron/Plugins/PMP/Hole_filling_plugin.cpp

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

Polyhedron/demo/Polyhedron/Plugins/PMP/Orient_soup_plugin.cpp

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

Polyhedron_IO/include/CGAL/IO/PLY_reader.h

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

Property_map/include/CGAL/property_map.h

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

STL_Extension/doc/STL_Extension/CGAL/iterator.h

@@ -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 V must be a `std::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 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 V must be a `std::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 O must be a `std::tuple<...>` of the types of corresponding output iterators.
 
 \cgalModels `OutputIterator`
 

STL_Extension/doc/STL_Extension/CGAL/tuple.h

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

STL_Extension/doc/STL_Extension/CGAL/utility.h

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

STL_Extension/examples/STL_Extension/Dispatch_output_iterator.cpp

@@ -10,11 +10,11 @@ int main()
   std::vector<char> c;
 
   typedef CGAL::Dispatch_output_iterator< 
-    CGAL::cpp0x::tuple<int, double, char>,
+    std::tuple<int, double, char>,
-    CGAL::cpp0x::tuple<std::back_insert_iterator< std::vector<int> >,
+    std::tuple<std::back_insert_iterator< std::vector<int> >,
-                       std::back_insert_iterator< std::vector<double> >,
+               std::back_insert_iterator< std::vector<double> >,
-                       std::back_insert_iterator< std::vector<char> > 
+               std::back_insert_iterator< std::vector<char> > 
-                       > > Dispatch;
+               > > Dispatch;
 
   Dispatch disp = CGAL::dispatch_output<int, double, char>(
     std::back_inserter(a),

STL_Extension/include/CGAL/iterator.h

@@ -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...> >
+struct Derivator<D, std::tuple<V1, V...>, std::tuple<O1, O...> >
-  : public Derivator<D, cpp11::tuple<V...>, cpp11::tuple<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, std::tuple<V1, V...>, std::tuple<O1, O...> > Self;
-  typedef Derivator<D, cpp11::tuple<V...>, cpp11::tuple<O...> > Base;
+  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))) ++ = 
+    * std::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 >(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...> >
+class Dispatch_output_iterator < std::tuple<V...>, std::tuple<O...> >
- : private internal::Derivator<Dispatch_output_iterator< cpp11::tuple<V...>, cpp11::tuple<O...> >, cpp11::tuple<V...>, cpp11::tuple<O...> >
+ : private internal::Derivator<Dispatch_output_iterator< std::tuple<V...>, std::tuple<O...> >, std::tuple<V...>, std::tuple<O...> >
- , public cpp11::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 std::tuple<O...>               Iterator_tuple;
-  typedef cpp11::tuple<V...>               Value_type_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...> >
+class Dispatch_or_drop_output_iterator < std::tuple<V...>, std::tuple<O...> >
- : public Dispatch_output_iterator< cpp11::tuple<V...>, cpp11::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

STL_Extension/include/CGAL/tuple.h

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

STL_Extension/include/CGAL/utility.h

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

STL_Extension/test/STL_Extension/test_dispatch_output.cpp

@@ -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;
+  std::tie(d, bck_ins) = disp;
-  CGAL::cpp11::tie(d, bck_ins) = drop;
+  std::tie(d, bck_ins) = drop;
 
   //testing putting the tuple directly
-  CGAL::cpp11::tuple<T1,T2> tuple =
+  std::tuple<T1,T2> tuple =
-    CGAL::cpp11::make_tuple(*data1.begin(), *data2.begin());
+    std::make_tuple(*data1.begin(), *data2.begin());
 
   *disp++ = tuple;
   assert(cont_2.size()==2 * data2.size()+1);
@@ -97,11 +97,11 @@ void variant_test() {
   std::vector<double> b;
   std::vector<char> c;
   typedef CGAL::Dispatch_output_iterator< 
-    CGAL::cpp0x::tuple<int, double, char>,
+    std::tuple<int, double, char>,
-    CGAL::cpp0x::tuple<std::back_insert_iterator< std::vector<int> >,
+    std::tuple<std::back_insert_iterator< std::vector<int> >,
-                       std::back_insert_iterator< std::vector<double> >,
+               std::back_insert_iterator< std::vector<double> >,
-                       std::back_insert_iterator< std::vector<char> > 
+               std::back_insert_iterator< std::vector<char> > 
-                       > > Dispatch;
+                     > > Dispatch;
   Dispatch disp = CGAL::dispatch_output<int, double, char>(std::back_inserter(a),
                                                            std::back_inserter(b),
                                                            std::back_inserter(c));

STL_Extension/test/STL_Extension/test_namespaces.cpp

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

STL_Extension/test/STL_Extension/test_stl_extension.cpp

@@ -8109,19 +8109,19 @@ void test_Quadruple()
 }
 
 void test_tuple(){
-  typedef CGAL::cpp11::tuple<> T0;
+  typedef std::tuple<> T0;
-  typedef CGAL::cpp11::tuple<int,int> T1;
+  typedef std::tuple<int,int> T1;
-  typedef CGAL::cpp11::tuple<int,My_to_int,int,int> T2;
+  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( std::tuple_size<T0>::value == 0 );
-  CGAL_static_assertion( CGAL::cpp11::tuple_size<T1>::value == 2 );
+  CGAL_static_assertion( std::tuple_size<T1>::value == 2 );
-  CGAL_static_assertion( CGAL::cpp11::tuple_size<T2>::value == 4 );
+  CGAL_static_assertion( std::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( (boost::is_same<std::tuple_element<1,T2>::type,My_to_int>::value) );  
   
-  T1 t1=CGAL::cpp11::make_tuple(1,2);
+  T1 t1=std::make_tuple(1,2);
-  T1 t1_2=CGAL::cpp11::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;
+  std::tie(i1,i2)=t1;
-  assert( CGAL::cpp11::get<0>(t1)==i1 );
+  assert( std::get<0>(t1)==i1 );
-  assert( CGAL::cpp11::get<1>(t1)==i2 );
+  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(std::get<0>(pair) == -3);
-  assert(CGAL::cpp11::get<1>(pair) == &d);
+  assert(std::get<1>(pair) == &d);
-  assert(CGAL::cpp11::get<0>(const_pair) == 2);
+  assert(std::get<0>(const_pair) == 2);
-  assert(CGAL::cpp11::get<1>(const_pair) == &d);
+  assert(std::get<1>(const_pair) == &d);
 }
 
 void test_prev_next()

Segment_Delaunay_graph_Linf_2/include/CGAL/Segment_Delaunay_graph_Linf_2/Voronoi_vertex_ring_C2.h

@@ -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 & p1 = std::get<0>(sites);
-      const Site_2 & p2 = cpp11::get<1>(sites);
+      const Site_2 & p2 = std::get<1>(sites);
-      const Site_2 & s  = cpp11::get<2>(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 & pt_site = std::get<0>(sites);
-      const Site_2 & s1 = cpp11::get<1>(sites);
+      const Site_2 & s1 = std::get<1>(sites);
-      const Site_2 & s2 = cpp11::get<2>(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);

Segment_Delaunay_graph_Linf_2/include/CGAL/Side_of_bounded_square_2.h

@@ -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 * lft_p = std::get<0>(tupx);
-        FT const * rgt_p = CGAL::cpp11::get<1>(tupx);
+        FT const * rgt_p = std::get<1>(tupx);
-        const bool samex_pq = CGAL::cpp11::get<2>(tupx);
+        const bool samex_pq = std::get<2>(tupx);
-        const bool samex_pr = CGAL::cpp11::get<3>(tupx);
+        const bool samex_pr = std::get<3>(tupx);
-        const bool samex_qr = CGAL::cpp11::get<4>(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 * bot_p = std::get<0>(tupy);
-        FT const * top_p = CGAL::cpp11::get<1>(tupy);
+        FT const * top_p = std::get<1>(tupy);
-        const bool samey_pq = CGAL::cpp11::get<2>(tupy);
+        const bool samey_pq = std::get<2>(tupy);
-        const bool samey_pr = CGAL::cpp11::get<3>(tupy);
+        const bool samey_pr = std::get<3>(tupy);
-        const bool samey_qr = CGAL::cpp11::get<4>(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;
+              (is_rgt_input)? std::get<6>(tupx) : NULL;
-            Point_2 const * const pt_top_p = CGAL::cpp11::get<6>(tupy);
+            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

Spatial_searching/include/CGAL/Orthogonal_incremental_neighbor_search.h

@@ -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);
+	  Node_const_handle N= std::get<0>(*The_node_top);
-          dists = CGAL::cpp11::get<2>(*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);
+	  Node_const_handle N= std::get<0>(*The_node_top);
-          dists = CGAL::cpp11::get<2>(*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);

Surface_mesh/benchmark/lcc_performance_2.h

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