1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
// Copyright (c) 2016 multimap developers
//
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
// option. All files in the project carrying such notice may not be copied,
// modified, or distributed except according to those terms.
use std::collections::hash_map::OccupiedEntry as HashMapOccupiedEntry;
use std::collections::hash_map::VacantEntry as HashMapVacantEntry;
/// A view into a single occupied location in a MultiMap.
pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
#[doc(hidden)]
pub inner: HashMapOccupiedEntry<'a, K, Vec<V>>,
}
/// A view into a single empty location in a MultiMap.
pub struct VacantEntry<'a, K: 'a, V: 'a> {
#[doc(hidden)]
pub inner: HashMapVacantEntry<'a, K, Vec<V>>,
}
/// A view into a single location in a map, which may be vacant or occupied.
pub enum Entry<'a, K: 'a, V: 'a> {
/// An occupied Entry.
Occupied(OccupiedEntry<'a, K, V>),
/// A vacant Entry.
Vacant(VacantEntry<'a, K, V>),
}
impl<'a, K: 'a, V: 'a> OccupiedEntry<'a, K, V> {
/// Gets a reference to the first item in value in the vector corresponding to entry.
///
/// # Panics
///
/// This method will panic if the key has zero values.
pub fn get(&self) -> &V {
self.inner.get().first().expect("no values in entry")
}
/// Gets a reference to the values (vector) corresponding to entry.
pub fn get_vec(&self) -> &Vec<V> {
self.inner.get()
}
/// Gets a mut reference to the first item in value in the vector corresponding to entry.
///
/// # Panics
///
/// This method will panic if the key has zero values.
pub fn get_mut(&mut self) -> &mut V {
self.inner
.get_mut()
.first_mut()
.expect("no values in entry")
}
/// Gets a mut reference to the values (vector) corresponding to entry.
pub fn get_vec_mut(&mut self) -> &mut Vec<V> {
self.inner.get_mut()
}
/// Converts the OccupiedEntry into a mutable reference to the first item in value in the entry
/// with a lifetime bound to the map itself
pub fn into_mut(self) -> &'a mut V {
&mut self.inner.into_mut()[0]
}
/// Converts the OccupiedEntry into a mutable reference to the values (vector) in the entry
/// with a lifetime bound to the map itself
pub fn into_vec_mut(self) -> &'a mut Vec<V> {
self.inner.into_mut()
}
/// Inserts a new value onto the vector of the entry.
pub fn insert(&mut self, value: V) {
self.get_vec_mut().push(value);
}
/// Extends the existing vector with the specified values.
pub fn insert_vec(&mut self, values: Vec<V>) {
self.get_vec_mut().extend(values);
}
/// Takes the values (vector) out of the entry, and returns it
pub fn remove(self) -> Vec<V> {
self.inner.remove()
}
}
impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
/// Sets the first value in the vector of the entry with the VacantEntry's key,
/// and returns a mutable reference to it.
pub fn insert(self, value: V) -> &'a mut V {
&mut self.inner.insert(vec![value])[0]
}
/// Sets values in the entry with the VacantEntry's key,
/// and returns a mutable reference to it.
pub fn insert_vec(self, values: Vec<V>) -> &'a mut Vec<V> {
self.inner.insert(values)
}
}
impl<'a, K: 'a, V: 'a> Entry<'a, K, V> {
/// Ensures a value is in the entry by inserting the default if empty, and returns
/// a mutable reference to the value in the entry. This will return a mutable reference to the
/// first value in the vector corresponding to the specified key.
pub fn or_insert(self, default: V) -> &'a mut V {
match self {
Entry::Occupied(entry) => entry.into_mut(),
Entry::Vacant(entry) => entry.insert(default),
}
}
/// Ensures a value is in the entry by inserting the default values if empty, and returns
/// a mutable reference to the values (the corresponding vector to the specified key) in
/// the entry.
pub fn or_insert_vec(self, defaults: Vec<V>) -> &'a mut Vec<V> {
match self {
Entry::Occupied(entry) => entry.into_vec_mut(),
Entry::Vacant(entry) => entry.insert_vec(defaults),
}
}
}