Struct stam::Handles

pub struct Handles<'store, T>
where
    T: Storable,
{ /* private fields */ }

Holds a collection of items. The collection may be either owned or borrowed from the store (usually from a reverse index).

The items in the collection by definition refer to the AnnotationStore, as internally the collection only keeps fully qualified handles and a reference to the store.

This structure is produced via the ToHandles trait that is implemented for all iterators over ResultItem<T>.

Implementations

impl<'store, T> Handles<'store, T>

where T: Storable,

pub fn returns_sorted(&self) -> bool

Are the items in this collection sorted (chronologically, i.e. by handle) or not?

pub fn store(&self) -> &'store AnnotationStore

Returns a reference to the underlying AnnotationStore.

pub fn new( array: Cow<'store, [T::FullHandleType]>, sorted: bool, store: &'store AnnotationStore ) -> Self

Low-level method to instantiate annotations from an existing vector of handles (either owned or borrowed from the store). Warning: Use of this function is dangerous and discouraged in most cases as there is no validity check on the handles you pass!

The safe option is to convert from an iterator of ResultItem<T> to Handles<T>, then use ToHandles::to_handles() on that

pub fn new_empty(store: &'store AnnotationStore) -> Self

Returns a new empty handles collection

pub fn from_iter( iter: impl Iterator<Item = T::FullHandleType>, store: &'store AnnotationStore ) -> Self

Create a new handles collection from an iterator handles Warning: Use of this function is dangerous and discouraged in most cases as there is no validity check on the handles you pass!

If you want to convert from an iterator of ResultItem<T> to Handles<T>, then use ToHandles::to_handles() on that

pub fn take(self) -> Cow<'store, [T::FullHandleType]>

where Self: Sized,

Low-level method to take out the underlying vector of handles

pub fn len(&self) -> usize

Returns the number of items in this collection.

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

Returns the number of items in this collection.

pub fn is_empty(&self) -> bool

Returns a boolean indicating whether the collection is empty or not.

pub fn contains(&self, handle: &T::FullHandleType) -> bool

Tests if the collection contains a specific element

pub fn position(&self, handle: &T::FullHandleType) -> Option<usize>

Tests if the collection contains a specific element and returns the index

pub fn iter<'a>(&'a self) -> HandlesIter<'a, T>

Returns an iterator over the low-level handles in this collection If you want to iterate over the actual items (ResultItem<T>), then use Self::items() instead.

pub fn items<'a>(&'a self) -> FromHandles<'store, T, HandlesIter<'store, T>>

where 'a: 'store,

Returns an iterator over the high-level items in this collection If you want to iterate over the low-level handles, then use Self::iter() instead.

pub fn union(&mut self, other: &Self)

Computes the union between two collections, retains order and ensures there are no duplicates Modifies the collection in-place to accommodate the other

pub fn intersection(&mut self, other: &Self)

Computes the intersection between two collections, retains order Modifies the collection in-place to match the other

pub fn contains_subset(&self, subset: &Self) -> bool

Checks if the collections contains another (need not be contingent)

pub fn sort(&mut self)

Sorts the collection in chronological order (i.e. the handles are sorted) Note that this is NOT the same as textual order.

pub fn add(&mut self, item: T::FullHandleType)

Adds an item to the collection, this checks for duplicates and respects existing sorting (if any), so this comes with performance overhead. Use [Self.union()] to add multiple items at once more efficiently.

Trait Implementations

impl<'store, T> Clone for Handles<'store, T>

where T: Storable + Clone, T::FullHandleType: Clone,

fn clone(&self) -> Handles<'store, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'store, T> Debug for Handles<'store, T>

where T: Storable,

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

Formats the value using the given formatter.

impl<'store, T> IntoIterator for Handles<'store, T>

where T: Storable,

type Item = <T as Storable>::FullHandleType

The type of the elements being iterated over.

type IntoIter = OwnedHandlesIter<'store, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.