Use integer standard library types from std namespace
The implementation is not required to define these types in the global
namespace.
diff --git a/src/cxx.cc b/src/cxx.cc
index a11ba12..776663e 100644
--- a/src/cxx.cc
+++ b/src/cxx.cc
@@ -10,8 +10,8 @@
#include <vector>
extern "C" {
-void cxxbridge1$cxx_string$init(std::string *s, const uint8_t *ptr,
- size_t len) noexcept {
+void cxxbridge1$cxx_string$init(std::string *s, const std::uint8_t *ptr,
+ std::size_t len) noexcept {
new (s) std::string(reinterpret_cast<const char *>(ptr), len);
}
@@ -24,12 +24,12 @@
return s.data();
}
-size_t cxxbridge1$cxx_string$length(const std::string &s) noexcept {
+std::size_t cxxbridge1$cxx_string$length(const std::string &s) noexcept {
return s.length();
}
-void cxxbridge1$cxx_string$push(std::string &s, const uint8_t *ptr,
- size_t len) noexcept {
+void cxxbridge1$cxx_string$push(std::string &s, const std::uint8_t *ptr,
+ std::size_t len) noexcept {
s.append(reinterpret_cast<const char *>(ptr), len);
}
@@ -38,13 +38,13 @@
void cxxbridge1$string$clone(rust::String *self,
const rust::String &other) noexcept;
bool cxxbridge1$string$from(rust::String *self, const char *ptr,
- size_t len) noexcept;
+ std::size_t len) noexcept;
void cxxbridge1$string$drop(rust::String *self) noexcept;
const char *cxxbridge1$string$ptr(const rust::String *self) noexcept;
-size_t cxxbridge1$string$len(const rust::String *self) noexcept;
+std::size_t cxxbridge1$string$len(const rust::String *self) noexcept;
// rust::Str
-bool cxxbridge1$str$valid(const char *ptr, size_t len) noexcept;
+bool cxxbridge1$str$valid(const char *ptr, std::size_t len) noexcept;
} // extern "C"
namespace rust {
@@ -74,7 +74,7 @@
String::~String() noexcept { cxxbridge1$string$drop(this); }
-static void initString(String *self, const char *s, size_t len) {
+static void initString(String *self, const char *s, std::size_t len) {
if (!cxxbridge1$string$from(self, s, len)) {
panic<std::invalid_argument>("data for rust::String is not utf-8");
}
@@ -87,7 +87,7 @@
initString(this, s, std::strlen(s));
}
-String::String(const char *s, size_t len) {
+String::String(const char *s, std::size_t len) {
assert(s != nullptr || len == 0);
initString(this,
s == nullptr && len == 0 ? reinterpret_cast<const char *>(1) : s,
@@ -119,9 +119,13 @@
return cxxbridge1$string$ptr(this);
}
-size_t String::size() const noexcept { return cxxbridge1$string$len(this); }
+std::size_t String::size() const noexcept {
+ return cxxbridge1$string$len(this);
+}
-size_t String::length() const noexcept { return cxxbridge1$string$len(this); }
+std::size_t String::length() const noexcept {
+ return cxxbridge1$string$len(this);
+}
String::iterator String::begin() noexcept {
return const_cast<char *>(this->data());
@@ -177,7 +181,7 @@
Str::Str(const String &s) noexcept : ptr(s.data()), len(s.length()) {}
-static void initStr(const char *ptr, size_t len) {
+static void initStr(const char *ptr, std::size_t len) {
if (!cxxbridge1$str$valid(ptr, len)) {
panic<std::invalid_argument>("data for rust::Str is not utf-8");
}
@@ -192,7 +196,7 @@
initStr(this->ptr, this->len);
}
-Str::Str(const char *s, size_t len)
+Str::Str(const char *s, std::size_t len)
: ptr(s == nullptr && len == 0 ? reinterpret_cast<const char *>(1) : s),
len(len) {
assert(s != nullptr || len == 0);
@@ -258,12 +262,13 @@
// same here and these assertions are just here to explicitly document that.
// *Note that no assumption is made about C++ name mangling of signatures
// containing these types, not here nor anywhere in CXX.*
-static_assert(sizeof(size_t) == sizeof(uintptr_t), "unsupported size_t size");
-static_assert(alignof(size_t) == alignof(uintptr_t),
+static_assert(sizeof(std::size_t) == sizeof(std::uintptr_t),
+ "unsupported size_t size");
+static_assert(alignof(std::size_t) == alignof(std::uintptr_t),
"unsupported size_t alignment");
-static_assert(sizeof(rust::isize) == sizeof(intptr_t),
+static_assert(sizeof(rust::isize) == sizeof(std::intptr_t),
"unsupported ssize_t size");
-static_assert(alignof(rust::isize) == alignof(intptr_t),
+static_assert(alignof(rust::isize) == alignof(std::intptr_t),
"unsupported ssize_t alignment");
static_assert(std::is_trivially_copy_constructible<Str>::value,
@@ -272,40 +277,44 @@
"trivial operator=(const Str &)");
static_assert(std::is_trivially_destructible<Str>::value, "trivial ~Str()");
-static_assert(std::is_trivially_copy_constructible<Slice<const uint8_t>>::value,
- "trivial Slice(const Slice &)");
-static_assert(std::is_trivially_move_constructible<Slice<const uint8_t>>::value,
- "trivial Slice(Slice &&)");
-static_assert(std::is_trivially_copy_assignable<Slice<const uint8_t>>::value,
- "trivial Slice::operator=(const Slice &) for const slices");
-static_assert(std::is_trivially_move_assignable<Slice<const uint8_t>>::value,
- "trivial Slice::operator=(Slice &&)");
-static_assert(std::is_trivially_destructible<Slice<const uint8_t>>::value,
- "trivial ~Slice()");
-
-static_assert(std::is_trivially_copy_constructible<Slice<uint8_t>>::value,
- "trivial Slice(const Slice &)");
-static_assert(std::is_trivially_move_constructible<Slice<uint8_t>>::value,
- "trivial Slice(Slice &&)");
-static_assert(!std::is_copy_assignable<Slice<uint8_t>>::value,
- "delete Slice::operator=(const Slice &) for mut slices");
-static_assert(std::is_trivially_move_assignable<Slice<uint8_t>>::value,
- "trivial Slice::operator=(Slice &&)");
-static_assert(std::is_trivially_destructible<Slice<uint8_t>>::value,
- "trivial ~Slice()");
-
-static_assert(std::is_same<Vec<uint8_t>::const_iterator,
- Vec<const uint8_t>::iterator>::value,
- "Vec<T>::const_iterator == Vec<const T>::iterator");
-static_assert(std::is_same<Vec<const uint8_t>::const_iterator,
- Vec<const uint8_t>::iterator>::value,
- "Vec<const T>::const_iterator == Vec<const T>::iterator");
static_assert(
- !std::is_same<Vec<uint8_t>::const_iterator, Vec<uint8_t>::iterator>::value,
- "Vec<T>::const_iterator != Vec<T>::iterator");
+ std::is_trivially_copy_constructible<Slice<const std::uint8_t>>::value,
+ "trivial Slice(const Slice &)");
+static_assert(
+ std::is_trivially_move_constructible<Slice<const std::uint8_t>>::value,
+ "trivial Slice(Slice &&)");
+static_assert(
+ std::is_trivially_copy_assignable<Slice<const std::uint8_t>>::value,
+ "trivial Slice::operator=(const Slice &) for const slices");
+static_assert(
+ std::is_trivially_move_assignable<Slice<const std::uint8_t>>::value,
+ "trivial Slice::operator=(Slice &&)");
+static_assert(std::is_trivially_destructible<Slice<const std::uint8_t>>::value,
+ "trivial ~Slice()");
+
+static_assert(std::is_trivially_copy_constructible<Slice<std::uint8_t>>::value,
+ "trivial Slice(const Slice &)");
+static_assert(std::is_trivially_move_constructible<Slice<std::uint8_t>>::value,
+ "trivial Slice(Slice &&)");
+static_assert(!std::is_copy_assignable<Slice<std::uint8_t>>::value,
+ "delete Slice::operator=(const Slice &) for mut slices");
+static_assert(std::is_trivially_move_assignable<Slice<std::uint8_t>>::value,
+ "trivial Slice::operator=(Slice &&)");
+static_assert(std::is_trivially_destructible<Slice<std::uint8_t>>::value,
+ "trivial ~Slice()");
+
+static_assert(std::is_same<Vec<std::uint8_t>::const_iterator,
+ Vec<const std::uint8_t>::iterator>::value,
+ "Vec<T>::const_iterator == Vec<const T>::iterator");
+static_assert(std::is_same<Vec<const std::uint8_t>::const_iterator,
+ Vec<const std::uint8_t>::iterator>::value,
+ "Vec<const T>::const_iterator == Vec<const T>::iterator");
+static_assert(!std::is_same<Vec<std::uint8_t>::const_iterator,
+ Vec<std::uint8_t>::iterator>::value,
+ "Vec<T>::const_iterator != Vec<T>::iterator");
extern "C" {
-const char *cxxbridge1$error(const char *ptr, size_t len) {
+const char *cxxbridge1$error(const char *ptr, std::size_t len) {
char *copy = new char[len];
std::strncpy(copy, ptr, len);
return copy;
@@ -384,7 +393,7 @@
} // extern "C"
namespace {
-const size_t kMaxExpectedWordsInString = 8;
+const std::size_t kMaxExpectedWordsInString = 8;
static_assert(alignof(std::string) <= alignof(void *),
"unexpectedly large std::string alignment");
static_assert(sizeof(std::string) <= kMaxExpectedWordsInString * sizeof(void *),
@@ -392,12 +401,12 @@
} // namespace
#define STD_VECTOR_OPS(RUST_TYPE, CXX_TYPE) \
- size_t cxxbridge1$std$vector$##RUST_TYPE##$size( \
+ std::size_t cxxbridge1$std$vector$##RUST_TYPE##$size( \
const std::vector<CXX_TYPE> &s) noexcept { \
return s.size(); \
} \
const CXX_TYPE *cxxbridge1$std$vector$##RUST_TYPE##$get_unchecked( \
- const std::vector<CXX_TYPE> &s, size_t pos) noexcept { \
+ const std::vector<CXX_TYPE> &s, std::size_t pos) noexcept { \
return &s[pos]; \
} \
void cxxbridge1$unique_ptr$std$vector$##RUST_TYPE##$null( \
@@ -429,17 +438,17 @@
rust::Vec<CXX_TYPE> *ptr) noexcept; \
void cxxbridge1$rust_vec$##RUST_TYPE##$drop( \
rust::Vec<CXX_TYPE> *ptr) noexcept; \
- size_t cxxbridge1$rust_vec$##RUST_TYPE##$len( \
+ std::size_t cxxbridge1$rust_vec$##RUST_TYPE##$len( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
- size_t cxxbridge1$rust_vec$##RUST_TYPE##$capacity( \
+ std::size_t cxxbridge1$rust_vec$##RUST_TYPE##$capacity( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
const CXX_TYPE *cxxbridge1$rust_vec$##RUST_TYPE##$data( \
const rust::Vec<CXX_TYPE> *ptr) noexcept; \
void cxxbridge1$rust_vec$##RUST_TYPE##$reserve_total( \
- rust::Vec<CXX_TYPE> *ptr, size_t cap) noexcept; \
+ rust::Vec<CXX_TYPE> *ptr, std::size_t cap) noexcept; \
void cxxbridge1$rust_vec$##RUST_TYPE##$set_len(rust::Vec<CXX_TYPE> *ptr, \
- size_t len) noexcept; \
- size_t cxxbridge1$rust_vec$##RUST_TYPE##$stride() noexcept;
+ std::size_t len) noexcept; \
+ std::size_t cxxbridge1$rust_vec$##RUST_TYPE##$stride() noexcept;
#define RUST_VEC_OPS(RUST_TYPE, CXX_TYPE) \
template <> \
@@ -451,11 +460,11 @@
return cxxbridge1$rust_vec$##RUST_TYPE##$drop(this); \
} \
template <> \
- size_t Vec<CXX_TYPE>::size() const noexcept { \
+ std::size_t Vec<CXX_TYPE>::size() const noexcept { \
return cxxbridge1$rust_vec$##RUST_TYPE##$len(this); \
} \
template <> \
- size_t Vec<CXX_TYPE>::capacity() const noexcept { \
+ std::size_t Vec<CXX_TYPE>::capacity() const noexcept { \
return cxxbridge1$rust_vec$##RUST_TYPE##$capacity(this); \
} \
template <> \
@@ -463,15 +472,15 @@
return cxxbridge1$rust_vec$##RUST_TYPE##$data(this); \
} \
template <> \
- void Vec<CXX_TYPE>::reserve_total(size_t cap) noexcept { \
+ void Vec<CXX_TYPE>::reserve_total(std::size_t cap) noexcept { \
cxxbridge1$rust_vec$##RUST_TYPE##$reserve_total(this, cap); \
} \
template <> \
- void Vec<CXX_TYPE>::set_len(size_t len) noexcept { \
+ void Vec<CXX_TYPE>::set_len(std::size_t len) noexcept { \
cxxbridge1$rust_vec$##RUST_TYPE##$set_len(this, len); \
} \
template <> \
- size_t Vec<CXX_TYPE>::stride() noexcept { \
+ std::size_t Vec<CXX_TYPE>::stride() noexcept { \
return cxxbridge1$rust_vec$##RUST_TYPE##$stride(); \
}
@@ -505,20 +514,20 @@
// Usize and isize are the same type as one of the below.
#define FOR_EACH_NUMERIC(MACRO) \
- MACRO(u8, uint8_t) \
- MACRO(u16, uint16_t) \
- MACRO(u32, uint32_t) \
- MACRO(u64, uint64_t) \
- MACRO(i8, int8_t) \
- MACRO(i16, int16_t) \
- MACRO(i32, int32_t) \
- MACRO(i64, int64_t) \
+ MACRO(u8, std::uint8_t) \
+ MACRO(u16, std::uint16_t) \
+ MACRO(u32, std::uint32_t) \
+ MACRO(u64, std::uint64_t) \
+ MACRO(i8, std::int8_t) \
+ MACRO(i16, std::int16_t) \
+ MACRO(i32, std::int32_t) \
+ MACRO(i64, std::int64_t) \
MACRO(f32, float) \
MACRO(f64, double)
#define FOR_EACH_STD_VECTOR(MACRO) \
FOR_EACH_NUMERIC(MACRO) \
- MACRO(usize, size_t) \
+ MACRO(usize, std::size_t) \
MACRO(isize, rust::isize) \
MACRO(string, std::string)
@@ -530,7 +539,7 @@
#define FOR_EACH_SHARED_PTR(MACRO) \
FOR_EACH_NUMERIC(MACRO) \
- MACRO(usize, size_t) \
+ MACRO(usize, std::size_t) \
MACRO(isize, rust::isize) \
MACRO(string, std::string)