Trait stackvec::Array

pub trait Array: Sealed {
    type Item;

    const N: usize;

    fn as_ptr(&self) -> *const Self::Item;
    fn as_mut_ptr(&mut self) -> *mut Self::Item;
}

Required Associated Types

type Item

Required Associated Constants

const N: usize

Required Methods

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

Implementations on Foreign Types

impl<T> Array for [T; 0]

type Item = T

const N: usize = 0usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1]

type Item = T

const N: usize = 1usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 2]

type Item = T

const N: usize = 2usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 3]

type Item = T

const N: usize = 3usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 4]

type Item = T

const N: usize = 4usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 5]

type Item = T

const N: usize = 5usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 6]

type Item = T

const N: usize = 6usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 7]

type Item = T

const N: usize = 7usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 8]

type Item = T

const N: usize = 8usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 9]

type Item = T

const N: usize = 9usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 10]

type Item = T

const N: usize = 10usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 11]

type Item = T

const N: usize = 11usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 12]

type Item = T

const N: usize = 12usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 13]

type Item = T

const N: usize = 13usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 14]

type Item = T

const N: usize = 14usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 15]

type Item = T

const N: usize = 15usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 16]

type Item = T

const N: usize = 16usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 32]

type Item = T

const N: usize = 32usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 64]

type Item = T

const N: usize = 64usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 128]

type Item = T

const N: usize = 128usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 256]

type Item = T

const N: usize = 256usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 512]

type Item = T

const N: usize = 512usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1024]

type Item = T

const N: usize = 1_024usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 2048]

type Item = T

const N: usize = 2_048usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 4096]

type Item = T

const N: usize = 4_096usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 8192]

type Item = T

const N: usize = 8_192usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 16384]

type Item = T

const N: usize = 16_384usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 32768]

type Item = T

const N: usize = 32_768usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 20]

type Item = T

const N: usize = 20usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 30]

type Item = T

const N: usize = 30usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 50]

type Item = T

const N: usize = 50usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 80]

type Item = T

const N: usize = 80usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 100]

type Item = T

const N: usize = 100usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 120]

type Item = T

const N: usize = 120usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 150]

type Item = T

const N: usize = 150usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 200]

type Item = T

const N: usize = 200usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 250]

type Item = T

const N: usize = 250usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 300]

type Item = T

const N: usize = 300usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 350]

type Item = T

const N: usize = 350usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 400]

type Item = T

const N: usize = 400usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 450]

type Item = T

const N: usize = 450usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 500]

type Item = T

const N: usize = 500usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 600]

type Item = T

const N: usize = 600usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 700]

type Item = T

const N: usize = 700usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 800]

type Item = T

const N: usize = 800usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 900]

type Item = T

const N: usize = 900usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1000]

type Item = T

const N: usize = 1_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1100]

type Item = T

const N: usize = 1_100usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1200]

type Item = T

const N: usize = 1_200usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1400]

type Item = T

const N: usize = 1_400usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1600]

type Item = T

const N: usize = 1_600usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 1800]

type Item = T

const N: usize = 1_800usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 2000]

type Item = T

const N: usize = 2_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 2500]

type Item = T

const N: usize = 2_500usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 3000]

type Item = T

const N: usize = 3_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 3500]

type Item = T

const N: usize = 3_500usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 4000]

type Item = T

const N: usize = 4_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 4500]

type Item = T

const N: usize = 4_500usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 5000]

type Item = T

const N: usize = 5_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 10000]

type Item = T

const N: usize = 10_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 15000]

type Item = T

const N: usize = 15_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 20000]

type Item = T

const N: usize = 20_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 25000]

type Item = T

const N: usize = 25_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

impl<T> Array for [T; 30000]

type Item = T

const N: usize = 30_000usize

fn as_ptr(&self) -> *const Self::Item

fn as_mut_ptr(&mut self) -> *mut Self::Item

Implementors