Struct GroupMap

pub struct GroupMap<GK, GV, IK, IV, S> { /* private fields */ }

A hash map containing Groups and Items.

Conceptually, group contains items in it, and item can belong to multiple groups. They cannot exist without relationship to each other. In other words, they must be linked. See a diagram below. In this map, group has an ordered links to items, while item has an unordered links to groups.

Groups    G0  G1
          /\  /\
Items   I0  I1  I2

The map provides you some ways to access groups and items by their keys and indices. If possible, prefer to use index to key because it can be faster.

Implementations

impl<GK, GV, IK, IV, S> GroupMap<GK, GV, IK, IV, S>

where S: Default,

pub fn new() -> Self

Creates a new empty map.

impl<GK, GV, IK, IV, S> GroupMap<GK, GV, IK, IV, S>

where GK: Hash + Eq + Clone, IK: Hash + Eq + Clone, S: BuildHasher,

pub fn contains_group(&self, index: usize) -> bool

Returns true if the map contains a group at the given group index.

Consider using GroupMap::contains_group2 if you need to know whether the map contains it or not by a key.

pub fn contains_group2<Q>(&self, key: &Q) -> bool

where GK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the map contains a group corresponding to the given group key.

Consider using GroupMap::contains_group if you need to know whether the map contains it or not by an index.

pub fn get_group(&self, index: usize) -> Option<(&GV, &Vec<usize>)>

Retrieves a shared reference to a group and related item indices by the given group index.

Consider using GroupMap::get_group2 if you need to get a group by a key.

pub fn get_group2<Q>(&self, key: &Q) -> Option<(&GV, &Vec<usize>)>

where GK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a shared reference to a group and related item indices by the given group key.

Consider using GroupMap::get_group if you need to get a group by an index.

pub fn get_group_mut(&mut self, index: usize) -> Option<(&mut GV, &Vec<usize>)>

Retrieves a mutable reference to a group and related item indices by the given group index.

Consider using GroupMap::get_group_mut2 if you need to get a group by a key.

pub fn get_group_mut2<Q>(&mut self, key: &Q) -> Option<(&mut GV, &Vec<usize>)>

where GK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a mutable reference to a group and related item indices by the given group key.

Consider using GroupMap::get_group_mut if you need to get a group by an index.

pub fn get_group_key(&self, index: usize) -> Option<&GK>

Retrieves group key corresponding to the given group index.

You can also get a group index from a key using GroupMap::get_group_index.

pub fn get_group_index<Q>(&self, key: &Q) -> Option<usize>

where GK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a group index corresponding to the given group key.

You can also get a group key from an index using GroupMap::get_group_key.

pub fn iter_group(&self) -> impl Iterator<Item = (&GK, usize, &GV)>

Returns an iterator visiting all groups.

The iterator yields pairs of group key, group index, and shared reference to group value.

pub fn contains_item(&self, index: usize) -> bool

Returns true if the map contains an item at the given item index.

Consider using GroupMap::contains_item2 if you need to know whether the map contains it or not by a key.

pub fn contains_item2<Q>(&self, key: &Q) -> bool

where IK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns true if the map contains an item corresponding to the given item key.

Consider using GroupMap::contains_item if you need to know whether the map contains it or not by an index.

pub fn get_item(&self, index: usize) -> Option<&(IV, HashSet<usize, S>)>

Retrieves a shared reference to an item and related group indices by the given item index.

Consider using GroupMap::get_item2 if you need to get an item by a key.

pub fn get_item2<Q>(&self, key: &Q) -> Option<&(IV, HashSet<usize, S>)>

where IK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a shared reference to an item and related group indices by the given item key.

Consider using GroupMap::get_item if you need to get an item by an index.

pub fn get_item_mut( &mut self, index: usize, ) -> Option<(&mut IV, &HashSet<usize, S>)>

Retrieves a mutable reference to an item and related group indices by the given item index.

Consider using GroupMap::get_item_mut2 if you need to get an item by a key.

pub fn get_item_mut2<Q>( &mut self, key: &Q, ) -> Option<(&mut IV, &HashSet<usize, S>)>

where IK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves a mutable reference to an item and related group indices by the given item key.

Consider using GroupMap::get_item_mut if you need to get an item by an index.

pub fn get_item_key(&self, index: usize) -> Option<&IK>

Retrieves an item key corresponding to the given item index.

You can also get an item index from a key using GroupMap::get_item_index.

pub fn get_item_index<Q>(&self, key: &Q) -> Option<usize>

where IK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Retrieves an item index corresponding to the given item key.

You can also get an item key from an index using GroupMap::get_item_key.

pub fn iter_item(&self) -> impl Iterator<Item = (&IK, usize, &IV)>

Returns an iterator visiting all items.

The iterator yields pairs of item key, item index, and shared reference to item value.

impl<GK, GV, IK, IV, S> GroupMap<GK, GV, IK, IV, S>

where GK: Hash + Eq + Clone, IK: Hash + Eq + Clone, S: BuildHasher + Default,

pub fn next_index<Q>(&self, key: &Q) -> usize

where GK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Returns the next index that will be returned on the next call to either GroupMap::add_group or GroupMap::add_group_from_desc.

pub fn add_group( &mut self, desc: impl DescribeGroup<GK, GV, IK, IV>, ) -> Result<usize, GroupDesc<GK, GV, IK, IV>>

Inserts a group and related items into the map from the given group descriptor.

This method is a simple wrapper of GroupMap::add_group_from_desc for easy use.

pub fn add_group_from_desc( &mut self, desc: GroupDesc<GK, GV, IK, IV>, ) -> Result<usize, GroupDesc<GK, GV, IK, IV>>

Inserts a group and related items into the map from the given group descriptor.

Note that this method doesn’t overwrite anything. Therefore, if the map already contains the same group key, returns error. With respect to item, only relation to the group is adapted and item value is dropped if the map already contains the item. If you want replace, remove old one first.

Panics

Panics if the descriptor doesn’t contain any items in it. Group cannot exist without relationship with items. See GroupMap documentation for more details.

pub fn remove_group(&mut self, index: usize) -> Option<(GK, GV)>

Removes a group at the given group index from the map.

Related items are automatically removed as well if they don’t have relationships anymore by the removal of the group.

Consider using GroupMap::remove_group2 if you need to remove a group by a key.

pub fn remove_group2<Q>(&mut self, key: &Q) -> Option<(GK, GV)>

where GK: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes a group corresponding to the given group key from the map.

Related items are automatically removed as well if they don’t have relationships anymore by the removal of the group.

Consider using GroupMap::remove_group if you need to remove a group by an index.

Trait Implementations

impl<GK: Clone, GV: Clone, IK: Clone, IV: Clone, S: Clone> Clone for GroupMap<GK, GV, IK, IV, S>

fn clone(&self) -> GroupMap<GK, GV, IK, IV, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<GK: Debug, GV: Debug, IK: Debug, IV: Debug, S: Debug> Debug for GroupMap<GK, GV, IK, IV, S>

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

Formats the value using the given formatter.

impl<GK, GV, IK, IV, S> Default for GroupMap<GK, GV, IK, IV, S>

where S: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<GK, GV, IK, IV, S> Resource for GroupMap<GK, GV, IK, IV, S>

where GK: Send + 'static, GV: Send + 'static, IK: Send + 'static, IV: Send + 'static, S: Send + 'static,