---
source: colvec-derive/src/lib.rs
expression: formatted
---
pub struct TestColVec<A: ::colvec::alloc::Allocator = ::colvec::alloc::Global> {
buf: ::colvec::raw::RawColVec<4usize, Test, A>,
len: usize,
}
impl ::colvec::raw::StructInfo<4usize> for Test {
const LAYOUT: ::core::alloc::Layout = unsafe {
let size = Self::FIELDS.size();
let align = align_of::<Test>();
::core::alloc::Layout::from_size_align_unchecked(size, align)
};
const FIELDS: ::colvec::fields::Fields<4usize> = ::colvec::fields::Fields::from_sizes([
size_of::<u8>(),
size_of::<Option<u8>>(),
size_of::<i16>(),
size_of::<u32>(),
]);
}
impl<A: ::colvec::alloc::Allocator> Drop for TestColVec<A> {
fn drop(&mut self) {
unsafe {
::core::ptr::drop_in_place(self.field0_slice_mut());
::core::ptr::drop_in_place(self.field1_slice_mut());
::core::ptr::drop_in_place(self.field2_slice_mut());
::core::ptr::drop_in_place(self.field3_slice_mut());
}
}
}
impl<A: ::colvec::alloc::Allocator + Clone> Clone for TestColVec<A>
where
u8: Clone,
Option<u8>: Clone,
i16: Clone,
u32: Clone,
{
fn clone(&self) -> Self {
let alloc = self.allocator().clone();
struct DropGuard<'a, A: ::colvec::alloc::Allocator> {
colvec: &'a mut TestColVec<A>,
num_init: usize,
}
impl<'a, A: ::colvec::alloc::Allocator> Drop for DropGuard<'a, A> {
#[inline]
fn drop(&mut self) {
unsafe {
self.colvec.set_len(self.num_init);
}
}
}
let mut colvec = Self::with_capacity_in(self.len(), alloc);
let mut guard = DropGuard {
colvec: &mut colvec,
num_init: 0,
};
let field0_slice = self.field0_slice();
let field1_slice = self.field1_slice();
let field2_slice = self.field2_slice();
let field3_slice = self.field3_slice();
let cap = guard.colvec.buf.capacity();
let ptr = guard.colvec.as_mut_ptr();
let field0_slice_mut = unsafe {
::core::slice::from_raw_parts_mut(
ptr
.add(
cap
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(0usize),
)
.cast::<::core::mem::MaybeUninit<u8>>(),
self.len,
)
};
let field1_slice_mut = unsafe {
::core::slice::from_raw_parts_mut(
ptr
.add(
cap
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(1usize),
)
.cast::<::core::mem::MaybeUninit<Option<u8>>>(),
self.len,
)
};
let field2_slice_mut = unsafe {
::core::slice::from_raw_parts_mut(
ptr
.add(
cap
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(2usize),
)
.cast::<::core::mem::MaybeUninit<i16>>(),
self.len,
)
};
let field3_slice_mut = unsafe {
::core::slice::from_raw_parts_mut(
ptr
.add(
cap
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(3usize),
)
.cast::<::core::mem::MaybeUninit<u32>>(),
self.len,
)
};
for i in 0..self.len() {
guard.num_init = i;
let field0 = unsafe { field0_slice.get_unchecked(i) }.clone();
let field1 = unsafe { field1_slice.get_unchecked(i) }.clone();
let field2 = unsafe { field2_slice.get_unchecked(i) }.clone();
let field3 = unsafe { field3_slice.get_unchecked(i) }.clone();
unsafe { field0_slice_mut.get_unchecked_mut(i).write(field0) };
unsafe { field1_slice_mut.get_unchecked_mut(i).write(field1) };
unsafe { field2_slice_mut.get_unchecked_mut(i).write(field2) };
unsafe { field3_slice_mut.get_unchecked_mut(i).write(field3) };
}
::core::mem::forget(guard);
unsafe {
colvec.set_len(self.len());
}
colvec
}
}
impl<A: ::colvec::alloc::Allocator> TestColVec<A> {
#[inline]
pub const fn new_in(alloc: A) -> Self {
Self {
buf: ::colvec::raw::RawColVec::new_in(alloc),
len: 0,
}
}
#[inline]
#[track_caller]
pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
Self {
buf: ::colvec::raw::RawColVec::with_capacity_in(capacity, alloc),
len: 0,
}
}
#[inline]
pub unsafe fn from_raw_parts_in(
ptr: *mut u8,
length: usize,
capacity: usize,
alloc: A,
) -> Self {
unsafe {
Self {
buf: ::colvec::raw::RawColVec::from_raw_parts_in(ptr, capacity, alloc),
len: length,
}
}
}
#[must_use = "losing the pointer will leak memory"]
pub fn into_raw_parts(self) -> (*mut u8, usize, usize) {
let mut me = ::core::mem::ManuallyDrop::new(self);
(me.as_mut_ptr(), me.len(), me.capacity())
}
#[must_use = "losing the pointer will leak memory"]
pub fn into_raw_parts_with_alloc(self) -> (*mut u8, usize, usize, A) {
let mut me = ::core::mem::ManuallyDrop::new(self);
let len = me.len();
let capacity = me.capacity();
let ptr = me.as_mut_ptr();
let alloc = unsafe { ::core::ptr::read(me.allocator()) };
(ptr, len, capacity, alloc)
}
#[inline]
pub const fn capacity(&self) -> usize {
self.buf.capacity()
}
#[track_caller]
pub fn reserve(&mut self, additional: usize) {
self.buf.reserve(self.len, additional);
}
#[inline]
const fn as_ptr(&self) -> *const u8 {
self.buf.ptr()
}
#[inline]
const fn as_mut_ptr(&mut self) -> *mut u8 {
self.buf.ptr()
}
#[inline]
pub fn allocator(&self) -> &A {
self.buf.allocator()
}
#[inline]
pub unsafe fn set_len(&mut self, new_len: usize) {
debug_assert!(new_len <= self.capacity());
self.len = new_len;
}
pub fn push(&mut self, value: Test) {
let len = self.len;
if len == self.buf.capacity() {
self.buf.grow_one();
}
unsafe {
let end = self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(0usize),
)
.cast::<u8>()
.add(len);
::core::ptr::write(end, value.field0);
let end = self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(1usize),
)
.cast::<Option<u8>>()
.add(len);
::core::ptr::write(end, value.field1);
let end = self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(2usize),
)
.cast::<i16>()
.add(len);
::core::ptr::write(end, value.field2);
let end = self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(3usize),
)
.cast::<u32>()
.add(len);
::core::ptr::write(end, value.field3);
}
self.len = len + 1;
}
#[inline]
#[track_caller]
pub fn append(&mut self, other: &mut Self) {
unsafe {
self.append_elements(other);
other.set_len(0);
}
}
/// Appends elements to `self` from other buffer.
#[inline]
#[track_caller]
unsafe fn append_elements(&mut self, other: &Self) {
let count = other.len();
self.reserve(count);
let len = self.len();
unsafe {
<Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.move_fields(
other.as_ptr(),
self.as_mut_ptr(),
other.capacity(),
self.capacity(),
len,
count,
)
}
self.len += count;
}
#[inline]
pub const fn len(&self) -> usize {
self.len
}
}
impl<A: ::colvec::alloc::Allocator> TestColVec<A> {
#[inline]
pub const fn field0_slice(&self) -> &[u8] {
unsafe {
::core::slice::from_raw_parts(
self
.as_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(0usize),
)
.cast::<u8>(),
self.len,
)
}
}
#[inline]
pub const fn field0_slice_mut(&mut self) -> &mut [u8] {
unsafe {
::core::slice::from_raw_parts_mut(
self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(0usize),
)
.cast::<u8>(),
self.len,
)
}
}
#[inline]
pub const fn field1_slice(&self) -> &[Option<u8>] {
unsafe {
::core::slice::from_raw_parts(
self
.as_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(1usize),
)
.cast::<Option<u8>>(),
self.len,
)
}
}
#[inline]
pub const fn field1_slice_mut(&mut self) -> &mut [Option<u8>] {
unsafe {
::core::slice::from_raw_parts_mut(
self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(1usize),
)
.cast::<Option<u8>>(),
self.len,
)
}
}
#[inline]
pub const fn field2_slice(&self) -> &[i16] {
unsafe {
::core::slice::from_raw_parts(
self
.as_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(2usize),
)
.cast::<i16>(),
self.len,
)
}
}
#[inline]
pub const fn field2_slice_mut(&mut self) -> &mut [i16] {
unsafe {
::core::slice::from_raw_parts_mut(
self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(2usize),
)
.cast::<i16>(),
self.len,
)
}
}
#[inline]
pub const fn field3_slice(&self) -> &[u32] {
unsafe {
::core::slice::from_raw_parts(
self
.as_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(3usize),
)
.cast::<u32>(),
self.len,
)
}
}
#[inline]
pub const fn field3_slice_mut(&mut self) -> &mut [u32] {
unsafe {
::core::slice::from_raw_parts_mut(
self
.as_mut_ptr()
.add(
self.buf.capacity()
* <Test as ::colvec::raw::StructInfo<4usize>>::FIELDS
.offset_of(3usize),
)
.cast::<u32>(),
self.len,
)
}
}
}
impl TestColVec<::colvec::alloc::Global> {
#[inline]
#[must_use]
pub const fn new() -> Self {
Self {
buf: ::colvec::raw::RawColVec::new_in(::colvec::alloc::Global),
len: 0,
}
}
#[inline]
#[must_use]
#[track_caller]
pub fn with_capacity(capacity: usize) -> Self {
Self::with_capacity_in(capacity, ::colvec::alloc::Global)
}
#[inline]
pub unsafe fn from_raw_parts(ptr: *mut u8, length: usize, capacity: usize) -> Self {
unsafe {
Self::from_raw_parts_in(ptr, length, capacity, ::colvec::alloc::Global)
}
}
}