cxx.h
No OneTemporary
Actions

Size

27 KB

Referenced Files

None

Subscribers

None

cxx.h
View Options

	#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 / static_cast<typename Slice<T>::iterator::difference_type>(
	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

File Metadata

Mime Type: text/x-c++
Expires: Mon, Feb 2, 12:03 AM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 493933
Default Alt Text: cxx.h (27 KB)

cxx.hNo OneTemporaryActions

cxx.hView Options

File Metadata

Event Timeline

cxx.h
No OneTemporary
Actions

cxx.h
View Options