Struct ic_stable_memory::collections::vec::SVec

pub struct SVec<T> { /* private fields */ }

Implementations

impl<'a, T: Readable<'a, LittleEndian> + Writable<LittleEndian>> SVec<T>

pub fn new() -> Self

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

pub fn pop(&mut self) -> Option<T>

pub fn get_cloned(&self, idx: u64) -> Option<T>

pub fn replace(&mut self, idx: u64, element: &T) -> T

pub fn swap(&mut self, idx1: u64, idx2: u64)

pub fn drop(self)

pub fn capacity(&self) -> u64

pub fn len(&self) -> u64

pub fn is_empty(&self) -> bool

pub fn is_about_to_grow(&self) -> bool

Trait Implementations

impl<'a, T: Readable<'a, LittleEndian> + Writable<LittleEndian>> Default for SVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a_, T, C_: Context> Readable<'a_, C_> for SVec<T>where
    SPhantomData<T>: Readable<'a_, C_>,

fn read_from<R_: Reader<'a_, C_>>(_reader_: &mut R_) -> Result<Self, C_::Error>

fn minimum_bytes_needed() -> usize

fn read_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx(
    context: C,
    buffer: &'a [u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx(
    context: C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut(
    context: &mut C,
    buffer: &[u8]
) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error>where
    S: Read,

fn read_from_stream_buffered_with_ctx<S>(
    context: C,
    stream: S
) -> Result<Self, <C as Context>::Error>where
    S: Read,

fn read_from_file_with_ctx(
    context: C,
    path: impl AsRef<Path>
) -> Result<Self, <C as Context>::Error>

impl<T, C_: Context> Writable<C_> for SVec<T>where
    SPhantomData<T>: Writable<C_>,

fn write_to<T_: ?Sized + Writer<C_>>(
    &self,
    _writer_: &mut T_
) -> Result<(), C_::Error>

fn write_to_buffer_with_ctx(
    &self,
    context: C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut(
    &self,
    context: &mut C,
    buffer: &mut [u8]
) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx(
    &self,
    context: C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut(
    &self,
    context: &mut C
) -> Result<Vec<u8, Global>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>(
    &self,
    context: C,
    stream: S
) -> Result<(), <C as Context>::Error>where
    S: Write,

fn write_to_file_with_ctx(
    &self,
    context: C,
    path: impl AsRef<Path>
) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>