Enum TempStack

pub enum TempStack<Root: TempRepr, Frame: TempRepr> {
    Root {
        data: Root,
    },
    Frame {
        data: Frame,
        parent: TempRefPin<TempStack<Root, Frame>>,
    },
}

A linked list consisting of a single item of type Root and arbitrarily many items of type Frame. Both types must implement temp_inst::TempRepr, which declares them as “temporary representations” of possibly lifetime-dependent types such as references.

A TempStack can be constructed and referenced in a mutable or shared fashion, and in the mutable case the usual exclusivity rules apply. However, adding an item never alters the list it was added to; it merely creates a new list that borrows the original one (exclusively or shared).

Remarks

Although the root and frames can consist of arbitrary data via temp_inst::SelfRepr, usually the size of both should be kept small, using references via temp_inst::TempRef or temp_inst::TempRefMut instead, for two reasons.

• Both root and frame data are stored in the same enum, so a large root also enlarges each frame.
• The iterators return copies/clones of the frame data. Therefore, if frames are large, iteration should be implemented manually.

Variants

Root

Fields

data: Root

Frame

Fields

data: Frame

parent: TempRefPin<TempStack<Root, Frame>>

Implementations

impl<Root: TempRepr, Frame: TempRepr> TempStack<Root, Frame>

pub fn new_root(data: Root::Shared<'_>) -> TempStackFrame<'_, Root, Frame>

Creates a new stack and returns a TempInst object that only hands out shared references.

pub fn new_frame<'a>( &'a self, data: Frame::Shared<'a>, ) -> TempStackFrame<'a, Root, Frame>

Creates a new stack that extends self with the given frame, and returns a TempInst object that only hands out shared references.

pub fn iter(&self) -> TempStackIter<'_, Root, Frame>

Returns an iterator that traverses the stack starting at the current frame and ending at the root.

The iterator returns the data of each frame, and also provides TempStackIter::into_root to access the root data.

impl<Root: TempReprMut, Frame: TempReprMut> TempStack<Root, Frame>

pub fn new_root_mut( data: Root::Mutable<'_>, ) -> TempStackFrameMut<'_, Root, Frame>

Creates a new stack and returns a TempInstPin object that can hand out pinned mutable references.

Note that this requires the resulting object to be pinned, e.g. using core::pin::pin!.

pub fn new_frame_mut<'a>( self: Pin<&'a mut Self>, data: Frame::Mutable<'a>, ) -> TempStackFrameMut<'a, Root, Frame>

Creates a new stack that extends self with the given frame, and returns a TempInstPin object that can hand out pinned mutable references.

Note that this requires the resulting object to be pinned, e.g. using core::pin::pin!.

pub fn iter_mut(self: Pin<&mut Self>) -> TempStackIterMut<'_, Root, Frame>

Returns an iterator that traverses the stack starting at the current frame and ending at the root, returning mutable frames.

The iterator returns the data of each frame, and also provides TempStackIterMut::into_root to access the root data.

Trait Implementations

impl<Root: TempRepr + Debug, Frame: TempRepr + Debug> Debug for TempStack<Root, Frame>

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

Formats the value using the given formatter.

impl<Root: TempRepr, Frame: TempRepr> TempRepr for TempStack<Root, Frame>

type Shared<'a> = Either<<Root as TempRepr>::Shared<'a>, (<Frame as TempRepr>::Shared<'a>, <TempRefPin<TempStack<Root, Frame>> as TempRepr>::Shared<'a>)> where Self: 'a

The type that Self is a temporary representation of. May contain shared references of lifetime 'a.

unsafe fn new_temp(obj: Self::Shared<'_>) -> Self

Converts the given object to its temporary representation.

fn get(&self) -> Self::Shared<'_>

Converts from a shared temporary reference back to the original type with a suitably-restricted lifetime.

impl<Root: TempReprMut, Frame: TempReprMut> TempReprMut for TempStack<Root, Frame>

type Mutable<'a> = Either<<Root as TempReprMut>::Mutable<'a>, (<Frame as TempReprMut>::Mutable<'a>, <TempRefPin<TempStack<Root, Frame>> as TempReprMut>::Mutable<'a>)> where Self: 'a

The type that Self is a temporary representation of. May contain mutable references of lifetime 'a.

unsafe fn new_temp_mut(obj: Self::Mutable<'_>) -> Self

Converts the given object to a temporary representation without a lifetime parameter.

fn get_mut(&mut self) -> Self::Mutable<'_>

Converts from a mutable reference to the temporary representation back to the original type, with a restricted lifetime.

fn get_mut_pinned(self: Pin<&mut Self>) -> Self::Mutable<'_>

Like TempReprMut::get_mut, but takes a pinned mutable reference to Self.