Struct stack_graphs::arena::ReversibleList

#[repr(C)]
pub struct ReversibleList<T> { /* private fields */ }

An arena-allocated list that can be reversed.

Well, that is, you can reverse a List just fine by yourself. This type takes care of doing that for you, and importantly, saves the result so that if you only have to compute the reversal once even if you need to access it multiple times.

Implementations

impl<T> ReversibleList<T>

pub fn new_arena() -> ReversibleListArena<T>

Creates a new ReversibleListArena that will manage lists of this type.

pub fn is_empty(&self) -> bool

Returns whether this list is empty.

pub fn empty() -> ReversibleList<T>

Returns an empty list.

pub fn have_reversal(&self, arena: &ReversibleListArena<T>) -> bool

Returns whether we have already calculated the reversal of this list.

pub fn push_front(&mut self, arena: &mut ReversibleListArena<T>, head: T)

Pushes a new element onto the front of this list.

pub fn pop_front<'a>(
    &mut self,
    arena: &'a ReversibleListArena<T>
) -> Option<&'a T>

Removes and returns the element at the front of this list. If the list is empty, returns None.

pub fn iter<'a>(
    self,
    arena: &'a ReversibleListArena<T>
) -> impl Iterator<Item = &'a T> + 'a

Returns an iterator over the elements of this list.

impl<T> ReversibleList<T>where
    T: Clone,

pub fn reverse(&mut self, arena: &mut ReversibleListArena<T>)

Reverses the list. Since we’re already caching everything in an arena, we make sure to only calculate the reversal once, returning it as-is if you call this function multiple times.

pub fn ensure_reversal_available(&mut self, arena: &mut ReversibleListArena<T>)

Ensures that the reversal of this list is available. It can be useful to precalculate this when you have mutable access to the arena, so that you can then reverse and un-reverse the list later when you only have shared access to it.

impl<T> ReversibleList<T>

pub fn reverse_reused(
    &mut self,
    arena: &ReversibleListArena<T>
) -> Result<(), ()>

Reverses the list, assuming that the reversal has already been computed. If it hasn’t we return an error.

impl<T> ReversibleList<T>

pub fn equals_with<F>(
    self,
    arena: &ReversibleListArena<T>,
    other: ReversibleList<T>,
    eq: F
) -> boolwhere
    F: FnMut(&T, &T) -> bool,

pub fn cmp_with<F>(
    self,
    arena: &ReversibleListArena<T>,
    other: ReversibleList<T>,
    cmp: F
) -> Orderingwhere
    F: FnMut(&T, &T) -> Ordering,

impl<T> ReversibleList<T>where
    T: Eq,

pub fn equals(
    self,
    arena: &ReversibleListArena<T>,
    other: ReversibleList<T>
) -> bool

impl<T> ReversibleList<T>where
    T: Ord,

pub fn cmp(
    self,
    arena: &ReversibleListArena<T>,
    other: ReversibleList<T>
) -> Ordering

Trait Implementations

impl<T> Clone for ReversibleList<T>

fn clone(&self) -> ReversibleList<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Niche for ReversibleList<T>where
    Handle<ReversibleListCell<T>>: Niche,

type Output = MaybeUninit<ReversibleList<T>>

The type that is used to store values of Self inside of a ControlledOption. This might be Self itself, if your niche is a valid instance of the type, but which violates some runtime constraint. But if you cannot easily create your niche as an instance of Self, you can use some other type, you can use some other type instead.

fn none() -> Self::Output

Returns the niche value for this type that should be used to represent None for a ControlledOption.

fn is_none(value: &Self::Output) -> bool

Returns whether value is the niche value for this type.

fn into_some(value: Self) -> Self::Output

Transforms a non-niche value of this type into its Output type. When Output is Self, this will be the identity function.

fn from_some(value: Self::Output) -> Self

Transforms a non-niche value of this type from its Output type. When Output is Self, this will be the identity function.

impl<T> Copy for ReversibleList<T>