Struct bones_framework::prelude::piccolo::stack::Stack

pub struct Stack<'gc, 'a> { /* private fields */ }

Implementations

impl<'gc, 'a> Stack<'gc, 'a>

pub fn new( values: &'a mut Vec<Value<'gc>, MetricsAlloc<'gc>>, bottom: usize, ) -> Stack<'gc, 'a>

pub fn sub_stack(&mut self, bottom: usize) -> Stack<'gc, '_>

pub fn get(&self, i: usize) -> Value<'gc>

pub fn push_back(&mut self, value: Value<'gc>)

pub fn push_front(&mut self, value: Value<'gc>)

pub fn pop_back(&mut self) -> Value<'gc>

pub fn pop_front(&mut self) -> Value<'gc>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&mut self)

pub fn resize(&mut self, size: usize)

pub fn drain<R>(&mut self, range: R) -> Drain<'_, Value<'gc>, MetricsAlloc<'gc>>

where R: RangeBounds<usize>,

pub fn into_back(&mut self, ctx: Context<'gc>, v: impl IntoMultiValue<'gc>)

pub fn into_front(&mut self, ctx: Context<'gc>, v: impl IntoMultiValue<'gc>)

pub fn from_back<V>(&mut self, ctx: Context<'gc>) -> Result<V, TypeError>

where V: FromValue<'gc>,

pub fn from_front<V>(&mut self, ctx: Context<'gc>) -> Result<V, TypeError>

where V: FromValue<'gc>,

pub fn replace(&mut self, ctx: Context<'gc>, v: impl IntoMultiValue<'gc>)

pub fn consume<V>(&mut self, ctx: Context<'gc>) -> Result<V, TypeError>

where V: FromMultiValue<'gc>,

Trait Implementations

impl<'gc, 'a, 'b, 'c> Extend<&'b Value<'gc>> for &'c mut Stack<'gc, 'a>

where 'gc: 'b,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = &'b Value<'gc>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'gc, 'a, 'b> Extend<&'a Value<'gc>> for Stack<'gc, 'a>

where 'gc: 'b,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = &'a Value<'gc>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'gc, 'a, 'b> Extend<Value<'gc>> for &'b mut Stack<'gc, 'a>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = Value<'gc>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'gc, 'a> Extend<Value<'gc>> for Stack<'gc, 'a>

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = Value<'gc>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'gc, 'a, I> Index<I> for Stack<'gc, 'a>

where I: SliceIndex<[Value<'gc>]>,

type Output = <Vec<Value<'gc>> as Index<I>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &<Stack<'gc, 'a> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<'gc, 'a, I> IndexMut<I> for Stack<'gc, 'a>

where I: SliceIndex<[Value<'gc>]>,

fn index_mut(&mut self, index: I) -> &mut <Stack<'gc, 'a> as Index<I>>::Output

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

impl<'gc, 'a, 'b> IntoIterator for &'b Stack<'gc, 'a>

where 'gc: 'b,

type Item = Value<'gc>

The type of the elements being iterated over.

type IntoIter = Copied<Iter<'b, Value<'gc>>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'b Stack<'gc, 'a> as IntoIterator>::IntoIter

Creates an iterator from a value.