Struct blend2d::array::Array

#[repr(transparent)]
pub struct Array<T: ArrayType> { /* fields omitted */ }

Methods

impl<T: ArrayType> Array<T>

pub fn new() -> Self

pub fn clear(&mut self)

pub fn shrink_to_fit(&mut self)

pub fn reserve(&mut self, n: usize)

pub fn try_reserve(&mut self, n: usize) -> Result<()>

pub fn truncate(&mut self, n: usize)

pub fn resize(&mut self, fill: &[T])

pub fn remove(&mut self, index: usize) -> Result<()>

pub fn remove_range<R: RangeBounds<usize>>(&mut self, range: R) -> Result<()>

pub fn as_slice(&self) -> &[T]

pub fn len(&self) -> usize

pub fn capacity(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn extend_from_slice(&mut self, data: &[T]) -> Result<()>

pub fn insert_from_slice(&mut self, index: usize, data: &[T]) -> Result<()>

pub fn replace_from_slice<R: RangeBounds<usize>>(
    &mut self,
    range: R,
    data: &[T]
) -> Result<()>

impl<T> Array<T> where
    T: ArrayType + WrappedBlCore, 

pub fn push(&mut self, item: &T)

pub fn insert(&mut self, index: usize, item: &T)

pub fn replace(&mut self, index: usize, item: &T)

impl Array<i8>

pub fn push(&mut self, item: i8)

pub fn insert(&mut self, index: usize, item: i8)

pub fn replace(&mut self, index: usize, item: i8)

impl Array<u8>

pub fn push(&mut self, item: u8)

pub fn insert(&mut self, index: usize, item: u8)

pub fn replace(&mut self, index: usize, item: u8)

impl Array<i16>

pub fn push(&mut self, item: i16)

pub fn insert(&mut self, index: usize, item: i16)

pub fn replace(&mut self, index: usize, item: i16)

impl Array<u16>

pub fn push(&mut self, item: u16)

pub fn insert(&mut self, index: usize, item: u16)

pub fn replace(&mut self, index: usize, item: u16)

impl Array<i32>

pub fn push(&mut self, item: i32)

pub fn insert(&mut self, index: usize, item: i32)

pub fn replace(&mut self, index: usize, item: i32)

impl Array<u32>

pub fn push(&mut self, item: u32)

pub fn insert(&mut self, index: usize, item: u32)

pub fn replace(&mut self, index: usize, item: u32)

impl Array<i64>

pub fn push(&mut self, item: i64)

pub fn insert(&mut self, index: usize, item: i64)

pub fn replace(&mut self, index: usize, item: i64)

impl Array<u64>

pub fn push(&mut self, item: u64)

pub fn insert(&mut self, index: usize, item: u64)

pub fn replace(&mut self, index: usize, item: u64)

impl Array<f32>

pub fn push(&mut self, item: f32)

pub fn insert(&mut self, index: usize, item: f32)

pub fn replace(&mut self, index: usize, item: f32)

impl Array<f64>

pub fn push(&mut self, item: f64)

pub fn insert(&mut self, index: usize, item: f64)

pub fn replace(&mut self, index: usize, item: f64)

impl Array<isize>

pub fn push(&mut self, item: isize)

pub fn insert(&mut self, index: usize, item: isize)

pub fn replace(&mut self, index: usize, item: isize)

impl Array<usize>

pub fn push(&mut self, item: usize)

pub fn insert(&mut self, index: usize, item: usize)

pub fn replace(&mut self, index: usize, item: usize)

Trait Implementations

impl<T> Geometry for Array<T> where
    [T]: Geometry,
    T: ArrayType, 

const GEO_TYPE: u32

impl<T: ArrayType> Clone for Array<T>

fn clone(&self) -> Self

Returns a copy of the value.

default fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: ArrayType> Drop for Array<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ArrayType> PartialEq<Array<T>> for Array<T>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

default fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: ArrayType> AsRef<[T]> for Array<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T: ArrayType> Default for Array<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: ArrayType> Debug for Array<T>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, I> Index<I> for Array<T> where
    T: ArrayType,
    I: SliceIndex<[T]>, 

type Output = I::Output

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: ArrayType> Deref for Array<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: ArrayType> Borrow<[T]> for Array<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.