Struct stack_graphs::arena::ReversibleList

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

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
) -> bool where
    F: FnMut(&T, &T) -> bool, 

pub fn cmp_with<F>(
    self,
    arena: &ReversibleListArena<T>,
    other: ReversibleList<T>,
    cmp: F
) -> Ordering where
    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> Copy for ReversibleList<T>