boost::unit -> std::uint

BGL/include/CGAL/boost/graph/IO/STL.h

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

CGAL_ImageIO/include/CGAL/ImageIO/bmptypes.h

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

CGAL_ImageIO/include/CGAL/Image_3_vtk_interface.h

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

Mesh_3/include/CGAL/Mesh_3/search_for_connected_components_in_labeled_image.h

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

Mesh_3/include/CGAL/Polyhedral_complex_mesh_domain_3.h

@@ -456,9 +456,9 @@ public:
         // here we have a new free vertex on patch #`patch_id`
 
         if(random.uniform_smallint(
-               boost::uint32_t(0),
+               std::uint32_t(0),
-               boost::uint32_t(nb_of_free_vertices_on_patch[patch_id]))
+               std::uint32_t(nb_of_free_vertices_on_patch[patch_id]))
-           < boost::uint32_t(needed_vertices_on_patch[patch_id]))
+           < std::uint32_t(needed_vertices_on_patch[patch_id]))
         {
           several_vertices_on_patch[patch_id].push_back(vit);
           --needed_vertices_on_patch[patch_id];

Number_types/include/CGAL/Mpzf.h

@@ -188,7 +188,7 @@ template <class T, class = void> struct no_pool {
 };
 
 // Only used with an argument known not to be 0.
-inline int ctz (boost::uint64_t x) {
+inline int ctz (std::uint64_t x) {
 #if defined(_MSC_VER)
   unsigned long ret;
   _BitScanForward64(&ret, x);
@@ -200,7 +200,7 @@ inline int ctz (boost::uint64_t x) {
   return __builtin_ctzll (x);
 #endif
 }
-inline int clz (boost::uint64_t x) {
+inline int clz (std::uint64_t x) {
 #if defined(_MSC_VER)
   unsigned long ret;
   _BitScanReverse64(&ret, x);
@@ -430,7 +430,7 @@ struct Mpzf {
   }
   Mpzf(double d){
     init();
-    using boost::uint64_t;
+    using std::uint64_t;
     union {
 #ifdef CGAL_LITTLE_ENDIAN
       struct { uint64_t man:52; uint64_t exp:11; uint64_t sig:1; } s;

Number_types/include/CGAL/known_bit_size_integers.h

@@ -38,15 +38,15 @@ namespace CGAL {
   typedef boost::int16_t   Integer16;
   typedef boost::int32_t   Integer32;
 
-  typedef boost::uint8_t   UInteger8;
+  typedef std::uint8_t   UInteger8;
-  typedef boost::uint16_t  UInteger16;
+  typedef std::uint16_t  UInteger16;
-  typedef boost::uint32_t  UInteger32;
+  typedef std::uint32_t  UInteger32;
 
 #ifndef BOOST_NO_INT64_T
 // this macro is still provided but its use is discouraged
 #   define CGAL_HAS_INTEGER64
   typedef boost::int64_t   Integer64;
-  typedef boost::uint64_t  UInteger64;
+  typedef std::uint64_t  UInteger64;
 #endif
 
 } //namespace CGAL

Number_types/test/Number_types/known_bit_size_integers.cpp

@@ -14,11 +14,11 @@ int main()
   CGAL_static_assertion(sizeof(boost::int64_t) == 8);
 #endif
 
-  CGAL_static_assertion(sizeof(boost::uint8_t)  == 1);
+  CGAL_static_assertion(sizeof(std::uint8_t)  == 1);
-  CGAL_static_assertion(sizeof(boost::uint16_t) == 2);
+  CGAL_static_assertion(sizeof(std::uint16_t) == 2);
-  CGAL_static_assertion(sizeof(boost::uint32_t) == 4);
+  CGAL_static_assertion(sizeof(std::uint32_t) == 4);
 #ifndef BOOST_NO_INT64_T
-  CGAL_static_assertion(sizeof(boost::uint64_t) == 8);
+  CGAL_static_assertion(sizeof(std::uint64_t) == 8);
 #endif
 
   return 0;

Point_set_3/doc/Point_set_3/Point_set_3.txt

@@ -117,7 +117,7 @@ For example, if the following line is found in the PLY header:
 
 > property uchar red
 
-Then a property named `red` and with type `boost::uint8_t` (`boost`
+Then a property named `red` and with type `std::uint8_t` (`boost`
 types are used because of their fixed memory size) will be
 instantiated in the point set and filled with the corresponding
 values.

Point_set_3/include/CGAL/Point_set_3.h

@@ -48,7 +48,7 @@ namespace internal {
 #ifdef CGAL_POINT_SET_3_USE_STD_SIZE_T_AS_SIZE_TYPE
     typedef std::size_t size_type;
 #else
-    typedef boost::uint32_t size_type;
+    typedef std::uint32_t size_type;
 #endif
     typedef CGAL::Point_set_3<Point, Vector> Point_set_3;
 

Point_set_3/include/CGAL/Point_set_3/IO/PLY.h

@@ -124,10 +124,10 @@ public:
             (new PLY_property_to_point_set_property<boost::int8_t>(m_point_set,
                                                                    name));
       }
-      else if(dynamic_cast<PLY_read_typed_number<boost::uint8_t>*>(property))
+      else if(dynamic_cast<PLY_read_typed_number<std::uint8_t>*>(property))
       {
         m_properties.push_back
-            (new PLY_property_to_point_set_property<boost::uint8_t>(m_point_set,
+            (new PLY_property_to_point_set_property<std::uint8_t>(m_point_set,
                                                                     name));
       }
       else if(dynamic_cast<PLY_read_typed_number<boost::int16_t>*>(property))
@@ -136,10 +136,10 @@ public:
             (new PLY_property_to_point_set_property<boost::int16_t>(m_point_set,
                                                                     name));
       }
-      else if(dynamic_cast<PLY_read_typed_number<boost::uint16_t>*>(property))
+      else if(dynamic_cast<PLY_read_typed_number<std::uint16_t>*>(property))
       {
         m_properties.push_back
-            (new PLY_property_to_point_set_property<boost::uint16_t>(m_point_set,
+            (new PLY_property_to_point_set_property<std::uint16_t>(m_point_set,
                                                                      name));
       }
       else if(dynamic_cast<PLY_read_typed_number<boost::int32_t>*>(property))
@@ -148,10 +148,10 @@ public:
             (new PLY_property_to_point_set_property<boost::int32_t>(m_point_set,
                                                                     name));
       }
-      else if(dynamic_cast<PLY_read_typed_number<boost::uint32_t>*>(property))
+      else if(dynamic_cast<PLY_read_typed_number<std::uint32_t>*>(property))
       {
         m_properties.push_back
-            (new PLY_property_to_point_set_property<boost::uint32_t>(m_point_set,
+            (new PLY_property_to_point_set_property<std::uint32_t>(m_point_set,
                                                                      name));
       }
       else if(dynamic_cast<PLY_read_typed_number<float>*>(property))
@@ -457,13 +457,13 @@ bool write_PLY(std::ostream& os,
   typedef typename Point_set::Point_map Point_map;
   typedef typename Point_set::Vector_map Vector_map;
   typedef typename Point_set::template Property_map<boost::int8_t> Int8_map;
-  typedef typename Point_set::template Property_map<boost::uint8_t> Uint8_map;
+  typedef typename Point_set::template Property_map<std::uint8_t> Uint8_map;
   typedef typename Point_set::template Property_map<boost::int16_t> Int16_map;
-  typedef typename Point_set::template Property_map<boost::uint16_t> Uint16_map;
+  typedef typename Point_set::template Property_map<std::uint16_t> Uint16_map;
   typedef typename Point_set::template Property_map<boost::int32_t> Int32_map;
-  typedef typename Point_set::template Property_map<boost::uint32_t> Uint32_map;
+  typedef typename Point_set::template Property_map<std::uint32_t> Uint32_map;
   typedef typename Point_set::template Property_map<boost::int64_t> Int64_map;
-  typedef typename Point_set::template Property_map<boost::uint64_t> Uint64_map;
+  typedef typename Point_set::template Property_map<std::uint64_t> Uint64_map;
   typedef typename Point_set::template Property_map<float> Float_map;
   typedef typename Point_set::template Property_map<double> Double_map;
 
@@ -551,7 +551,7 @@ bool write_PLY(std::ostream& os,
     }
     {
       Uint8_map pmap;
-      boost::tie(pmap, okay) = point_set.template property_map<boost::uint8_t>(prop[i]);
+      boost::tie(pmap, okay) = point_set.template property_map<std::uint8_t>(prop[i]);
       if(okay)
       {
         os << "property uchar " << prop[i] << std::endl;
@@ -571,7 +571,7 @@ bool write_PLY(std::ostream& os,
     }
     {
       Uint16_map pmap;
-      boost::tie(pmap, okay) = point_set.template property_map<boost::uint16_t>(prop[i]);
+      boost::tie(pmap, okay) = point_set.template property_map<std::uint16_t>(prop[i]);
       if(okay)
       {
         os << "property ushort " << prop[i] << std::endl;
@@ -591,7 +591,7 @@ bool write_PLY(std::ostream& os,
     }
     {
       Uint32_map pmap;
-      boost::tie(pmap, okay) = point_set.template property_map<boost::uint32_t>(prop[i]);
+      boost::tie(pmap, okay) = point_set.template property_map<std::uint32_t>(prop[i]);
       if(okay)
       {
         os << "property uint " << prop[i] << std::endl;
@@ -611,11 +611,11 @@ bool write_PLY(std::ostream& os,
     }
     {
       Uint64_map pmap;
-      boost::tie(pmap, okay) = point_set.template property_map<boost::uint64_t>(prop[i]);
+      boost::tie(pmap, okay) = point_set.template property_map<std::uint64_t>(prop[i]);
       if(okay)
       {
         os << "property uint " << prop[i] << std::endl;
-        printers.push_back(new internal::Simple_property_printer<Index,Uint64_map,boost::uint32_t>(pmap));
+        printers.push_back(new internal::Simple_property_printer<Index,Uint64_map,std::uint32_t>(pmap));
         continue;
       }
     }

Polyhedron/demo/Polyhedron/Plugins/Classification/Cluster_classification.cpp

@@ -637,11 +637,11 @@ void Cluster_classification::compute_features (std::size_t nb_scales, float voxe
 
   bool colors = (m_color != Point_set::Property_map<CGAL::IO::Color>());
 
-  Point_set::Property_map<boost::uint8_t> echo_map;
+  Point_set::Property_map<std::uint8_t> echo_map;
   bool echo;
-  boost::tie (echo_map, echo) = m_points->point_set()->template property_map<boost::uint8_t>("echo");
+  boost::tie (echo_map, echo) = m_points->point_set()->template property_map<std::uint8_t>("echo");
   if (!echo)
-    boost::tie (echo_map, echo) = m_points->point_set()->template property_map<boost::uint8_t>("number_of_returns");
+    boost::tie (echo_map, echo) = m_points->point_set()->template property_map<std::uint8_t>("number_of_returns");
 
   Feature_set pointwise_features;
 
@@ -775,15 +775,15 @@ void Cluster_classification::add_remaining_point_set_properties_as_features(Feat
 
     if (try_adding_simple_feature<boost::int8_t>(feature_set, prop[i]))
       continue;
-    if (try_adding_simple_feature<boost::uint8_t>(feature_set, prop[i]))
+    if (try_adding_simple_feature<std::uint8_t>(feature_set, prop[i]))
       continue;
     if (try_adding_simple_feature<boost::int16_t>(feature_set, prop[i]))
       continue;
-    if (try_adding_simple_feature<boost::uint16_t>(feature_set, prop[i]))
+    if (try_adding_simple_feature<std::uint16_t>(feature_set, prop[i]))
       continue;
     if (try_adding_simple_feature<boost::int32_t>(feature_set, prop[i]))
       continue;
-    if (try_adding_simple_feature<boost::uint32_t>(feature_set, prop[i]))
+    if (try_adding_simple_feature<std::uint32_t>(feature_set, prop[i]))
       continue;
     if (try_adding_simple_feature<float>(feature_set, prop[i]))
       continue;

Polyhedron/demo/Polyhedron/Plugins/Classification/Point_set_item_classification.cpp

@@ -532,11 +532,11 @@ void Point_set_item_classification::compute_features (std::size_t nb_scales, flo
 
   bool colors = (m_color != Point_set::Property_map<CGAL::IO::Color>());
 
-  Point_set::Property_map<boost::uint8_t> echo_map;
+  Point_set::Property_map<std::uint8_t> echo_map;
   bool echo;
-  boost::tie (echo_map, echo) = m_points->point_set()->template property_map<boost::uint8_t>("echo");
+  boost::tie (echo_map, echo) = m_points->point_set()->template property_map<std::uint8_t>("echo");
   if (!echo)
-    boost::tie (echo_map, echo) = m_points->point_set()->template property_map<boost::uint8_t>("number_of_returns");
+    boost::tie (echo_map, echo) = m_points->point_set()->template property_map<std::uint8_t>("number_of_returns");
 
   m_generator = new Generator (*(m_points->point_set()), m_points->point_set()->point_map(), nb_scales, voxel_size);
 
@@ -670,15 +670,15 @@ void Point_set_item_classification::add_remaining_point_set_properties_as_featur
 
     if (try_adding_simple_feature<boost::int8_t>(prop[i]))
       continue;
-    if (try_adding_simple_feature<boost::uint8_t>(prop[i]))
+    if (try_adding_simple_feature<std::uint8_t>(prop[i]))
       continue;
     if (try_adding_simple_feature<boost::int16_t>(prop[i]))
       continue;
-    if (try_adding_simple_feature<boost::uint16_t>(prop[i]))
+    if (try_adding_simple_feature<std::uint16_t>(prop[i]))
       continue;
     if (try_adding_simple_feature<boost::int32_t>(prop[i]))
       continue;
-    if (try_adding_simple_feature<boost::uint32_t>(prop[i]))
+    if (try_adding_simple_feature<std::uint32_t>(prop[i]))
       continue;
     if (try_adding_simple_feature<float>(prop[i]))
       continue;

Polyhedron/demo/Polyhedron/Plugins/Display/Display_property_plugin.cpp

@@ -1758,7 +1758,7 @@ private:
     {
       return true;
     }
-    if(ps->template property_map<boost::uint8_t>(name).second)
+    if(ps->template property_map<std::uint8_t>(name).second)
     {
       return true;
     }
@@ -1766,7 +1766,7 @@ private:
     {
       return true;
     }
-    if(ps->template property_map<boost::uint16_t>(name).second)
+    if(ps->template property_map<std::uint16_t>(name).second)
     {
       return true;
     }
@@ -1774,7 +1774,7 @@ private:
     {
       return true;
     }
-    if(ps->template property_map<boost::uint32_t>(name).second)
+    if(ps->template property_map<std::uint32_t>(name).second)
     {
       return true;
     }
@@ -1782,7 +1782,7 @@ private:
     {
       return true;
     }
-    if(ps->template property_map<boost::uint64_t>(name).second)
+    if(ps->template property_map<std::uint64_t>(name).second)
     {
       return true;
     }
@@ -1805,7 +1805,7 @@ private:
     {
       return true;
     }
-    if(sm->template property_map<Simplex,boost::uint8_t>(name).second)
+    if(sm->template property_map<Simplex,std::uint8_t>(name).second)
     {
       return true;
     }
@@ -1813,7 +1813,7 @@ private:
     {
       return true;
     }
-    if(sm->template property_map<Simplex,boost::uint16_t>(name).second)
+    if(sm->template property_map<Simplex,std::uint16_t>(name).second)
     {
       return true;
     }
@@ -1821,7 +1821,7 @@ private:
     {
       return true;
     }
-    if(sm->template property_map<Simplex,boost::uint32_t>(name).second)
+    if(sm->template property_map<Simplex,std::uint32_t>(name).second)
     {
       return true;
     }
@@ -1829,7 +1829,7 @@ private:
     {
       return true;
     }
-    if(sm->template property_map<Simplex,boost::uint64_t>(name).second)
+    if(sm->template property_map<Simplex,std::uint64_t>(name).second)
     {
       return true;
     }
@@ -1847,13 +1847,13 @@ private:
   bool DisplayPropertyPlugin::treat_point_property(std::string name, Point_set* ps)
   {
     typedef typename Point_set::template Property_map<boost::int8_t>   Int8_map;
-    typedef typename Point_set::template Property_map<boost::uint8_t>  Uint8_map;
+    typedef typename Point_set::template Property_map<std::uint8_t>  Uint8_map;
     typedef typename Point_set::template Property_map<boost::int16_t>  Int16_map;
-    typedef typename Point_set::template Property_map<boost::uint16_t> Uint16_map;
+    typedef typename Point_set::template Property_map<std::uint16_t> Uint16_map;
     typedef typename Point_set::template Property_map<boost::int32_t>  Int32_map;
-    typedef typename Point_set::template Property_map<boost::uint32_t> Uint32_map;
+    typedef typename Point_set::template Property_map<std::uint32_t> Uint32_map;
     typedef typename Point_set::template Property_map<boost::int64_t>  Int64_map;
-    typedef typename Point_set::template Property_map<boost::uint64_t> Uint64_map;
+    typedef typename Point_set::template Property_map<std::uint64_t> Uint64_map;
     typedef typename Point_set::template Property_map<float>           Float_map;
     typedef typename Point_set::template Property_map<double>          Double_map;
 
@@ -1869,7 +1869,7 @@ private:
 
     {
       Uint8_map pmap;
-      std::tie(pmap, okay) = ps->property_map<boost::uint8_t>(name);
+      std::tie(pmap, okay) = ps->property_map<std::uint8_t>(name);
       if(okay)
       {
         return displayPSProperty(ps, pmap);
@@ -1887,7 +1887,7 @@ private:
 
     {
       Uint16_map pmap;
-      std::tie(pmap, okay) = ps->property_map<boost::uint16_t>(name);
+      std::tie(pmap, okay) = ps->property_map<std::uint16_t>(name);
       if(okay)
       {
         return displayPSProperty(ps, pmap);
@@ -1905,7 +1905,7 @@ private:
 
     {
       Uint32_map pmap;
-      std::tie(pmap, okay) = ps->property_map<boost::uint32_t>(name);
+      std::tie(pmap, okay) = ps->property_map<std::uint32_t>(name);
       if(okay)
       {
         return displayPSProperty(ps, pmap);
@@ -1923,7 +1923,7 @@ private:
 
     {
       Uint64_map pmap;
-      std::tie(pmap, okay) = ps->property_map<boost::uint64_t>(name);
+      std::tie(pmap, okay) = ps->property_map<std::uint64_t>(name);
       if(okay)
       {
         return displayPSProperty(ps, pmap);
@@ -1954,13 +1954,13 @@ private:
   bool DisplayPropertyPlugin::treat_sm_property(std::string name, SMesh* sm)
   {
     typedef typename SMesh::template Property_map<TAG, boost::int8_t>   Int8_map;
-    typedef typename SMesh::template Property_map<TAG, boost::uint8_t>  Uint8_map;
+    typedef typename SMesh::template Property_map<TAG, std::uint8_t>  Uint8_map;
     typedef typename SMesh::template Property_map<TAG, boost::int16_t>  Int16_map;
-    typedef typename SMesh::template Property_map<TAG, boost::uint16_t> Uint16_map;
+    typedef typename SMesh::template Property_map<TAG, std::uint16_t> Uint16_map;
     typedef typename SMesh::template Property_map<TAG, boost::int32_t>  Int32_map;
-    typedef typename SMesh::template Property_map<TAG, boost::uint32_t> Uint32_map;
+    typedef typename SMesh::template Property_map<TAG, std::uint32_t> Uint32_map;
     typedef typename SMesh::template Property_map<TAG, boost::int64_t>  Int64_map;
-    typedef typename SMesh::template Property_map<TAG, boost::uint64_t> Uint64_map;
+    typedef typename SMesh::template Property_map<TAG, std::uint64_t> Uint64_map;
     typedef typename SMesh::template Property_map<TAG, float>           Float_map;
     typedef typename SMesh::template Property_map<TAG, double>          Double_map;
 
@@ -1976,7 +1976,7 @@ private:
 
     {
       Uint8_map pmap;
-      std::tie(pmap, okay) = sm->property_map<TAG,boost::uint8_t>(name);
+      std::tie(pmap, okay) = sm->property_map<TAG,std::uint8_t>(name);
       if(okay)
       {
         return displaySMProperty(*sm, pmap, TAG());
@@ -1994,7 +1994,7 @@ private:
 
     {
       Uint16_map pmap;
-      std::tie(pmap, okay) = sm->property_map<TAG,boost::uint16_t>(name);
+      std::tie(pmap, okay) = sm->property_map<TAG,std::uint16_t>(name);
       if(okay)
       {
         return displaySMProperty(*sm, pmap, TAG());
@@ -2012,7 +2012,7 @@ private:
 
     {
       Uint32_map pmap;
-      std::tie(pmap, okay) = sm->property_map<TAG,boost::uint32_t>(name);
+      std::tie(pmap, okay) = sm->property_map<TAG,std::uint32_t>(name);
       if(okay)
       {
         return displaySMProperty(*sm, pmap, TAG());
@@ -2030,7 +2030,7 @@ private:
 
     {
       Uint64_map pmap;
-      std::tie(pmap, okay) = sm->property_map<TAG,boost::uint64_t>(name);
+      std::tie(pmap, okay) = sm->property_map<TAG,std::uint64_t>(name);
       if(okay)
       {
         return displaySMProperty(*sm, pmap, TAG());

Polyhedron/demo/Polyhedron/Scene_image_item.cpp

@@ -548,11 +548,11 @@ template <typename T> const char* whatType(T) { return "unknown"; }    // defaul
 template <> const char* whatType(float) { return "float"; }
 template <> const char* whatType(double) { return "double"; }
 template <> const char* whatType(char) { return "int8_t (char)"; }
-template <> const char* whatType(boost::uint8_t) { return "uint8_t (unsigned char)"; }
+template <> const char* whatType(std::uint8_t) { return "uint8_t (unsigned char)"; }
 template <> const char* whatType(boost::int16_t) { return "int16_t (short)"; }
-template <> const char* whatType(boost::uint16_t) { return "uint16_t (unsigned short)"; }
+template <> const char* whatType(std::uint16_t) { return "uint16_t (unsigned short)"; }
 template <> const char* whatType(boost::int32_t) { return "int32_t (int)"; }
-template <> const char* whatType(boost::uint32_t) { return "uint32_t (unsigned int)"; }
+template <> const char* whatType(std::uint32_t) { return "uint32_t (unsigned int)"; }
 
 template<typename Word>
 QString explicitWordType()

Spatial_searching/include/CGAL/Kd_tree_node.h

@@ -653,7 +653,7 @@ namespace CGAL {
   private:
 
        // private variables for internal nodes
-    boost::uint8_t cut_dim;
+    std::uint8_t cut_dim;
     FT cut_val;
 
     Node_handle lower_ch, upper_ch;
@@ -714,7 +714,7 @@ namespace CGAL {
 
     inline
     void set_separator(Separator& sep){
-      cut_dim = static_cast<boost::uint8_t>(sep.cutting_dimension());
+      cut_dim = static_cast<std::uint8_t>(sep.cutting_dimension());
       cut_val = sep.cutting_value();
     }
 

Stream_support/include/CGAL/IO/PLY.h

@@ -81,13 +81,13 @@ bool read_PLY(std::istream& is,
       bool has_colors = false;
       std::string rtag = "r", gtag = "g", btag = "b";
 
-      if((element.has_property<boost::uint8_t>("red") || element.has_property<boost::uint8_t>("r")) &&
+      if((element.has_property<std::uint8_t>("red") || element.has_property<std::uint8_t>("r")) &&
-         (element.has_property<boost::uint8_t>("green") || element.has_property<boost::uint8_t>("g")) &&
+         (element.has_property<std::uint8_t>("green") || element.has_property<std::uint8_t>("g")) &&
-         (element.has_property<boost::uint8_t>("blue") || element.has_property<boost::uint8_t>("b")))
+         (element.has_property<std::uint8_t>("blue") || element.has_property<std::uint8_t>("b")))
       {
         has_colors = true;
 
-        if(element.has_property<boost::uint8_t>("red"))
+        if(element.has_property<std::uint8_t>("red"))
         {
           rtag = "red";
           gtag = "green";
@@ -106,17 +106,17 @@ bool read_PLY(std::istream& is,
             return false;
         }
 
-        std::tuple<Point_3, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_vertex;
+        std::tuple<Point_3, std::uint8_t, std::uint8_t, std::uint8_t> new_vertex;
         if(has_colors)
         {
           internal::process_properties(element, new_vertex,
                                        make_ply_point_reader(CGAL::make_nth_of_tuple_property_map<0>(new_vertex)),
                                        std::make_pair(CGAL::make_nth_of_tuple_property_map<1>(new_vertex),
-                                                      PLY_property<boost::uint8_t>(rtag.c_str())),
+                                                      PLY_property<std::uint8_t>(rtag.c_str())),
                                        std::make_pair(CGAL::make_nth_of_tuple_property_map<2>(new_vertex),
-                                                      PLY_property<boost::uint8_t>(gtag.c_str())),
+                                                      PLY_property<std::uint8_t>(gtag.c_str())),
                                        std::make_pair(CGAL::make_nth_of_tuple_property_map<3>(new_vertex),
-                                                      PLY_property<boost::uint8_t>(btag.c_str())));
+                                                      PLY_property<std::uint8_t>(btag.c_str())));
 
           *vc_out++ = Color_rgb(get<1>(new_vertex), get<2>(new_vertex), get<3>(new_vertex));
         }
@@ -135,17 +135,17 @@ bool read_PLY(std::istream& is,
       {
         internal::read_PLY_faces<boost::int32_t>(is, element, polygons, fc_out, "vertex_indices");
       }
-      else if(element.has_property<std::vector<boost::uint32_t> >("vertex_indices"))
+      else if(element.has_property<std::vector<std::uint32_t> >("vertex_indices"))
       {
-        internal::read_PLY_faces<boost::uint32_t>(is, element, polygons, fc_out, "vertex_indices");
+        internal::read_PLY_faces<std::uint32_t>(is, element, polygons, fc_out, "vertex_indices");
       }
       else if(element.has_property<std::vector<boost::int32_t> >("vertex_index"))
       {
         internal::read_PLY_faces<boost::int32_t>(is, element, polygons, fc_out, "vertex_index");
       }
-      else if(element.has_property<std::vector<boost::uint32_t> >("vertex_index"))
+      else if(element.has_property<std::vector<std::uint32_t> >("vertex_index"))
       {
-        internal::read_PLY_faces<boost::uint32_t>(is, element, polygons, fc_out, "vertex_index");
+        internal::read_PLY_faces<std::uint32_t>(is, element, polygons, fc_out, "vertex_index");
       }
       else
       {

Stream_support/include/CGAL/IO/PLY/PLY_reader.h

@@ -37,11 +37,11 @@
     m_elements.back().add_property(new PLY_read_typed_list_with_typed_size< SIZE_TYPE , INDEX_TYPE >(name, format))
 
 #define TRY_TO_GENERATE_LIST_PROPERTY(STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE) \
-  TRY_TO_GENERATE_SIZED_LIST_PROPERTY("uchar", "uint8", boost::uint8_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
+  TRY_TO_GENERATE_SIZED_LIST_PROPERTY("uchar", "uint8", std::uint8_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
   else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("char", "int8", boost::int8_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
-  else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("ushort", "uint16", boost::uint16_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
+  else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("ushort", "uint16", std::uint16_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
   else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("short", "int16", boost::int16_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
-  else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("uint", "uint32", boost::uint32_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
+  else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("uint", "uint32", std::uint32_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE); \
   else TRY_TO_GENERATE_SIZED_LIST_PROPERTY("int", "int32", boost::int32_t, STD_INDEX_TYPE, T_INDEX_TYPE, INDEX_TYPE)
 
 namespace CGAL {
@@ -530,22 +530,22 @@ public:
             }
 
             TRY_TO_GENERATE_LIST_PROPERTY("char", "int8", boost::int8_t);
-            else TRY_TO_GENERATE_LIST_PROPERTY("uchar", "uint8", boost::uint8_t);
+            else TRY_TO_GENERATE_LIST_PROPERTY("uchar", "uint8", std::uint8_t);
             else TRY_TO_GENERATE_LIST_PROPERTY("short", "int16", boost::int16_t);
-            else TRY_TO_GENERATE_LIST_PROPERTY("ushort", "uint16", boost::uint16_t);
+            else TRY_TO_GENERATE_LIST_PROPERTY("ushort", "uint16", std::uint16_t);
             else TRY_TO_GENERATE_LIST_PROPERTY("int", "int32", boost::int32_t);
-            else TRY_TO_GENERATE_LIST_PROPERTY("uint", "uint32", boost::uint32_t);
+            else TRY_TO_GENERATE_LIST_PROPERTY("uint", "uint32", std::uint32_t);
             else TRY_TO_GENERATE_LIST_PROPERTY("float", "float32", float);
             else TRY_TO_GENERATE_LIST_PROPERTY("double", "float64", double);
           }
           else
           {
             TRY_TO_GENERATE_PROPERTY("char", "int8", boost::int8_t);
-            else TRY_TO_GENERATE_PROPERTY("uchar", "uint8", boost::uint8_t);
+            else TRY_TO_GENERATE_PROPERTY("uchar", "uint8", std::uint8_t);
             else TRY_TO_GENERATE_PROPERTY("short", "int16", boost::int16_t);
-            else TRY_TO_GENERATE_PROPERTY("ushort", "uint16", boost::uint16_t);
+            else TRY_TO_GENERATE_PROPERTY("ushort", "uint16", std::uint16_t);
             else TRY_TO_GENERATE_PROPERTY("int", "int32", boost::int32_t);
-            else TRY_TO_GENERATE_PROPERTY("uint", "uint32", boost::uint32_t);
+            else TRY_TO_GENERATE_PROPERTY("uint", "uint32", std::uint32_t);
             else TRY_TO_GENERATE_PROPERTY("float", "float32", float);
             else TRY_TO_GENERATE_PROPERTY("double", "float64", double);
           }
@@ -711,12 +711,12 @@ bool read_PLY_faces(std::istream& in,
   bool has_colors = false;
   std::string rtag = "r", gtag = "g", btag = "b";
 
-  if((element.has_property<boost::uint8_t>("red") || element.has_property<boost::uint8_t>("r")) &&
+  if((element.has_property<std::uint8_t>("red") || element.has_property<std::uint8_t>("r")) &&
-     (element.has_property<boost::uint8_t>("green") || element.has_property<boost::uint8_t>("g")) &&
+     (element.has_property<std::uint8_t>("green") || element.has_property<std::uint8_t>("g")) &&
-     (element.has_property<boost::uint8_t>("blue") || element.has_property<boost::uint8_t>("b")))
+     (element.has_property<std::uint8_t>("blue") || element.has_property<std::uint8_t>("b")))
   {
     has_colors = true;
-    if(element.has_property<boost::uint8_t>("red"))
+    if(element.has_property<std::uint8_t>("red"))
     {
       rtag = "red";
       gtag = "green";
@@ -735,7 +735,7 @@ bool read_PLY_faces(std::istream& in,
         return false;
     }
 
-    std::tuple<std::vector<Integer>, boost::uint8_t, boost::uint8_t, boost::uint8_t> new_face;
+    std::tuple<std::vector<Integer>, std::uint8_t, std::uint8_t, std::uint8_t> new_face;
 
     if(has_colors)
     {
@@ -743,11 +743,11 @@ bool read_PLY_faces(std::istream& in,
                          std::make_pair(CGAL::make_nth_of_tuple_property_map<0>(new_face),
                                         PLY_property<std::vector<Integer> >(vertex_indices_tag)),
                          std::make_pair(CGAL::make_nth_of_tuple_property_map<1>(new_face),
-                                        PLY_property<boost::uint8_t>(rtag.c_str())),
+                                        PLY_property<std::uint8_t>(rtag.c_str())),
                          std::make_pair(CGAL::make_nth_of_tuple_property_map<2>(new_face),
-                                        PLY_property<boost::uint8_t>(gtag.c_str())),
+                                        PLY_property<std::uint8_t>(gtag.c_str())),
                          std::make_pair(CGAL::make_nth_of_tuple_property_map<3>(new_face),
-                                        PLY_property<boost::uint8_t>(btag.c_str())));
+                                        PLY_property<std::uint8_t>(btag.c_str())));
 
       *fc_out++ = Color_rgb(get<1>(new_face), get<2>(new_face), get<3>(new_face));
     }

Stream_support/include/CGAL/IO/STL.h

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

Stream_support/include/CGAL/IO/STL/STL_reader.h

@@ -209,7 +209,7 @@ bool parse_binary_STL(std::istream& is,
   int index = 0;
   std::map<Point, int> index_map;
 
-  boost::uint32_t N32;
+  std::uint32_t N32;
   if(!(is.read(reinterpret_cast<char*>(&N32), sizeof(N32))))
   {
     if(verbose)

Surface_mesh/doc/Surface_mesh/Surface_mesh.txt

@@ -398,7 +398,7 @@ Result of the run of the draw_surface_mesh program. A window shows the surface m
 
 \section sectionSurfaceMeshImplementation Implementation Details
 
-As integer type for the indices we have chosen `boost::uint32_t`. On 64 bit operating systems they
+As integer type for the indices we have chosen `std::uint32_t`. On 64 bit operating systems they
 take only half the size of a pointer. They still allow to have meshes with 2 billion elements.
 
 We use `std::vector` for storing properties. So by accessing the address

Surface_mesh/include/CGAL/Surface_mesh/IO/PLY.h

@@ -146,7 +146,7 @@ public:
     if(name == "vertex_indices" || name == "vertex_index")
     {
       CGAL_assertion(dynamic_cast<PLY_read_typed_list<boost::int32_t>*>(property)
-                     || dynamic_cast<PLY_read_typed_list<boost::uint32_t>*>(property));
+                     || dynamic_cast<PLY_read_typed_list<std::uint32_t>*>(property));
       m_index_tag  = name;
       m_use_int32_t = dynamic_cast<PLY_read_typed_list<boost::int32_t>*>(property);
       return true;
@@ -222,25 +222,25 @@ public:
       {
         properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, boost::int8_t>(m_mesh, name));
       }
-      else if(dynamic_cast<PLY_read_typed_number<boost::uint8_t>*>(property))
+      else if(dynamic_cast<PLY_read_typed_number<std::uint8_t>*>(property))
       {
-        properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, boost::uint8_t>(m_mesh, name));
+        properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, std::uint8_t>(m_mesh, name));
       }
       else if(dynamic_cast<PLY_read_typed_number<boost::int16_t>*>(property))
       {
         properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, boost::int16_t>(m_mesh, name));
       }
-      else if(dynamic_cast<PLY_read_typed_number<boost::uint16_t>*>(property))
+      else if(dynamic_cast<PLY_read_typed_number<std::uint16_t>*>(property))
       {
-        properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, boost::uint16_t>(m_mesh, name));
+        properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, std::uint16_t>(m_mesh, name));
       }
       else if(dynamic_cast<PLY_read_typed_number<boost::int32_t>*>(property))
       {
         properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, boost::int32_t>(m_mesh, name));
       }
-      else if(dynamic_cast<PLY_read_typed_number<boost::uint32_t>*>(property))
+      else if(dynamic_cast<PLY_read_typed_number<std::uint32_t>*>(property))
       {
-        properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, boost::uint32_t>(m_mesh, name));
+        properties.push_back(new PLY_property_to_surface_mesh_property<Simplex, std::uint32_t>(m_mesh, name));
       }
       else if(dynamic_cast<PLY_read_typed_number<float>*>(property))
       {
@@ -316,7 +316,7 @@ public:
     if(m_use_int32_t)
       process_line<boost::int32_t>(element, fi);
     else
-      process_line<boost::uint32_t>(element, fi);
+      process_line<std::uint32_t>(element, fi);
 
     if(fi == Surface_mesh::null_face())
       return false;
@@ -370,7 +370,7 @@ public:
     if(m_use_int32_t)
       process_line<boost::int32_t>(element, ei);
     else
-      process_line<boost::uint32_t>(element, ei);
+      process_line<std::uint32_t>(element, ei);
 
     if(ei == Surface_mesh::null_edge())
       return false;
@@ -403,7 +403,7 @@ public:
     if(m_use_int32_t)
       process_line<boost::int32_t>(element, hi);
     else
-      process_line<boost::uint32_t>(element, hi);
+      process_line<std::uint32_t>(element, hi);
 
     if(hi == Surface_mesh::null_halfedge())
       return false;
@@ -641,13 +641,13 @@ void fill_header(std::ostream& os, const Surface_mesh<Point>& sm,
 {
   typedef Surface_mesh<Point>                                             SMesh;
   typedef typename SMesh::template Property_map<Simplex, boost::int8_t>   Int8_map;
-  typedef typename SMesh::template Property_map<Simplex, boost::uint8_t>  Uint8_map;
+  typedef typename SMesh::template Property_map<Simplex, std::uint8_t>  Uint8_map;
   typedef typename SMesh::template Property_map<Simplex, boost::int16_t>  Int16_map;
-  typedef typename SMesh::template Property_map<Simplex, boost::uint16_t> Uint16_map;
+  typedef typename SMesh::template Property_map<Simplex, std::uint16_t> Uint16_map;
   typedef typename SMesh::template Property_map<Simplex, boost::int32_t>  Int32_map;
-  typedef typename SMesh::template Property_map<Simplex, boost::uint32_t> Uint32_map;
+  typedef typename SMesh::template Property_map<Simplex, std::uint32_t> Uint32_map;
   typedef typename SMesh::template Property_map<Simplex, boost::int64_t>  Int64_map;
-  typedef typename SMesh::template Property_map<Simplex, boost::uint64_t> Uint64_map;
+  typedef typename SMesh::template Property_map<Simplex, std::uint64_t> Uint64_map;
   typedef typename SMesh::template Property_map<Simplex, float>           Float_map;
   typedef typename SMesh::template Property_map<Simplex, double>          Double_map;
 
@@ -721,7 +721,7 @@ void fill_header(std::ostream& os, const Surface_mesh<Point>& sm,
     }
     {
       Uint8_map pmap;
-      boost::tie(pmap, okay) = sm.template property_map<Simplex,boost::uint8_t>(prop[i]);
+      boost::tie(pmap, okay) = sm.template property_map<Simplex,std::uint8_t>(prop[i]);
       if(okay)
       {
         os << "property uchar " << name << std::endl;
@@ -741,7 +741,7 @@ void fill_header(std::ostream& os, const Surface_mesh<Point>& sm,
     }
     {
       Uint16_map pmap;
-      boost::tie(pmap, okay) = sm.template property_map<Simplex,boost::uint16_t>(prop[i]);
+      boost::tie(pmap, okay) = sm.template property_map<Simplex,std::uint16_t>(prop[i]);
       if(okay)
       {
         os << "property ushort " << name << std::endl;
@@ -761,7 +761,7 @@ void fill_header(std::ostream& os, const Surface_mesh<Point>& sm,
     }
     {
       Uint32_map pmap;
-      boost::tie(pmap, okay) = sm.template property_map<Simplex,boost::uint32_t>(prop[i]);
+      boost::tie(pmap, okay) = sm.template property_map<Simplex,std::uint32_t>(prop[i]);
       if(okay)
       {
         os << "property uint " << name << std::endl;
@@ -781,11 +781,11 @@ void fill_header(std::ostream& os, const Surface_mesh<Point>& sm,
     }
     {
       Uint64_map pmap;
-      boost::tie(pmap, okay) = sm.template property_map<Simplex,boost::uint64_t>(prop[i]);
+      boost::tie(pmap, okay) = sm.template property_map<Simplex,std::uint64_t>(prop[i]);
       if(okay)
       {
         os << "property uint " << name << std::endl;
-        printers.push_back(new internal::Simple_property_printer<Simplex,Uint64_map,boost::uint32_t>(pmap));
+        printers.push_back(new internal::Simple_property_printer<Simplex,Uint64_map,std::uint32_t>(pmap));
         continue;
       }
     }

Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h

@@ -60,7 +60,7 @@ namespace CGAL {
     class SM_Index
     {
     public:
-    typedef boost::uint32_t size_type;
+    typedef std::uint32_t size_type;
         /// Constructor. %Default construction creates an invalid index.
         /// We write -1, which is <a href="https://en.cppreference.com/w/cpp/types/numeric_limits">
         /// <tt>(std::numeric_limits<size_type>::max)()</tt></a>
@@ -239,7 +239,7 @@ namespace CGAL {
     class SM_Edge_index
     {
     public:
-        typedef boost::uint32_t size_type;
+        typedef std::uint32_t size_type;
 
         SM_Edge_index() : halfedge_((std::numeric_limits<size_type>::max)()) { }
 
@@ -364,7 +364,7 @@ public:
     typedef P Point;
 
     /// The type used to represent an index.
-    typedef boost::uint32_t size_type;
+    typedef std::uint32_t size_type;
 
     ///@}
 

Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h

@@ -71,8 +71,8 @@ class SM_index_pmap
 {
 public:
   typedef boost::readable_property_map_tag category;
-  typedef boost::uint32_t                  value_type;
+  typedef std::uint32_t                  value_type;
-  typedef boost::uint32_t                  reference;
+  typedef std::uint32_t                  reference;
   typedef VEF                              key_type;
 
   value_type operator[](const key_type& vd) const
@@ -260,13 +260,13 @@ namespace internal {
      const TYPE& x)                                                \
  { return get(get(p, sm), x); }                                        \
 
-CGAL_SM_INTRINSIC_PROPERTY(boost::uint32_t, boost::vertex_index_t,
+CGAL_SM_INTRINSIC_PROPERTY(std::uint32_t, boost::vertex_index_t,
 SM_Vertex_index)
-CGAL_SM_INTRINSIC_PROPERTY(boost::uint32_t, boost::edge_index_t,
+CGAL_SM_INTRINSIC_PROPERTY(std::uint32_t, boost::edge_index_t,
 SM_Edge_index)
-CGAL_SM_INTRINSIC_PROPERTY(boost::uint32_t, boost::halfedge_index_t,
+CGAL_SM_INTRINSIC_PROPERTY(std::uint32_t, boost::halfedge_index_t,
 SM_Halfedge_index)
-CGAL_SM_INTRINSIC_PROPERTY(boost::uint32_t, boost::face_index_t,
+CGAL_SM_INTRINSIC_PROPERTY(std::uint32_t, boost::face_index_t,
 SM_Face_index)
 CGAL_SM_INTRINSIC_PROPERTY(Point&, CGAL::vertex_point_t, SM_Vertex_index)
 

Surface_mesh_topology/include/CGAL/Face_graph_wrapper.h

@@ -40,7 +40,7 @@ class Face_graph_wrapper
 public:
   typedef HEG_                    HEG;
   typedef Face_graph_wrapper<HEG> Self;
-  typedef boost::uint32_t /*std::size_t*/ size_type;
+  typedef std::uint32_t /*std::size_t*/ size_type;
   typedef Self                    Refs;
 
   struct Dart_container

Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Functors_for_face_graph_wrapper.h

@@ -71,7 +71,7 @@ struct Get_beta<HEG, 2>
 template<typename Mesh>
 struct Index_from_halfedge_descriptor
 {
-  typedef boost::uint32_t size_type;
+  typedef std::uint32_t size_type;
   typedef typename boost::template graph_traits<Mesh>::halfedge_descriptor
   halfedge_descriptor;
 
@@ -88,7 +88,7 @@ template<typename P>
 struct Index_from_halfedge_descriptor<CGAL::Surface_mesh<P> >
 {
   using Mesh=CGAL::Surface_mesh<P>;
-  typedef boost::uint32_t size_type;
+  typedef std::uint32_t size_type;
   typedef typename boost::template graph_traits<Mesh>::halfedge_descriptor
   halfedge_descriptor;
 
@@ -99,7 +99,7 @@ struct Index_from_halfedge_descriptor<CGAL::Surface_mesh<P> >
 template<typename Mesh>
 struct Halfedge_descriptor_from_index
 {
-  typedef boost::uint32_t size_type;
+  typedef std::uint32_t size_type;
   typedef typename boost::template graph_traits<Mesh>::halfedge_descriptor
   halfedge_descriptor;
 
@@ -115,7 +115,7 @@ template<typename P>
 struct Halfedge_descriptor_from_index<CGAL::Surface_mesh<P> >
 {
   using Mesh=CGAL::Surface_mesh<P>;
-  typedef boost::uint32_t size_type;
+  typedef std::uint32_t size_type;
   typedef typename boost::template graph_traits<Mesh>::halfedge_descriptor
   halfedge_descriptor;
 
@@ -126,7 +126,7 @@ struct Halfedge_descriptor_from_index<CGAL::Surface_mesh<P> >
 template<typename Mesh>
 struct Is_index_used
 {
-  typedef boost::uint32_t size_type;
+  typedef std::uint32_t size_type;
 
   static bool run(const Mesh& m, size_type i)
   { return i<m.size_of_halfedges(); }
@@ -135,7 +135,7 @@ template<typename P>
 struct Is_index_used<CGAL::Surface_mesh<P> >
 {
   using Mesh=CGAL::Surface_mesh<P>;
-  typedef boost::uint32_t size_type;
+  typedef std::uint32_t size_type;
 
   static bool run(const Mesh& m, size_type i)
   { return i<(m.number_of_halfedges()+m.number_of_removed_halfedges()) &&