Differential D5230 Diff 17110 native/native_rust_library/cxx.h

Changeset View

Standalone View

native/native_rust_library/cxx.h

This file was added.

				#pragma once
				#include <algorithm>
				#include <array>
				#include <cassert>
				#include <cstddef>
				#include <cstdint>
				#include <exception>
				#include <initializer_list>
				#include <iosfwd>
				#include <iterator>
				#include <new>
				#include <stdexcept>
				#include <string>
				#include <type_traits>
				#include <utility>
				#include <vector>
				#if defined(_WIN32)
				#include <basetsd.h>
				#else
				#include <sys/types.h>
				#endif

				namespace rust {
				inline namespace cxxbridge1 {

				struct unsafe_bitcopy_t;

				namespace {
				template <typename T>
				class impl;
				}

				#ifndef CXXBRIDGE1_RUST_STRING
				#define CXXBRIDGE1_RUST_STRING
				// https://cxx.rs/binding/string.html
				class String final {
				public:
				String() noexcept;
				String(const String &) noexcept;
				String(String &&) noexcept;
				~String() noexcept;

				String(const std::string &);
				String(const char *);
				String(const char *, std::size_t);
				String(const char16_t *);
				String(const char16_t *, std::size_t);

				// Replace invalid Unicode data with the replacement character (U+FFFD).
				static String lossy(const std::string &) noexcept;
				static String lossy(const char *) noexcept;
				static String lossy(const char *, std::size_t) noexcept;
				static String lossy(const char16_t *) noexcept;
				static String lossy(const char16_t *, std::size_t) noexcept;

				String &operator=(const String &) &noexcept;
				String &operator=(String &&) &noexcept;

				explicit operator std::string() const;

				// Note: no null terminator.
				const char *data() const noexcept;
				std::size_t size() const noexcept;
				std::size_t length() const noexcept;
				bool empty() const noexcept;

				const char *c_str() noexcept;

				std::size_t capacity() const noexcept;
				void reserve(size_t new_cap) noexcept;

				using iterator = char *;
				iterator begin() noexcept;
				iterator end() noexcept;

				using const_iterator = const char *;
				const_iterator begin() const noexcept;
				const_iterator end() const noexcept;
				const_iterator cbegin() const noexcept;
				const_iterator cend() const noexcept;

				bool operator==(const String &) const noexcept;
				bool operator!=(const String &) const noexcept;
				bool operator<(const String &) const noexcept;
				bool operator<=(const String &) const noexcept;
				bool operator>(const String &) const noexcept;
				bool operator>=(const String &) const noexcept;

				void swap(String &) noexcept;

				// Internal API only intended for the cxxbridge code generator.
				String(unsafe_bitcopy_t, const String &) noexcept;

				private:
				struct lossy_t;
				String(lossy_t, const char *, std::size_t) noexcept;
				String(lossy_t, const char16_t *, std::size_t) noexcept;
				friend void swap(String &lhs, String &rhs) noexcept { lhs.swap(rhs); }

				// Size and alignment statically verified by rust_string.rs.
				std::array<std::uintptr_t, 3> repr;
				};
				#endif // CXXBRIDGE1_RUST_STRING

				#ifndef CXXBRIDGE1_RUST_STR
				#define CXXBRIDGE1_RUST_STR
				// https://cxx.rs/binding/str.html
				class Str final {
				public:
				Str() noexcept;
				Str(const String &) noexcept;
				Str(const std::string &);
				Str(const char *);
				Str(const char *, std::size_t);

				Str &operator=(const Str &) &noexcept = default;

				explicit operator std::string() const;

				// Note: no null terminator.
				const char *data() const noexcept;
				std::size_t size() const noexcept;
				std::size_t length() const noexcept;
				bool empty() const noexcept;

				// Important in order for System V ABI to pass in registers.
				Str(const Str &) noexcept = default;
				~Str() noexcept = default;

				using iterator = const char *;
				using const_iterator = const char *;
				const_iterator begin() const noexcept;
				const_iterator end() const noexcept;
				const_iterator cbegin() const noexcept;
				const_iterator cend() const noexcept;

				bool operator==(const Str &) const noexcept;
				bool operator!=(const Str &) const noexcept;
				bool operator<(const Str &) const noexcept;
				bool operator<=(const Str &) const noexcept;
				bool operator>(const Str &) const noexcept;
				bool operator>=(const Str &) const noexcept;

				void swap(Str &) noexcept;

				private:
				class uninit;
				Str(uninit) noexcept;
				friend impl<Str>;

				std::array<std::uintptr_t, 2> repr;
				};
				#endif // CXXBRIDGE1_RUST_STR

				#ifndef CXXBRIDGE1_RUST_SLICE
				namespace detail {
				template <bool>
				struct copy_assignable_if {};

				template <>
				struct copy_assignable_if<false> {
				copy_assignable_if() noexcept = default;
				copy_assignable_if(const copy_assignable_if &) noexcept = default;
				copy_assignable_if &operator=(const copy_assignable_if &) &noexcept = delete;
				copy_assignable_if &operator=(copy_assignable_if &&) &noexcept = default;
				};
				} // namespace detail

				// https://cxx.rs/binding/slice.html
				template <typename T>
				class Slice final
				: private detail::copy_assignable_if<std::is_const<T>::value> {
				public:
				using value_type = T;

				Slice() noexcept;
				Slice(T *, std::size_t count) noexcept;

				Slice &operator=(const Slice<T> &) &noexcept = default;
				Slice &operator=(Slice<T> &&) &noexcept = default;

				T *data() const noexcept;
				std::size_t size() const noexcept;
				std::size_t length() const noexcept;
				bool empty() const noexcept;

				T &operator[](std::size_t n) const noexcept;
				T &at(std::size_t n) const;
				T &front() const noexcept;
				T &back() const noexcept;

				// Important in order for System V ABI to pass in registers.
				Slice(const Slice<T> &) noexcept = default;
				~Slice() noexcept = default;

				class iterator;
				iterator begin() const noexcept;
				iterator end() const noexcept;

				void swap(Slice &) noexcept;

				private:
				class uninit;
				Slice(uninit) noexcept;
				friend impl<Slice>;
				friend void sliceInit(void , const void , std::size_t) noexcept;
				friend void slicePtr(const void ) noexcept;
				friend std::size_t sliceLen(const void *) noexcept;

				std::array<std::uintptr_t, 2> repr;
				};

				template <typename T>
				class Slice<T>::iterator final {
				public:
				using iterator_category = std::random_access_iterator_tag;
				using value_type = T;
				using difference_type = std::ptrdiff_t;
				using pointer = typename std::add_pointer<T>::type;
				using reference = typename std::add_lvalue_reference<T>::type;

				reference operator*() const noexcept;
				pointer operator->() const noexcept;
				reference operator[](difference_type) const noexcept;

				iterator &operator++() noexcept;
				iterator operator++(int) noexcept;
				iterator &operator--() noexcept;
				iterator operator--(int) noexcept;

				iterator &operator+=(difference_type) noexcept;
				iterator &operator-=(difference_type) noexcept;
				iterator operator+(difference_type) const noexcept;
				iterator operator-(difference_type) const noexcept;
				difference_type operator-(const iterator &) const noexcept;

				bool operator==(const iterator &) const noexcept;
				bool operator!=(const iterator &) const noexcept;
				bool operator<(const iterator &) const noexcept;
				bool operator<=(const iterator &) const noexcept;
				bool operator>(const iterator &) const noexcept;
				bool operator>=(const iterator &) const noexcept;

				private:
				friend class Slice;
				void *pos;
				std::size_t stride;
				};
				#endif // CXXBRIDGE1_RUST_SLICE

				#ifndef CXXBRIDGE1_RUST_BOX
				// https://cxx.rs/binding/box.html
				template <typename T>
				class Box final {
				public:
				using element_type = T;
				using const_pointer =
				typename std::add_pointer<typename std::add_const<T>::type>::type;
				using pointer = typename std::add_pointer<T>::type;

				Box() = delete;
				Box(Box &&) noexcept;
				~Box() noexcept;

				explicit Box(const T &);
				explicit Box(T &&);

				Box &operator=(Box &&) &noexcept;

				const T *operator->() const noexcept;
				const T &operator*() const noexcept;
				T *operator->() noexcept;
				T &operator*() noexcept;

				template <typename... Fields>
				static Box in_place(Fields &&...);

				void swap(Box &) noexcept;

				// Important: requires that `raw` came from an into_raw call. Do not pass a
				// pointer from `new` or any other source.
				static Box from_raw(T *) noexcept;

				T *into_raw() noexcept;

				/* Deprecated */ using value_type = element_type;

				private:
				class uninit;
				class allocation;
				Box(uninit) noexcept;
				void drop() noexcept;

				friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }

				T *ptr;
				};
				#endif // CXXBRIDGE1_RUST_BOX

				#ifndef CXXBRIDGE1_RUST_VEC
				// https://cxx.rs/binding/vec.html
				template <typename T>
				class Vec final {
				public:
				using value_type = T;

				Vec() noexcept;
				Vec(std::initializer_list<T>);
				Vec(const Vec &);
				Vec(Vec &&) noexcept;
				~Vec() noexcept;

				Vec &operator=(Vec &&) &noexcept;
				Vec &operator=(const Vec &) &;

				std::size_t size() const noexcept;
				bool empty() const noexcept;
				const T *data() const noexcept;
				T *data() noexcept;
				std::size_t capacity() const noexcept;

				const T &operator[](std::size_t n) const noexcept;
				const T &at(std::size_t n) const;
				const T &front() const noexcept;
				const T &back() const noexcept;

				T &operator[](std::size_t n) noexcept;
				T &at(std::size_t n);
				T &front() noexcept;
				T &back() noexcept;

				void reserve(std::size_t new_cap);
				void push_back(const T &value);
				void push_back(T &&value);
				template <typename... Args>
				void emplace_back(Args &&...args);
				void truncate(std::size_t len);
				void clear();

				using iterator = typename Slice<T>::iterator;
				iterator begin() noexcept;
				iterator end() noexcept;

				using const_iterator = typename Slice<const T>::iterator;
				const_iterator begin() const noexcept;
				const_iterator end() const noexcept;
				const_iterator cbegin() const noexcept;
				const_iterator cend() const noexcept;

				void swap(Vec &) noexcept;

				// Internal API only intended for the cxxbridge code generator.
				Vec(unsafe_bitcopy_t, const Vec &) noexcept;

				private:
				void reserve_total(std::size_t new_cap) noexcept;
				void set_len(std::size_t len) noexcept;
				void drop() noexcept;

				friend void swap(Vec &lhs, Vec &rhs) noexcept { lhs.swap(rhs); }

				// Size and alignment statically verified by rust_vec.rs.
				std::array<std::uintptr_t, 3> repr;
				};
				#endif // CXXBRIDGE1_RUST_VEC

				#ifndef CXXBRIDGE1_RUST_FN
				// https://cxx.rs/binding/fn.html
				template <typename Signature>
				class Fn;

				template <typename Ret, typename... Args>
				class Fn<Ret(Args...)> final {
				public:
				Ret operator()(Args... args) const noexcept;
				Fn operator*() const noexcept;

				private:
				Ret (trampoline)(Args..., void fn) noexcept;
				void *fn;
				};
				#endif // CXXBRIDGE1_RUST_FN

				#ifndef CXXBRIDGE1_RUST_ERROR
				#define CXXBRIDGE1_RUST_ERROR
				// https://cxx.rs/binding/result.html
				class Error final : public std::exception {
				public:
				Error(const Error &);
				Error(Error &&) noexcept;
				~Error() noexcept override;

				Error &operator=(const Error &) &;
				Error &operator=(Error &&) &noexcept;

				const char *what() const noexcept override;

				private:
				Error() noexcept = default;
				friend impl<Error>;
				const char *msg;
				std::size_t len;
				};
				#endif // CXXBRIDGE1_RUST_ERROR

				#ifndef CXXBRIDGE1_RUST_ISIZE
				#define CXXBRIDGE1_RUST_ISIZE
				#if defined(_WIN32)
				using isize = SSIZE_T;
				#else
				using isize = ssize_t;
				#endif
				#endif // CXXBRIDGE1_RUST_ISIZE

				std::ostream &operator<<(std::ostream &, const String &);
				std::ostream &operator<<(std::ostream &, const Str &);

				#ifndef CXXBRIDGE1_RUST_OPAQUE
				#define CXXBRIDGE1_RUST_OPAQUE
				// Base class of generated opaque Rust types.
				class Opaque {
				public:
				Opaque() = delete;
				Opaque(const Opaque &) = delete;
				~Opaque() = delete;
				};
				#endif // CXXBRIDGE1_RUST_OPAQUE

				template <typename T>
				std::size_t size_of();
				template <typename T>
				std::size_t align_of();

				// IsRelocatable<T> is used in assertions that a C++ type passed by value
				// between Rust and C++ is soundly relocatable by Rust.
				//
				// There may be legitimate reasons to opt out of the check for support of types
				// that the programmer knows are soundly Rust-movable despite not being
				// recognized as such by the C++ type system due to a move constructor or
				// destructor. To opt out of the relocatability check, do either of the
				// following things in any header used by `include!` in the bridge.
				//
				// --- if you define the type:
				// struct MyType {
				// ...
				// + using IsRelocatable = std::true_type;
				// };
				//
				// --- otherwise:
				// + template <>
				// + struct rust::IsRelocatable<MyType> : std::true_type {};
				template <typename T>
				struct IsRelocatable;

				using u8 = std::uint8_t;
				using u16 = std::uint16_t;
				using u32 = std::uint32_t;
				using u64 = std::uint64_t;
				using usize = std::size_t; // see static asserts in cxx.cc
				using i8 = std::int8_t;
				using i16 = std::int16_t;
				using i32 = std::int32_t;
				using i64 = std::int64_t;
				using f32 = float;
				using f64 = double;

				// Snake case aliases for use in code that uses this style for type names.
				using string = String;
				using str = Str;
				template <typename T>
				using slice = Slice<T>;
				template <typename T>
				using box = Box<T>;
				template <typename T>
				using vec = Vec<T>;
				using error = Error;
				template <typename Signature>
				using fn = Fn<Signature>;
				template <typename T>
				using is_relocatable = IsRelocatable<T>;



				////////////////////////////////////////////////////////////////////////////////
				/// end public API, begin implementation details

				#ifndef CXXBRIDGE1_PANIC
				#define CXXBRIDGE1_PANIC
				template <typename Exception>
				void panic [[noreturn]] (const char *msg);
				#endif // CXXBRIDGE1_PANIC

				#ifndef CXXBRIDGE1_RUST_FN
				#define CXXBRIDGE1_RUST_FN
				template <typename Ret, typename... Args>
				Ret Fn<Ret(Args...)>::operator()(Args... args) const noexcept {
				return (*this->trampoline)(std::forward<Args>(args)..., this->fn);
				}

				template <typename Ret, typename... Args>
				Fn<Ret(Args...)> Fn<Ret(Args...)>::operator*() const noexcept {
				return *this;
				}
				#endif // CXXBRIDGE1_RUST_FN

				#ifndef CXXBRIDGE1_RUST_BITCOPY_T
				#define CXXBRIDGE1_RUST_BITCOPY_T
				struct unsafe_bitcopy_t final {
				explicit unsafe_bitcopy_t() = default;
				};
				#endif // CXXBRIDGE1_RUST_BITCOPY_T

				#ifndef CXXBRIDGE1_RUST_BITCOPY
				#define CXXBRIDGE1_RUST_BITCOPY
				constexpr unsafe_bitcopy_t unsafe_bitcopy{};
				#endif // CXXBRIDGE1_RUST_BITCOPY

				#ifndef CXXBRIDGE1_RUST_SLICE
				#define CXXBRIDGE1_RUST_SLICE
				template <typename T>
				Slice<T>::Slice() noexcept {
				sliceInit(this, reinterpret_cast<void *>(align_of<T>()), 0);
				}

				template <typename T>
				Slice<T>::Slice(T *s, std::size_t count) noexcept {
				assert(s != nullptr \|\| count == 0);
				sliceInit(this,
				s == nullptr && count == 0
				? reinterpret_cast<void *>(align_of<T>())
				: const_cast<typename std::remove_const<T>::type *>(s),
				count);
				}

				template <typename T>
				T *Slice<T>::data() const noexcept {
				return reinterpret_cast<T *>(slicePtr(this));
				}

				template <typename T>
				std::size_t Slice<T>::size() const noexcept {
				return sliceLen(this);
				}

				template <typename T>
				std::size_t Slice<T>::length() const noexcept {
				return this->size();
				}

				template <typename T>
				bool Slice<T>::empty() const noexcept {
				return this->size() == 0;
				}

				template <typename T>
				T &Slice<T>::operator[](std::size_t n) const noexcept {
				assert(n < this->size());
				auto ptr = static_cast<char >(slicePtr(this)) + size_of<T>() n;
				return reinterpret_cast<T >(ptr);
				}

				template <typename T>
				T &Slice<T>::at(std::size_t n) const {
				if (n >= this->size()) {
				panic<std::out_of_range>("rust::Slice index out of range");
				}
				return (*this)[n];
				}

				template <typename T>
				T &Slice<T>::front() const noexcept {
				assert(!this->empty());
				return (*this)[0];
				}

				template <typename T>
				T &Slice<T>::back() const noexcept {
				assert(!this->empty());
				return (*this)[this->size() - 1];
				}

				template <typename T>
				typename Slice<T>::iterator::reference
				Slice<T>::iterator::operator*() const noexcept {
				return static_cast<T >(this->pos);
				}

				template <typename T>
				typename Slice<T>::iterator::pointer
				Slice<T>::iterator::operator->() const noexcept {
				return static_cast<T *>(this->pos);
				}

				template <typename T>
				typename Slice<T>::iterator::reference Slice<T>::iterator::operator[](
				typename Slice<T>::iterator::difference_type n) const noexcept {
				auto ptr = static_cast<char >(this->pos) + this->stride n;
				return reinterpret_cast<T >(ptr);
				}

				template <typename T>
				typename Slice<T>::iterator &Slice<T>::iterator::operator++() noexcept {
				this->pos = static_cast<char *>(this->pos) + this->stride;
				return *this;
				}

				template <typename T>
				typename Slice<T>::iterator Slice<T>::iterator::operator++(int) noexcept {
				auto ret = iterator(*this);
				this->pos = static_cast<char *>(this->pos) + this->stride;
				return ret;
				}

				template <typename T>
				typename Slice<T>::iterator &Slice<T>::iterator::operator--() noexcept {
				this->pos = static_cast<char *>(this->pos) - this->stride;
				return *this;
				}

				template <typename T>
				typename Slice<T>::iterator Slice<T>::iterator::operator--(int) noexcept {
				auto ret = iterator(*this);
				this->pos = static_cast<char *>(this->pos) - this->stride;
				return ret;
				}

				template <typename T>
				typename Slice<T>::iterator &Slice<T>::iterator::operator+=(
				typename Slice<T>::iterator::difference_type n) noexcept {
				this->pos = static_cast<char >(this->pos) + this->stride n;
				return *this;
				}

				template <typename T>
				typename Slice<T>::iterator &Slice<T>::iterator::operator-=(
				typename Slice<T>::iterator::difference_type n) noexcept {
				this->pos = static_cast<char >(this->pos) - this->stride n;
				return *this;
				}

				template <typename T>
				typename Slice<T>::iterator Slice<T>::iterator::operator+(
				typename Slice<T>::iterator::difference_type n) const noexcept {
				auto ret = iterator(*this);
				ret.pos = static_cast<char >(this->pos) + this->stride n;
				return ret;
				}

				template <typename T>
				typename Slice<T>::iterator Slice<T>::iterator::operator-(
				typename Slice<T>::iterator::difference_type n) const noexcept {
				auto ret = iterator(*this);
				ret.pos = static_cast<char >(this->pos) - this->stride n;
				return ret;
				}

				template <typename T>
				typename Slice<T>::iterator::difference_type
				Slice<T>::iterator::operator-(const iterator &other) const noexcept {
				auto diff = std::distance(static_cast<char *>(other.pos),
				static_cast<char *>(this->pos));
				return diff / this->stride;
				}

				template <typename T>
				bool Slice<T>::iterator::operator==(const iterator &other) const noexcept {
				return this->pos == other.pos;
				}

				template <typename T>
				bool Slice<T>::iterator::operator!=(const iterator &other) const noexcept {
				return this->pos != other.pos;
				}

				template <typename T>
				bool Slice<T>::iterator::operator<(const iterator &other) const noexcept {
				return this->pos < other.pos;
				}

				template <typename T>
				bool Slice<T>::iterator::operator<=(const iterator &other) const noexcept {
				return this->pos <= other.pos;
				}

				template <typename T>
				bool Slice<T>::iterator::operator>(const iterator &other) const noexcept {
				return this->pos > other.pos;
				}

				template <typename T>
				bool Slice<T>::iterator::operator>=(const iterator &other) const noexcept {
				return this->pos >= other.pos;
				}

				template <typename T>
				typename Slice<T>::iterator Slice<T>::begin() const noexcept {
				iterator it;
				it.pos = slicePtr(this);
				it.stride = size_of<T>();
				return it;
				}

				template <typename T>
				typename Slice<T>::iterator Slice<T>::end() const noexcept {
				iterator it = this->begin();
				it.pos = static_cast<char >(it.pos) + it.stride this->size();
				return it;
				}

				template <typename T>
				void Slice<T>::swap(Slice &rhs) noexcept {
				std::swap(*this, rhs);
				}
				#endif // CXXBRIDGE1_RUST_SLICE

				#ifndef CXXBRIDGE1_RUST_BOX
				#define CXXBRIDGE1_RUST_BOX
				template <typename T>
				class Box<T>::uninit {};

				template <typename T>
				class Box<T>::allocation {
				static T *alloc() noexcept;
				static void dealloc(T *) noexcept;

				public:
				allocation() noexcept : ptr(alloc()) {}
				~allocation() noexcept {
				if (this->ptr) {
				dealloc(this->ptr);
				}
				}
				T *ptr;
				};

				template <typename T>
				Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
				other.ptr = nullptr;
				}

				template <typename T>
				Box<T>::Box(const T &val) {
				allocation alloc;
				::new (alloc.ptr) T(val);
				this->ptr = alloc.ptr;
				alloc.ptr = nullptr;
				}

				template <typename T>
				Box<T>::Box(T &&val) {
				allocation alloc;
				::new (alloc.ptr) T(std::move(val));
				this->ptr = alloc.ptr;
				alloc.ptr = nullptr;
				}

				template <typename T>
				Box<T>::~Box() noexcept {
				if (this->ptr) {
				this->drop();
				}
				}

				template <typename T>
				Box<T> &Box<T>::operator=(Box &&other) &noexcept {
				if (this->ptr) {
				this->drop();
				}
				this->ptr = other.ptr;
				other.ptr = nullptr;
				return *this;
				}

				template <typename T>
				const T *Box<T>::operator->() const noexcept {
				return this->ptr;
				}

				template <typename T>
				const T &Box<T>::operator*() const noexcept {
				return *this->ptr;
				}

				template <typename T>
				T *Box<T>::operator->() noexcept {
				return this->ptr;
				}

				template <typename T>
				T &Box<T>::operator*() noexcept {
				return *this->ptr;
				}

				template <typename T>
				template <typename... Fields>
				Box<T> Box<T>::in_place(Fields &&...fields) {
				allocation alloc;
				auto ptr = alloc.ptr;
				::new (ptr) T{std::forward<Fields>(fields)...};
				alloc.ptr = nullptr;
				return from_raw(ptr);
				}

				template <typename T>
				void Box<T>::swap(Box &rhs) noexcept {
				using std::swap;
				swap(this->ptr, rhs.ptr);
				}

				template <typename T>
				Box<T> Box<T>::from_raw(T *raw) noexcept {
				Box box = uninit{};
				box.ptr = raw;
				return box;
				}

				template <typename T>
				T *Box<T>::into_raw() noexcept {
				T *raw = this->ptr;
				this->ptr = nullptr;
				return raw;
				}

				template <typename T>
				Box<T>::Box(uninit) noexcept {}
				#endif // CXXBRIDGE1_RUST_BOX

				#ifndef CXXBRIDGE1_RUST_VEC
				#define CXXBRIDGE1_RUST_VEC
				template <typename T>
				Vec<T>::Vec(std::initializer_list<T> init) : Vec{} {
				this->reserve_total(init.size());
				std::move(init.begin(), init.end(), std::back_inserter(*this));
				}

				template <typename T>
				Vec<T>::Vec(const Vec &other) : Vec() {
				this->reserve_total(other.size());
				std::copy(other.begin(), other.end(), std::back_inserter(*this));
				}

				template <typename T>
				Vec<T>::Vec(Vec &&other) noexcept : repr(other.repr) {
				new (&other) Vec();
				}

				template <typename T>
				Vec<T>::~Vec() noexcept {
				this->drop();
				}

				template <typename T>
				Vec<T> &Vec<T>::operator=(Vec &&other) &noexcept {
				this->drop();
				this->repr = other.repr;
				new (&other) Vec();
				return *this;
				}

				template <typename T>
				Vec<T> &Vec<T>::operator=(const Vec &other) & {
				if (this != &other) {
				this->drop();
				new (this) Vec(other);
				}
				return *this;
				}

				template <typename T>
				bool Vec<T>::empty() const noexcept {
				return this->size() == 0;
				}

				template <typename T>
				T *Vec<T>::data() noexcept {
				return const_cast<T >(const_cast<const Vec<T> >(this)->data());
				}

				template <typename T>
				const T &Vec<T>::operator[](std::size_t n) const noexcept {
				assert(n < this->size());
				auto data = reinterpret_cast<const char *>(this->data());
				return reinterpret_cast<const T >(data + n * size_of<T>());
				}

				template <typename T>
				const T &Vec<T>::at(std::size_t n) const {
				if (n >= this->size()) {
				panic<std::out_of_range>("rust::Vec index out of range");
				}
				return (*this)[n];
				}

				template <typename T>
				const T &Vec<T>::front() const noexcept {
				assert(!this->empty());
				return (*this)[0];
				}

				template <typename T>
				const T &Vec<T>::back() const noexcept {
				assert(!this->empty());
				return (*this)[this->size() - 1];
				}

				template <typename T>
				T &Vec<T>::operator[](std::size_t n) noexcept {
				assert(n < this->size());
				auto data = reinterpret_cast<char *>(this->data());
				return reinterpret_cast<T >(data + n * size_of<T>());
				}

				template <typename T>
				T &Vec<T>::at(std::size_t n) {
				if (n >= this->size()) {
				panic<std::out_of_range>("rust::Vec index out of range");
				}
				return (*this)[n];
				}

				template <typename T>
				T &Vec<T>::front() noexcept {
				assert(!this->empty());
				return (*this)[0];
				}

				template <typename T>
				T &Vec<T>::back() noexcept {
				assert(!this->empty());
				return (*this)[this->size() - 1];
				}

				template <typename T>
				void Vec<T>::reserve(std::size_t new_cap) {
				this->reserve_total(new_cap);
				}

				template <typename T>
				void Vec<T>::push_back(const T &value) {
				this->emplace_back(value);
				}

				template <typename T>
				void Vec<T>::push_back(T &&value) {
				this->emplace_back(std::move(value));
				}

				template <typename T>
				template <typename... Args>
				void Vec<T>::emplace_back(Args &&...args) {
				auto size = this->size();
				this->reserve_total(size + 1);
				::new (reinterpret_cast<T >(reinterpret_cast<char >(this->data()) +
				size * size_of<T>()))
				T(std::forward<Args>(args)...);
				this->set_len(size + 1);
				}

				template <typename T>
				void Vec<T>::clear() {
				this->truncate(0);
				}

				template <typename T>
				typename Vec<T>::iterator Vec<T>::begin() noexcept {
				return Slice<T>(this->data(), this->size()).begin();
				}

				template <typename T>
				typename Vec<T>::iterator Vec<T>::end() noexcept {
				return Slice<T>(this->data(), this->size()).end();
				}

				template <typename T>
				typename Vec<T>::const_iterator Vec<T>::begin() const noexcept {
				return this->cbegin();
				}

				template <typename T>
				typename Vec<T>::const_iterator Vec<T>::end() const noexcept {
				return this->cend();
				}

				template <typename T>
				typename Vec<T>::const_iterator Vec<T>::cbegin() const noexcept {
				return Slice<const T>(this->data(), this->size()).begin();
				}

				template <typename T>
				typename Vec<T>::const_iterator Vec<T>::cend() const noexcept {
				return Slice<const T>(this->data(), this->size()).end();
				}

				template <typename T>
				void Vec<T>::swap(Vec &rhs) noexcept {
				using std::swap;
				swap(this->repr, rhs.repr);
				}

				// Internal API only intended for the cxxbridge code generator.
				template <typename T>
				Vec<T>::Vec(unsafe_bitcopy_t, const Vec &bits) noexcept : repr(bits.repr) {}
				#endif // CXXBRIDGE1_RUST_VEC

				#ifndef CXXBRIDGE1_IS_COMPLETE
				#define CXXBRIDGE1_IS_COMPLETE
				namespace detail {
				namespace {
				template <typename T, typename = std::size_t>
				struct is_complete : std::false_type {};
				template <typename T>
				struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
				} // namespace
				} // namespace detail
				#endif // CXXBRIDGE1_IS_COMPLETE

				#ifndef CXXBRIDGE1_LAYOUT
				#define CXXBRIDGE1_LAYOUT
				class layout {
				template <typename T>
				friend std::size_t size_of();
				template <typename T>
				friend std::size_t align_of();
				template <typename T>
				static typename std::enable_if<std::is_base_of<Opaque, T>::value,
				std::size_t>::type
				do_size_of() {
				return T::layout::size();
				}
				template <typename T>
				static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
				std::size_t>::type
				do_size_of() {
				return sizeof(T);
				}
				template <typename T>
				static
				typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
				size_of() {
				return do_size_of<T>();
				}
				template <typename T>
				static typename std::enable_if<std::is_base_of<Opaque, T>::value,
				std::size_t>::type
				do_align_of() {
				return T::layout::align();
				}
				template <typename T>
				static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
				std::size_t>::type
				do_align_of() {
				return alignof(T);
				}
				template <typename T>
				static
				typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
				align_of() {
				return do_align_of<T>();
				}
				};

				template <typename T>
				std::size_t size_of() {
				return layout::size_of<T>();
				}

				template <typename T>
				std::size_t align_of() {
				return layout::align_of<T>();
				}
				#endif // CXXBRIDGE1_LAYOUT

				#ifndef CXXBRIDGE1_RELOCATABLE
				#define CXXBRIDGE1_RELOCATABLE
				namespace detail {
				template <typename... Ts>
				struct make_void {
				using type = void;
				};

				template <typename... Ts>
				using void_t = typename make_void<Ts...>::type;

				template <typename Void, template <typename...> class, typename...>
				struct detect : std::false_type {};
				template <template <typename...> class T, typename... A>
				struct detect<void_t<T<A...>>, T, A...> : std::true_type {};

				template <template <typename...> class T, typename... A>
				using is_detected = detect<void, T, A...>;

				template <typename T>
				using detect_IsRelocatable = typename T::IsRelocatable;

				template <typename T>
				struct get_IsRelocatable
				: std::is_same<typename T::IsRelocatable, std::true_type> {};
				} // namespace detail

				template <typename T>
				struct IsRelocatable
				: std::conditional<
				detail::is_detected<detail::detect_IsRelocatable, T>::value,
				detail::get_IsRelocatable<T>,
				std::integral_constant<
				bool, std::is_trivially_move_constructible<T>::value &&
				std::is_trivially_destructible<T>::value>>::type {};
				#endif // CXXBRIDGE1_RELOCATABLE

				} // namespace cxxbridge1
				} // namespace rust