Struct Entries

pub struct Entries<'a, T> { /* private fields */ }

A view into the elements of a Vec

Implementations

impl<'a, T> Entries<'a, T>

pub fn remaining(&mut self) -> &mut [T]

Get the remaining elements of the view as a mutable slice.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.remaining(), [0, 1, 2]);
    e.shift();
    assert_eq!(e.remaining(), [1, 2]);
    e.shift();
    assert_eq!(e.remaining(), [2]);
});

pub const fn remaining_len(&self) -> usize

Get the number of elements still present in the view.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.remaining_len(), 3);
    e.shift();
    assert_eq!(e.remaining_len(), 2);
    e.shift();
    assert_eq!(e.remaining_len(), 1);
});

pub const fn len_before(&self) -> usize

Get the length of portion of the underlying Vec before the view.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.len_before(), 0);
    e.shift();
    assert_eq!(e.len_before(), 1);
    e.shift();
    assert_eq!(e.len_before(), 2);
});

pub fn len_after(&self) -> usize

Get the length of portion of the underlying Vec after the view.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.len_after(), 0);
    e.shift_back();
    assert_eq!(e.len_after(), 1);
    e.shift_back();
    assert_eq!(e.len_after(), 2);
});

pub fn clear(&mut self)

Remove and drop all remaining elements in the view.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2, 3, 4];
v.entries(.., |e| {
    e.shift(); // shift `0` out of view
    e.shift_back(); // shift `4` out of view
    e.clear(); // Drop 1, 2, and 3
});
assert_eq!(v, [0, 4]);

pub fn front<'b>(&'b mut self) -> Option<Entry<'a, 'b, T>>

Get an entry for the element at the head of the view.

Returns None if the view is empty.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    let f = e.front().unwrap();
    assert_eq!(*f, 0);
    f.shift();

    let f = e.front().unwrap();
    assert_eq!(*f, 1);
    f.shift();

    let f = e.front().unwrap();
    assert_eq!(*f, 2);
    f.shift();

    assert!(e.front().is_none());
});

pub fn back<'b>(&'b mut self) -> Option<Entry<'a, 'b, T>>

Get an entry for the element at the tail of the view.

Returns None if the view is empty.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    let b = e.back().unwrap();
    assert_eq!(*b, 2);
    b.shift();

    let b = e.back().unwrap();
    assert_eq!(*b, 1);
    b.shift();

    let b = e.back().unwrap();
    assert_eq!(*b, 0);
    b.shift();

    assert!(e.back().is_none());
});

pub fn shift(&mut self) -> Option<&'a mut T>

Shift the head of the view inward by one, returning a mutable reference to the now excluded item.

Returns None if the view is empty.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.shift(), Some(&mut 0));
    assert_eq!(e.shift(), Some(&mut 1));
    assert_eq!(e.shift(), Some(&mut 2));
    assert_eq!(e.shift(), None);
});

pub fn shift_back(&mut self) -> Option<&'a mut T>

Shift the tail of the view inward by one, returning a mutable reference to the now excluded item.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.shift_back(), Some(&mut 2));
    assert_eq!(e.shift_back(), Some(&mut 1));
    assert_eq!(e.shift_back(), Some(&mut 0));
    assert_eq!(e.shift_back(), None);
});

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

Remove the item at the head of the view from the underlying Vec, returning the now removed item.

Returns None if the view is empty.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    e.shift();
    assert_eq!(e.remove(), Some(1));
});
assert_eq!(v, [0, 2]);

Examples found in repository

examples/merkle.rs (line 22)

fn merkle_step<T>(v: &mut Vec<T>, mut join: impl FnMut(T, T) -> T) {
    v.entries(.., |e| {
        while let Some(left) = e.remove() {
            let Some(right) = e.remove() else {
                // If we can't find a right, just insert the left and stop
                let Ok(_) = e.try_insert_outside(left) else {
                    unreachable!()
                };
                return;
            };

            // Combine the two items and insert the result
            let joined = join(left, right);
            let Ok(_) = e.try_insert_outside(joined) else {
                unreachable!()
            };
        }
    });
}

examples/sparse_merkle.rs (line 22)

fn sparse_merkle_step<T>(v: &mut Vec<T>, mut maybe_join: impl FnMut(T, T) -> (T, Option<T>)) {
    v.entries(.., |e| {
        let Some(mut left) = e.remove() else { return };

        while let Some(right) = e.remove() {
            // Combine the two items and insert the result
            // If the join succeeded this is the joined item
            // If the join failed, this is the left item
            let (joined, failed) = maybe_join(left, right);
            let Ok(_) = e.try_insert_outside(joined) else {
                unreachable!()
            };

            // Try to get the next left item, either from the join-failure or the next entry
            // Stop if we can't get any more items
            left = if let Some(next) = failed {
                next
            } else if let Some(next) = e.remove() {
                next
            } else {
                return;
            };
        }

        // Re-insert any unused left items
        let Ok(_) = e.try_insert_outside(left) else {
            unreachable!()
        };
    })
}

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

Remove the item at the tail of the view from the underlying Vec, returning the now removed item.

Returns None if the view is empty.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    assert_eq!(e.remove_back(), Some(2));
});
assert_eq!(v, [0, 1]);

pub fn try_insert_inside(&mut self, v: T) -> Result<&mut T, T>

Try to insert an item into the underlying Vec, just before the head of the view. The view is then shifted include the added item.

Returns Err if the there is no empty space for the insert to occur.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    // Can't insert if you didn't remove
    assert_eq!(e.try_insert_inside(5), Err(5));

    assert_eq!(e.remove(), Some(0));
    assert_eq!(e.remaining(), [1, 2]);
    assert_eq!(e.try_insert_inside(5), Ok(&mut 5));
    assert_eq!(e.remaining(), [5, 1, 2]);
});
assert_eq!(v, [5, 1, 2]);

pub fn try_insert_inside_back(&mut self, v: T) -> Result<&mut T, T>

Try to insert an item into the underlying Vec, just after the tail of the view. The view is then shifted include the added item.

Returns Err if the there is no empty space for the insert to occur.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    // Can't insert if you didn't remove
    assert_eq!(e.try_insert_inside_back(5), Err(5));

    assert_eq!(e.remove_back(), Some(2));
    assert_eq!(e.remaining(), [0, 1]);
    assert_eq!(e.try_insert_inside_back(5), Ok(&mut 5));
    assert_eq!(e.remaining(), [0, 1, 5]);
});
assert_eq!(v, [0, 1, 5]);

pub fn try_insert_outside(&mut self, v: T) -> Result<&'a mut T, T>

Try to insert an item into the underlying Vec, just before the head of the view.

Returns Err if the there is no empty space for the insert to occur.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    // Can't insert if you didn't remove
    assert_eq!(e.try_insert_outside(5), Err(5));

    assert_eq!(e.remove(), Some(0));
    assert_eq!(e.remaining(), [1, 2]);
    assert_eq!(e.try_insert_outside(5), Ok(&mut 5));
    assert_eq!(e.remaining(), [1, 2]);
});
assert_eq!(v, [5, 1, 2]);

Examples found in repository

examples/merkle.rs (line 25)

fn merkle_step<T>(v: &mut Vec<T>, mut join: impl FnMut(T, T) -> T) {
    v.entries(.., |e| {
        while let Some(left) = e.remove() {
            let Some(right) = e.remove() else {
                // If we can't find a right, just insert the left and stop
                let Ok(_) = e.try_insert_outside(left) else {
                    unreachable!()
                };
                return;
            };

            // Combine the two items and insert the result
            let joined = join(left, right);
            let Ok(_) = e.try_insert_outside(joined) else {
                unreachable!()
            };
        }
    });
}

examples/sparse_merkle.rs (line 29)

fn sparse_merkle_step<T>(v: &mut Vec<T>, mut maybe_join: impl FnMut(T, T) -> (T, Option<T>)) {
    v.entries(.., |e| {
        let Some(mut left) = e.remove() else { return };

        while let Some(right) = e.remove() {
            // Combine the two items and insert the result
            // If the join succeeded this is the joined item
            // If the join failed, this is the left item
            let (joined, failed) = maybe_join(left, right);
            let Ok(_) = e.try_insert_outside(joined) else {
                unreachable!()
            };

            // Try to get the next left item, either from the join-failure or the next entry
            // Stop if we can't get any more items
            left = if let Some(next) = failed {
                next
            } else if let Some(next) = e.remove() {
                next
            } else {
                return;
            };
        }

        // Re-insert any unused left items
        let Ok(_) = e.try_insert_outside(left) else {
            unreachable!()
        };
    })
}

pub fn try_insert_outside_back(&mut self, v: T) -> Result<&'a mut T, T>

Try to insert an item into the underlying Vec, just after the tail of the view.

Returns Err if the there is no empty space for the insert to occur.

Examples

use vec_entries::EntriesExt;

let mut v = vec![0, 1, 2];
v.entries(.., |e| {
    // Can't insert if you didn't remove
    assert_eq!(e.try_insert_outside_back(5), Err(5));

    assert_eq!(e.remove_back(), Some(2));
    assert_eq!(e.remaining(), [0, 1]);
    assert_eq!(e.try_insert_outside_back(5), Ok(&mut 5));
    assert_eq!(e.remaining(), [0, 1]);
});
assert_eq!(v, [0, 1, 5]);

pub fn shift_iter<'b>(&'b mut self) -> ShiftIter<'a, 'b, T>

Get an iterator which gives mutable references to entries.

pub fn remove_iter<'b>(&'b mut self) -> RemoveIter<'a, 'b, T>

Get an iterator which removes entries.

Trait Implementations

impl<'a, T> Drop for Entries<'a, T>

fn drop(&mut self)

Executes the destructor for this type.