Struct ObservableVectorTransaction

pub struct ObservableVectorTransaction<'o, T: Clone> { /* private fields */ }

A transaction that allows making multiple updates to an ObservableVector as an atomic unit.

For updates from the transaction to have affect, it has to be finalized with .commit(). If the transaction is dropped without that method being called, the updates will be discarded.

Implementations

impl<'o, T: Clone + 'static> ObservableVectorTransaction<'o, T>

pub fn commit(self)

Commit this transaction, persisting the changes and notifying subscribers.

pub fn rollback(&mut self)

Roll back all changes made using this transaction so far.

Same as dropping the transaction and starting a new one, semantically.

pub fn append(&mut self, values: Vector<T>)

Append the given elements at the end of the Vector and notify subscribers.

pub fn clear(&mut self)

Clear out all of the elements in this Vector and notify subscribers.

pub fn push_front(&mut self, value: T)

Add an element at the front of the list and notify subscribers.

pub fn push_back(&mut self, value: T)

Add an element at the back of the list and notify subscribers.

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

Remove the first element, notify subscribers and return the element.

If there are no elements, subscribers will not be notified and this method will return None.

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

Remove the last element, notify subscribers and return the element.

If there are no elements, subscribers will not be notified and this method will return None.

pub fn insert(&mut self, index: usize, value: T)

Insert an element at the given position and notify subscribers.

Panics

Panics if index > len.

pub fn set(&mut self, index: usize, value: T) -> T

Replace the element at the given position, notify subscribers and return the previous element at that position.

Panics

Panics if index > len.

pub fn remove(&mut self, index: usize) -> T

Remove the element at the given position, notify subscribers and return the element.

Panics

Panics if index >= len.

pub fn truncate(&mut self, len: usize)

Truncate the vector to len elements and notify subscribers.

Does nothing if len is greater or equal to the vector’s current length.

pub fn entry( &mut self, index: usize, ) -> ObservableVectorTransactionEntry<'_, 'o, T>

Gets an entry for the given index through which only the element at that index alone can be updated or removed.

Panics

Panics if index >= len.

pub fn for_each( &mut self, f: impl FnMut(ObservableVectorTransactionEntry<'_, 'o, T>), )

Call the given closure for every element in this ObservableVector, with an entry struct that allows updating or removing that element.

Iteration happens in order, i.e. starting at index 0.

pub fn entries(&mut self) -> ObservableVectorTransactionEntries<'_, 'o, T>

Get an iterator over all the entries in this ObservableVector.

This is a more flexible, but less convenient alternative to for_each. If you don’t need to use special control flow like .await or break when iterating, it’s recommended to use that method instead.

Because std’s Iterator trait does not allow iterator items to borrow from the iterator itself, the returned typed does not implement the Iterator trait and can thus not be used with a for loop. Instead, you have to call its .next() method directly, as in:

let mut entries = ob.entries();
while let Some(entry) = entries.next() {
    // use entry
}

Methods from Deref<Target = Vector<T>>

pub fn len(&self) -> usize

Get the length of a vector.

Time: O(1)

Examples

assert_eq!(5, vector![1, 2, 3, 4, 5].len());

pub fn is_empty(&self) -> bool

Test whether a vector is empty.

Time: O(1)

Examples

let vec = vector!["Joe", "Mike", "Robert"];
assert_eq!(false, vec.is_empty());
assert_eq!(true, Vector::<i32>::new().is_empty());

pub fn is_inline(&self) -> bool

Test whether a vector is currently inlined.

Vectors small enough that their contents could be stored entirely inside the space of std::mem::size_of::<Vector<A>>() bytes are stored inline on the stack instead of allocating any chunks. This method returns true if this vector is currently inlined, or false if it currently has chunks allocated on the heap.

This may be useful in conjunction with ptr_eq(), which checks if two vectors’ heap allocations are the same, and thus will never return true for inlined vectors.

Time: O(1)

pub fn ptr_eq(&self, other: &Vector<A>) -> bool

Test whether two vectors refer to the same content in memory.

This uses the following rules to determine equality:

• If the two sides are references to the same vector, return true.
• If the two sides are single chunk vectors pointing to the same chunk, return true.
• If the two sides are full trees pointing to the same chunks, return true.

This would return true if you’re comparing a vector to itself, or if you’re comparing a vector to a fresh clone of itself. The exception to this is if you’ve cloned an inline array (ie. an array with so few elements they can fit inside the space a Vector allocates for its pointers, so there are no heap allocations to compare).

Time: O(1)

pub fn iter(&self) -> Iter<'_, A>

Get an iterator over a vector.

Time: O(1)

pub fn leaves(&self) -> Chunks<'_, A>

Get an iterator over the leaf nodes of a vector.

This returns an iterator over the Chunks at the leaves of the RRB tree. These are useful for efficient parallelisation of work on the vector, but should not be used for basic iteration.

Time: O(1)

pub fn focus(&self) -> Focus<'_, A>

Construct a Focus for a vector.

Time: O(1)

pub fn get(&self, index: usize) -> Option<&A>

Get a reference to the value at index index in a vector.

Returns None if the index is out of bounds.

Time: O(log n)

Examples

let vec = vector!["Joe", "Mike", "Robert"];
assert_eq!(Some(&"Robert"), vec.get(2));
assert_eq!(None, vec.get(5));

pub fn front(&self) -> Option<&A>

Get the first element of a vector.

If the vector is empty, None is returned.

Time: O(log n)

pub fn head(&self) -> Option<&A>

Get the first element of a vector.

If the vector is empty, None is returned.

This is an alias for the front method.

Time: O(log n)

pub fn back(&self) -> Option<&A>

Get the last element of a vector.

If the vector is empty, None is returned.

Time: O(log n)

pub fn last(&self) -> Option<&A>

Get the last element of a vector.

If the vector is empty, None is returned.

This is an alias for the back method.

Time: O(log n)

pub fn index_of(&self, value: &A) -> Option<usize>

where A: PartialEq,

Get the index of a given element in the vector.

Searches the vector for the first occurrence of a given value, and returns the index of the value if it’s there. Otherwise, it returns None.

Time: O(n)

Examples

let mut vec = vector![1, 2, 3, 4, 5];
assert_eq!(Some(2), vec.index_of(&3));
assert_eq!(None, vec.index_of(&31337));

pub fn contains(&self, value: &A) -> bool

where A: PartialEq,

Test if a given element is in the vector.

Searches the vector for the first occurrence of a given value, and returns true if it’s there. If it’s nowhere to be found in the vector, it returns false.

Time: O(n)

Examples

let mut vec = vector![1, 2, 3, 4, 5];
assert_eq!(true, vec.contains(&3));
assert_eq!(false, vec.contains(&31337));

pub fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>

where F: FnMut(&A) -> Ordering,

Binary search a sorted vector for a given element using a comparator function.

Assumes the vector has already been sorted using the same comparator function, eg. by using sort_by.

If the value is found, it returns Ok(index) where index is the index of the element. If the value isn’t found, it returns Err(index) where index is the index at which the element would need to be inserted to maintain sorted order.

Time: O(log n)

pub fn binary_search(&self, value: &A) -> Result<usize, usize>

where A: Ord,

Binary search a sorted vector for a given element.

If the value is found, it returns Ok(index) where index is the index of the element. If the value isn’t found, it returns Err(index) where index is the index at which the element would need to be inserted to maintain sorted order.

Time: O(log n)

pub fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize>

where F: FnMut(&A) -> B, B: Ord,

Binary search a sorted vector for a given element with a key extract function.

Assumes the vector has already been sorted using the same key extract function, eg. by using sort_by_key.

If the value is found, it returns Ok(index) where index is the index of the element. If the value isn’t found, it returns Err(index) where index is the index at which the element would need to be inserted to maintain sorted order.

Time: O(log n)

pub fn update(&self, index: usize, value: A) -> Vector<A>

Create a new vector with the value at index index updated.

Panics if the index is out of bounds.

Time: O(log n)

Examples

let mut vec = vector![1, 2, 3];
assert_eq!(vector![1, 5, 3], vec.update(1, 5));

pub fn skip(&self, count: usize) -> Vector<A>

Construct a vector with count elements removed from the start of the current vector.

Time: O(log n)

pub fn take(&self, count: usize) -> Vector<A>

Construct a vector of the first count elements from the current vector.

Time: O(log n)

Trait Implementations

impl<T> Debug for ObservableVectorTransaction<'_, T>

where T: Clone + Debug,

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

Formats the value using the given formatter.

impl<T: Clone> Deref for ObservableVectorTransaction<'_, T>

type Target = Vector<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: Clone> Drop for ObservableVectorTransaction<'_, T>

fn drop(&mut self)

Executes the destructor for this type.