Struct Collection

pub struct Collection<In, Ix> { /* private fields */ }

Implementations

impl<'t, In, Ix> Collection<In, Ix>

where Ix: Index<'t, In>,

pub fn new(ix: Ix) -> Self

Examples found in repository

examples/simple.rs (lines 4-11)

fn main() {
    let mut db = Collection::<Person, _>::new(indexes::zip3(
        // A hashtable index is useful for fast lookups
        indexes::premap(|p: &Person| p.name.clone(), indexes::hashtable()),
        // A btree index can provide max/min queries
        indexes::premap(|p: &Person| p.birth_year, indexes::btree()),
        // A grouped index can provide a "filtering" view
        indexes::grouped(|p: &Person| p.starsign.clone(), || aggregations::count()),
    ));

    db.insert(Person::new("Alice".to_string(), 1990, StarSign::Aries));
    db.insert(Person::new("Bob".to_string(), 1992, StarSign::Taurus));
    db.insert(Person::new("Charlie".to_string(), 1991, StarSign::Aries));
    db.insert(Person::new("Dave".to_string(), 1993, StarSign::Gemini));
    let eve = Person::new("Eve".to_string(), 1984, StarSign::Cancer);
    db.insert(eve.clone());
    db.insert(Person::new("Frank".to_string(), 1995, StarSign::Gemini));
    db.insert(Person::new("Grace".to_string(), 1996, StarSign::Cancer));
    db.insert(Person::new("Heidi".to_string(), 1997, StarSign::Aries));

    let q = db.query();

    // Find a person by name, using the first index
    let found = q.0.get_one(&"Eve".to_string());
    assert_eq!(found, Some(&eve));

    // Find the youngest person, using the second index
    let youngest = q.1.max_one();
    assert_eq!(
        youngest,
        Some((
            &1997,
            &Person::new("Heidi".to_string(), 1997, StarSign::Aries)
        ))
    );

    // Count the number of Gemini for each star sign, using the third index
    let gemini_count = q.2.get(&StarSign::Gemini);
    assert_eq!(gemini_count, 2);
}

pub fn get(&self, key: Key) -> Option<&In>

pub fn iter(&self) -> impl Iterator<Item = (&Key, &In)>

pub fn insert(&mut self, value: In) -> Key

Examples found in repository

examples/simple.rs (line 13)

fn main() {
    let mut db = Collection::<Person, _>::new(indexes::zip3(
        // A hashtable index is useful for fast lookups
        indexes::premap(|p: &Person| p.name.clone(), indexes::hashtable()),
        // A btree index can provide max/min queries
        indexes::premap(|p: &Person| p.birth_year, indexes::btree()),
        // A grouped index can provide a "filtering" view
        indexes::grouped(|p: &Person| p.starsign.clone(), || aggregations::count()),
    ));

    db.insert(Person::new("Alice".to_string(), 1990, StarSign::Aries));
    db.insert(Person::new("Bob".to_string(), 1992, StarSign::Taurus));
    db.insert(Person::new("Charlie".to_string(), 1991, StarSign::Aries));
    db.insert(Person::new("Dave".to_string(), 1993, StarSign::Gemini));
    let eve = Person::new("Eve".to_string(), 1984, StarSign::Cancer);
    db.insert(eve.clone());
    db.insert(Person::new("Frank".to_string(), 1995, StarSign::Gemini));
    db.insert(Person::new("Grace".to_string(), 1996, StarSign::Cancer));
    db.insert(Person::new("Heidi".to_string(), 1997, StarSign::Aries));

    let q = db.query();

    // Find a person by name, using the first index
    let found = q.0.get_one(&"Eve".to_string());
    assert_eq!(found, Some(&eve));

    // Find the youngest person, using the second index
    let youngest = q.1.max_one();
    assert_eq!(
        youngest,
        Some((
            &1997,
            &Person::new("Heidi".to_string(), 1997, StarSign::Aries)
        ))
    );

    // Count the number of Gemini for each star sign, using the third index
    let gemini_count = q.2.get(&StarSign::Gemini);
    assert_eq!(gemini_count, 2);
}

pub fn update<F>(&mut self, key: Key, f: F)

where F: FnOnce(Option<&In>) -> In,

pub fn delete(&mut self, key: Key)

pub fn query(&'t self) -> Ix::Query<In>

Examples found in repository

examples/simple.rs (line 23)

fn main() {
    let mut db = Collection::<Person, _>::new(indexes::zip3(
        // A hashtable index is useful for fast lookups
        indexes::premap(|p: &Person| p.name.clone(), indexes::hashtable()),
        // A btree index can provide max/min queries
        indexes::premap(|p: &Person| p.birth_year, indexes::btree()),
        // A grouped index can provide a "filtering" view
        indexes::grouped(|p: &Person| p.starsign.clone(), || aggregations::count()),
    ));

    db.insert(Person::new("Alice".to_string(), 1990, StarSign::Aries));
    db.insert(Person::new("Bob".to_string(), 1992, StarSign::Taurus));
    db.insert(Person::new("Charlie".to_string(), 1991, StarSign::Aries));
    db.insert(Person::new("Dave".to_string(), 1993, StarSign::Gemini));
    let eve = Person::new("Eve".to_string(), 1984, StarSign::Cancer);
    db.insert(eve.clone());
    db.insert(Person::new("Frank".to_string(), 1995, StarSign::Gemini));
    db.insert(Person::new("Grace".to_string(), 1996, StarSign::Cancer));
    db.insert(Person::new("Heidi".to_string(), 1997, StarSign::Aries));

    let q = db.query();

    // Find a person by name, using the first index
    let found = q.0.get_one(&"Eve".to_string());
    assert_eq!(found, Some(&eve));

    // Find the youngest person, using the second index
    let youngest = q.1.max_one();
    assert_eq!(
        youngest,
        Some((
            &1997,
            &Person::new("Heidi".to_string(), 1997, StarSign::Aries)
        ))
    );

    // Count the number of Gemini for each star sign, using the third index
    let gemini_count = q.2.get(&StarSign::Gemini);
    assert_eq!(gemini_count, 2);
}

pub fn len(&self) -> usize