Struct dodo::repository::RepositoryCursor

pub struct RepositoryCursor<'a, T, S, I, R> { /* fields omitted */ }

Repository cursor, yeilding all entities inside the repository.

Example

let entities = repository.find_all()?
                         .filter(|person| person.age > 20)
                         .skip(1)
                         .take(3)?;

Methods

impl<'a, T, S, R> RepositoryCursor<'a, T, S, S::Iterator, R> where
    T: Entity,
    S: Storage,
    R: Serializer, 

pub fn shuffled(self) -> RepositoryCursor<'a, T, S, IntoIter<Result<Uuid>>, R>

Shuffles the order the entities are yielded.

Use this if you need to shuffle the entire repository contents. When done this early, this shuffles ids, not entities, so it is pretty lightweight. Nevertheless, this still has some serious performance implications, as this collects every id in the storage. With a small repository, this shouldn't be a problem, but with a large one, this will allocate a substantial amount of memory.

Examples

let mut person1 = Person::new();
let mut person2 = Person::new();
repository.insert(&mut person1)?;
repository.insert(&mut person2)?;

let persons : Vec<Person> = repository.find_all()?
                                      .shuffled()
                                      .collect()?;

assert!(persons.contains(&person1), "Person1 should be in the results.");
assert!(persons.contains(&person2), "Person2 should be in the results.");

Trait Implementations

impl<'a, T, S, I, R> Cursor for RepositoryCursor<'a, T, S, I, R> where
    T: Entity,
    S: Storage,
    I: Iterator<Item = Result<Uuid>>,
    R: Serializer, 

type Item = T

Entity.

fn next(&mut self) -> Result<Option<Self::Item>>

Advances the cursor and returns the next element.

fn skip(self, nb_items: usize) -> Skip<Self> where
    Self: Sized, 

Skip the first n elements.

fn find<F>(&mut self, filter: F) -> Result<Option<Self::Item>> where
    Self: Sized,
    F: FnMut(&Self::Item) -> bool, 

Searches for an element that satisfies a predicate.

fn filter<F>(self, filter: F) -> Filter<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item) -> bool, 

Filters the cursor using a predicate.

fn first(self) -> Result<Option<Self::Item>> where
    Self: Sized, 

Consumes the cursor, only taking the first element.

fn nth(&mut self, index: usize) -> Result<Option<Self::Item>> where
    Self: Sized, 

Take the nth element.

fn take(self, nb_items: usize) -> Result<Vec<Self::Item>> where
    Self: Sized, 

Consumes the cursor into a Vec, taking only n elements.

fn collect(self) -> Result<Vec<Self::Item>> where
    Self: Sized, 

Consumes the cursor into a Vec.

impl<'a, T: Debug, S: Debug, I: Debug, R: Debug> Debug for RepositoryCursor<'a, T, S, I, R>

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

Formats the value using the given formatter.