Struct rel_alloc::vec::RelVec

#[repr(C)]
pub struct RelVec<T, A: RawRegionalAllocator, B: Basis = DefaultBasis> { /* private fields */ }

A relative counterpart to Vec.

Implementations

impl<T, A: RawRegionalAllocator, B: Basis> RelVec<T, A, B>

pub fn is_empty(&self) -> bool

Returns true if the RelVec contains no elements.

pub fn len(&self) -> usize

Returns the number of elements in the RelVec.

pub fn as_ptr(this: Ref<'_, Self>) -> *const T

Returns a raw pointer to the RelVec’s buffer, or a dangling raw pointer valid for zero sized reads if the RelVec didn’t allocate.

pub fn as_mut_ptr(this: Mut<'_, Self>) -> *mut T

Returns an unsafe mutable pointer to the RelVec’s buffer, or a dangling raw pointer valid for zero sized reads if the RelVec didn’t allocate.

pub unsafe fn set_len(this: Mut<'_, Self>, new_len: usize)

Forces the length of the vector to new_len.

Safety

• new_len must be less than or equal to capacity().
• The elements at old_len..new_len must be initialized.

pub fn capacity(&self) -> usize

Returns the maximum number of elements the RelVec can contain before resizing.

pub fn allocator(this: Ref<'_, Self>) -> Ref<'_, A>

Returns a reference to the underlying allocator.

pub fn as_slice(this: Ref<'_, Self>) -> Ref<'_, [T]>

Returns a Ref to a slice of the elements in the RelVec.

pub fn reserve(this: Mut<'_, Self>, additional: usize)where
    T: Move<A::Region>,

Reserves capacity for at least additional more elements to be inserted in the given RelVec<T>. The collection may reserve more space to speculatively avoid frequent reallocations. After calling reserve, the capacity will be greater than or equal to self.len() + additional. Does nothing if capacity is already sufficient.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn push<E>(this: Mut<'_, Self>, value: E)where
    T: Move<A::Region>,
    E: Emplace<T, A::Region>,

Appends an element to the back of a collection.

Panics

Panics if the new capacity exceeds isize::MAX bytes.

pub fn extend<I>(this: Mut<'_, Self>, values: I)where
    T: Move<A::Region>,
    I: Iterator,
    I::Item: Emplace<T, A::Region>,

Extends the RelVec with the contents of an iterator.

pub fn clear(this: Mut<'_, Self>)where
    T: DropRaw,

Clears the RelVec, removing all values.

Note that this method has no effect on the allocated capacity of the RelVec.

Trait Implementations

impl<T, A, B> DebugRaw for RelVec<T, A, B>where
    T: DebugRaw,
    A: RawRegionalAllocator,
    B: Basis,

fn fmt_raw(this: Ref<'_, Self>, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, A: RawRegionalAllocator, B: Basis> DerefMutRaw for RelVec<T, A, B>

fn deref_mut_raw(this: Mut<'_, Self>) -> Mut<'_, [T]>

Mutably dereferences the value.

impl<T, A: RawRegionalAllocator, B: Basis> DerefRaw for RelVec<T, A, B>

type Target = [T]

The resulting type after dereferencing.

fn deref_raw(this: Ref<'_, Self>) -> Ref<'_, [T]>

Dereferences the value.

impl<T, A, B> DropRaw for RelVec<T, A, B>where
    T: DropRaw,
    A: RawRegionalAllocator + DropRaw,
    B: Basis,
    <B as Basis>::Usize: DropRaw,

unsafe fn drop_raw(this: Mut<'_, Self>)

Drops the value pointed to by this.

impl<T, A, B, R> Emplace<RelVec<T, A, B>, <R as RegionalAllocator>::Region> for New<R>where
    T: DropRaw,
    A: DropRaw + RawRegionalAllocator<Region = R::Region>,
    B: Basis,
    <B as Basis>::Usize: DropRaw,
    R: RelAllocator<A>,

fn emplaced_meta(&self) -> <RelVec<T, A, B> as Pointee>::Metadata

Returns the metadata of the T that this emplaces.

unsafe fn emplace_unsized_unchecked(
    self,
    out: In<Slot<'_, RelVec<T, A, B>>, R::Region>
)

Emplaces a value into a given slot within some memory region.

impl<T, A, B, R> Emplace<RelVec<T, A, B>, <R as RegionalAllocator>::Region> for WithCapacity<R>where
    T: DropRaw,
    A: DropRaw + RawRegionalAllocator<Region = R::Region>,
    B: Basis,
    <B as Basis>::Usize: DropRaw,
    R: RelAllocator<A>,

fn emplaced_meta(&self) -> <RelVec<T, A, B> as Pointee>::Metadata

Returns the metadata of the T that this emplaces.

unsafe fn emplace_unsized_unchecked(
    self,
    out: In<Slot<'_, RelVec<T, A, B>>, R::Region>
)

Emplaces a value into a given slot within some memory region.

impl<T, A, B> IndexMutRaw<usize> for RelVec<T, A, B>where
    A: RawRegionalAllocator,
    B: Basis,

fn index_mut_raw(this: Mut<'_, Self>, index: usize) -> Mut<'_, Self::Output>

Performs the mutable indexing (container[index]) operation.

unsafe fn index_mut_raw_unchecked(
    this: Mut<'_, Self>,
    index: usize
) -> Mut<'_, Self::Output>

Performs the mutable indexing (container[index]) operation without performing bounds checking

impl<T, A, B> IndexRaw<usize> for RelVec<T, A, B>where
    A: RawRegionalAllocator,
    B: Basis,

type Output = T

The returned type after indexing.

fn index_raw(this: Ref<'_, Self>, index: usize) -> Ref<'_, Self::Output>

Performs the indexing (container[index]) operation.

unsafe fn index_raw_unchecked(
    this: Ref<'_, Self>,
    index: usize
) -> Ref<'_, Self::Output>

Performs the indexing (container[index]) operation without performing bounds checking

impl<T, A: RawRegionalAllocator, B: Basis, __R: Region> Move<__R> for RelVec<T, A, B>where
    Self: DropRaw,
    RelPtr<T, A::Region, B>: Move<__R>,
    B::Usize: Move<__R>,
    B::Usize: Move<__R>,
    A: Move<__R>,

unsafe fn move_unsized_unchecked(
    this: In<Val<'_, Self>, __R>,
    out: In<Slot<'_, Self>, __R>
)

Moves a value into a given slot within some memory region.

impl<T, A: RawRegionalAllocator, B: Basis> Portable for RelVec<T, A, B>where
    RelPtr<T, A::Region, B>: Portable,
    B::Usize: Portable,
    B::Usize: Portable,
    A: Portable,