Struct superfusion::index::IndexList

pub struct IndexList<'a> { /* fields omitted */ }

List of Index's references

It use HashSet internally but provide a bit of abstraction that allow looking up Index base on "path similarity"

Implementations

impl<'a> IndexList<'a>

pub fn new(indexes: HashSet<&'a Index>) -> Self

pub fn get_different_pid(&self, index: &Index) -> Option<&Index>

Get index loosely base on the relative path similar to IndexList::get() but the result index must not contain the same Pid as the given index.

let alpha = Pid::new(0);
let beta = Pid::new(1);

let foo = Index::new(alpha, "example/path");
let bar = Index::new(beta, "example/path");

let mut list = HashSet::new();
list.insert(&foo);
let list = IndexList::new(list);

assert_eq!(list.get_different_pid(&foo), None);
assert_eq!(list.get_different_pid(&bar), Some(&Index::new(alpha, "example/path")));

pub fn get(&self, index: &Index) -> Option<&Index>

Get index loosely base on the relative path

let alpha = Pid::new(0);
let beta = Pid::new(1);

let foo = Index::new(alpha, "example/path");
let bar = Index::new(beta, "example/path");

let mut list = HashSet::new();
list.insert(&foo);
let list = IndexList::new(list);

assert_eq!(list.get(&bar), Some(&Index::new(alpha, "example/path")));

pub fn get_exact(&self, index: &Index) -> Option<&Index>

Get index with exactly the same Pid and Path

This method is really useless since you need to already know the index to run it but it can be useful to check if the index exists, I suppose.

pub fn inner(&self) -> &HashSet<&Index>

Get access to the internal's HashSet

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

Create iterator over Index's reference

Trait Implementations

impl<'a> Clone for IndexList<'a>

fn clone(&self) -> IndexList<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for IndexList<'a>

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

Formats the value using the given formatter.

impl<'a> Default for IndexList<'a>

fn default() -> IndexList<'a>

Returns the "default value" for a type.

impl<'a> FromIterator<&'a Index> for IndexList<'a>

fn from_iter<T: IntoIterator<Item = &'a Index>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, 'b> IntoIterator for &'a IndexList<'b>

type Item = &'a &'b Index

The type of the elements being iterated over.

type IntoIter = Iter<'a, &'b Index>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for IndexList<'a>

type Item = &'a Index

The type of the elements being iterated over.

type IntoIter = IntoIter<&'a Index>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq<IndexList<'a>> for IndexList<'a>

fn eq(&self, other: &IndexList<'a>) -> bool

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

fn ne(&self, other: &IndexList<'a>) -> bool

This method tests for !=.

impl<'a> StructuralPartialEq for IndexList<'a>