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

boost::unit -> std::uint

This commit is contained in:
Sébastien Loriot 2023-04-23 18:40:39 +02:00
parent 8ad6096550
commit fc034c6a5d
26 changed files with 145 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

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

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

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

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

6
Number_types/include/CGAL/Mpzf.h
View File

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

8
Number_types/include/CGAL/known_bit_size_integers.h
View File

@ -38,15 +38,15 @@ namespace CGAL {
typedef boost::int16_t Integer16;
typedef boost::int32_t Integer32;
typedef boost::uint8_t UInteger8;
typedef boost::uint16_t UInteger16;
typedef boost::uint32_t UInteger32;
typedef std::uint8_t UInteger8;
typedef std::uint16_t UInteger16;
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

8
Number_types/test/Number_types/known_bit_size_integers.cpp
View File

@ -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(boost::uint16_t) == 2);
CGAL_static_assertion(sizeof(boost::uint32_t) == 4);
CGAL_static_assertion(sizeof(std::uint8_t) == 1);
CGAL_static_assertion(sizeof(std::uint16_t) == 2);
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;

2
Point_set_3/doc/Point_set_3/Point_set_3.txt
View File

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

2
Point_set_3/include/CGAL/Point_set_3.h
View File

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

30
Point_set_3/include/CGAL/Point_set_3/IO/PLY.h
View File

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

12
Polyhedron/demo/Polyhedron/Plugins/Classification/Cluster_classification.cpp
View File

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

12
Polyhedron/demo/Polyhedron/Plugins/Classification/Point_set_item_classification.cpp
View File

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

48
Polyhedron/demo/Polyhedron/Plugins/Display/Display_property_plugin.cpp
View File

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

6
Polyhedron/demo/Polyhedron/Scene_image_item.cpp
View File

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

4
Spatial_searching/include/CGAL/Kd_tree_node.h
View File

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

24
Stream_support/include/CGAL/IO/PLY.h
View File

@ -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")) &&
(element.has_property<boost::uint8_t>("green") || element.has_property<boost::uint8_t>("g")) &&
(element.has_property<boost::uint8_t>("blue") || element.has_property<boost::uint8_t>("b")))
if((element.has_property<std::uint8_t>("red") || element.has_property<std::uint8_t>("r")) &&
(element.has_property<std::uint8_t>("green") || element.has_property<std::uint8_t>("g")) &&
(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
{

34
Stream_support/include/CGAL/IO/PLY/PLY_reader.h
View File

@ -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")) &&
(element.has_property<boost::uint8_t>("green") || element.has_property<boost::uint8_t>("g")) &&
(element.has_property<boost::uint8_t>("blue") || element.has_property<boost::uint8_t>("b")))
if((element.has_property<std::uint8_t>("red") || element.has_property<std::uint8_t>("r")) &&
(element.has_property<std::uint8_t>("green") || element.has_property<std::uint8_t>("g")) &&
(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));
}

2
Stream_support/include/CGAL/IO/STL.h
View File

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

2
Stream_support/include/CGAL/IO/STL/STL_reader.h
View File

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

2
Surface_mesh/doc/Surface_mesh/Surface_mesh.txt
View File

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

38
Surface_mesh/include/CGAL/Surface_mesh/IO/PLY.h
View File

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

6
Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h
View File

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

12
Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h
View File

@ -71,8 +71,8 @@ class SM_index_pmap
{
public:
typedef boost::readable_property_map_tag category;
typedef boost::uint32_t value_type;
typedef boost::uint32_t reference;
typedef std::uint32_t value_type;
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)

2
Surface_mesh_topology/include/CGAL/Face_graph_wrapper.h
View File

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

12
Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Functors_for_face_graph_wrapper.h
View File

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