Struct transit_model::collection::Collection

pub struct Collection<T> { /* fields omitted */ }

The Collection object looks like a Map<Idx<T>, T>, with opaque keys. Then, you can easily store indices and don't mess up between different types of indices.

Methods

impl<T> Collection<T>

pub fn new(v: Vec<T>) -> Self

Creates the Collection from a Vec.

Examples

let _: Collection<i32> = Collection::new(vec![1, 1, 2, 3, 5, 8]);

pub fn len(&self) -> usize

Returns the number of elements in the collection, also referred to as its 'length'.

Examples

let c: Collection<i32> = Collection::new(vec![1, 1, 2, 3, 5, 8]);
assert_eq!(c.len(), 6);

pub fn iter(&self) -> Iter<T>

Iterates over the (Idx<T>, &T) of the Collection.

Examples

let c: Collection<i32> = Collection::new(vec![1, 1, 2, 3, 5, 8]);
let (k, v): (Idx<i32>, &i32) = c.iter().nth(4).unwrap();
assert_eq!(v, &5);
assert_eq!(&c[k], &5);

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

Iterates over the &T of the Collection.

Examples

let c: Collection<i32> = Collection::new(vec![1, 1, 2, 3, 5, 8]);
let values: Vec<&i32> = c.values().collect();
assert_eq!(values, &[&1, &1, &2, &3, &5, &8]);

pub fn values_mut(&mut self) -> IterMut<T>

Iterates over the &mut T of the Collection.

Examples

let mut c: Collection<i32> = Collection::new(vec![1, 1, 2, 3, 5, 8]);
for elem in c.values_mut() {
    *elem *= 2;
}
assert_eq!(c, Collection::new(vec![2, 2, 4, 6, 10, 16]));

pub fn iter_from<I>(&self, indexes: I) -> impl Iterator<Item = &T> where
    I: IntoIterator,
    I::Item: Borrow<Idx<T>>, 

Iterates on the objects corresponding to the given indices.

Examples

let c = Collection::new(vec!["bike", "bus", "walking", "car", "metro", "train"]);
let transit_indices: BTreeSet<Idx<&str>> = get_transit_indices(&c);
let transit_refs: Vec<&&str> = c.iter_from(&transit_indices).collect();
assert_eq!(transit_refs, &[&"bus", &"metro", &"train"]);

pub fn push(&mut self, item: T) -> Idx<T>

Push an element in the Collection without control.

Examples

let mut c = Collection::default();
let foo_idx = c.push(Obj("foo"));
let bar_idx = c.push(Obj("bar"));
assert_eq!(&c[foo_idx], &Obj("foo"));
assert_ne!(&c[foo_idx], &Obj("bar"));

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

Merge a Collection parameter into the current one.

Examples

let mut c1 = Collection::from(Obj("foo"));
let c2 = Collection::from(Obj("bar"));
c1.merge(c2);
assert_eq!(c1.len(), 2);

pub fn take(&mut self) -> Vec<T>

Takes the corresponding vector without clones or allocation, leaving self empty.

Examples

let mut c = Collection::new(vec![Obj("foo"), Obj("bar")]);
let v = c.take();
assert_eq!(v, &[Obj("foo"), Obj("bar")]);
assert_eq!(c.len(), 0);

pub fn is_empty(&self) -> bool

Examples

let mut c: Collection<Obj> = Collection::default();
assert!(c.is_empty());

pub fn retain<F: FnMut(&T) -> bool>(&mut self, f: F)

Retains the elements matching predicate parameter from the current CollectionWithId object

Examples

let mut c = Collection::new(vec![Obj("foo"), Obj("bar"), Obj("qux")]);
let mut ids_to_keep: HashSet<String> = HashSet::new();
ids_to_keep.insert("foo".to_string());
ids_to_keep.insert("qux".to_string());
c.retain(|item| ids_to_keep.contains(item.0));
assert_eq!(c.len(), 2);
assert_eq!(c.values().map(|obj| obj.0).collect::<Vec<&str>>(), ["foo", "qux"]);

Trait Implementations

impl<T> From<T> for Collection<T>

Creates a Collection from one element.

Examples

let collection: Collection<i32> = Collection::from(42);
assert_eq!(collection.len(), 1);
let integer = collection.into_iter().next().unwrap();
assert_eq!(integer, 42);

fn from(object: T) -> Self

Performs the conversion.

impl<T: PartialEq> PartialEq<Collection<T>> for Collection<T>

fn eq(&self, other: &Collection<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T> Default for Collection<T>

fn default() -> Self

Returns the "default value" for a type.

impl<'a, T> IntoIterator for &'a Collection<T>

type Item = (Idx<T>, &'a T)

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<T> IntoIterator for Collection<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Clone> Clone for Collection<T>

fn clone(&self) -> Collection<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Collection<T>

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

Formats the value using the given formatter.

impl<T> Index<Idx<T>> for Collection<T>

type Output = T

The returned type after indexing.

fn index(&self, index: Idx<T>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'de, T> Deserialize<'de> for Collection<T> where
    T: Deserialize<'de>, 

fn deserialize<D>(deserializer: D) -> StdResult<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for Collection<T> where
    T: Serialize, 

fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.