Struct RankedIndex

pub struct RankedIndex<K, T>
where
    K: 'static + Ord + Clone,
    T: 'static + Clone + Eq,
{ /* private fields */ }

Keeps an index of items sorted by the given rank, highest rank first

Implementations

impl<K, T> RankedIndex<K, T>

where K: 'static + Ord + Clone, T: 'static + Clone + Eq,

pub fn new_with(rank: K, value: T) -> Self

pub fn insert(&mut self, rank: K, value: T)

Insert the value T at the position of rank

Will add at first position if a value of the same rank is found

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

Remove all instances in the vector having the specific value

pub fn values(&self) -> Vec<&T>

Returns the current list of values in order of their rank

pub fn update_stream(&self) -> impl Stream<Item = VectorDiff<T>>

Methods from Deref<Target = ObservableVector<(K, T)>>

pub fn subscribe(&self) -> VectorSubscriber<T>

Obtain a new subscriber.

If you put the ObservableVector behind a lock, it is highly recommended to make access of the elements and subscribing one operation. Otherwise, the values could be altered in between the reading of the values and subscribing to changes.

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<K, T> Default for RankedIndex<K, T>

where K: 'static + Ord + Clone, T: 'static + Clone + Eq,

fn default() -> Self

Returns the “default value” for a type.

impl<K, T> Deref for RankedIndex<K, T>

where K: 'static + Ord + Clone, T: 'static + Clone + Eq,

type Target = ObservableVector<(K, T)>

The resulting type after dereferencing.

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

Dereferences the value.