Struct ordered_multimap::list_ordered_multimap::OccupiedEntry

pub struct OccupiedEntry<'map, Key, Value> { /* private fields */ }

A view into an occupied entry in the multimap.

Implementations

impl<'map, Key, Value> OccupiedEntry<'map, Key, Value>

pub fn append(&mut self, value: Value)

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

entry.append("value2");

let mut iter = map.get_all(&"key");
assert_eq!(iter.next(), Some(&"value1"));
assert_eq!(iter.next(), Some(&"value2"));
assert_eq!(iter.next(), None);

pub fn get(&self) -> &Value

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

assert_eq!(entry.get(), &"value");

pub fn get_mut(&mut self) -> &mut Value

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

assert_eq!(entry.get(), &mut "value");

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

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

entry.insert("value2");

assert_eq!(map.get(&"key"), Some(&"value2"));

pub fn insert_all(&mut self, value: Value) -> EntryValuesDrain<'_, Key, Value>

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
  Entry::Occupied(entry) => entry,
  _ => panic!("expected occupied entry")
};

entry.append("value2");

let mut iter = entry.insert_all("value3");
assert_eq!(iter.next(), Some("value1"));
assert_eq!(iter.next(), Some("value2"));
assert_eq!(iter.next(), None);

pub fn into_mut(self) -> &'map mut Value

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value");

let mut entry = match map.entry("key") {
  Entry::Occupied(entry) => entry,
  _ => panic!("expected occupied entry")
};

assert_eq!(entry.into_mut(), &mut "value");

pub fn iter(&self) -> EntryValues<'_, Key, Value>

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
  Entry::Occupied(entry) => entry,
  _ => panic!("expected occupied entry")
};

entry.append("value2");

let mut iter = entry.iter();
assert_eq!(iter.next(), Some(&"value1"));
assert_eq!(iter.next(), Some(&"value2"));
assert_eq!(iter.next(), None);

pub fn iter_mut(&mut self) -> EntryValuesMut<'_, Key, Value>

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

entry.append("value2");

let mut iter = entry.iter_mut();
assert_eq!(iter.next(), Some(&mut "value1"));
assert_eq!(iter.next(), Some(&mut "value2"));
assert_eq!(iter.next(), None);

pub fn key(&self) -> &Key

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
  Entry::Occupied(entry) => entry,
  _ => panic!("expected occupied entry")
};

assert_eq!(entry.key(), &"key");

pub fn len(&self) -> usize

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

assert_eq!(entry.len(), 1);

entry.append("value2");
assert_eq!(entry.len(), 2);

pub fn remove(self) -> Value

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

assert_eq!(entry.remove(), "value");

pub fn remove_all(self) -> EntryValuesDrain<'map, Key, Value>

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

entry.append("value2");

let mut iter = entry.remove_all();
assert_eq!(iter.next(), Some("value1"));
assert_eq!(iter.next(), Some("value2"));
assert_eq!(iter.next(), None);

pub fn remove_entry(self) -> (Key, Value)

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

assert_eq!(entry.remove_entry(), ("key", "value"));

pub fn remove_entry_all(self) -> (Key, EntryValuesDrain<'map, Key, Value>)

Examples

use ordered_multimap::ListOrderedMultimap;
use ordered_multimap::list_ordered_multimap::Entry;

let mut map = ListOrderedMultimap::new();
map.insert("key", "value1");

let mut entry = match map.entry("key") {
    Entry::Occupied(entry) => entry,
    _ => panic!("expected occupied entry")
};

entry.append("value2");

let (key, mut iter) = entry.remove_entry_all();
assert_eq!(key, "key");
assert_eq!(iter.next(), Some("value1"));
assert_eq!(iter.next(), Some("value2"));
assert_eq!(iter.next(), None);

Trait Implementations

impl<Key, Value> Debug for OccupiedEntry<'_, Key, Value>

where Key: Debug, Value: Debug,

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

Formats the value using the given formatter.