Struct NEBTreeMap 

pub struct NEBTreeMap<K, V> { /* private fields */ }

A non-empty, growable BTreeMap.

use nonempty_collections::nebtm;

let m = nebtm!["elves" => 3000, "orcs" => 10000];
assert_eq!(2, m.len().get());

Implementations

impl<K, V> NEBTreeMap<K, V>

where K: Ord,

pub fn new(k: K, v: V) -> NEBTreeMap<K, V>

Creates a new NEBTreeMap with a single element.

impl<K, V> NEBTreeMap<K, V>

pub fn try_from_map(map: BTreeMap<K, V>) -> Option<Self>

Attempt a conversion from BTreeMap, consuming the given BTreeMap. Will return None if the BTreeMap is empty.

use std::collections::*;

use nonempty_collections::*;

let mut map = BTreeMap::new();
map.extend([("a", 1), ("b", 2)]);
assert_eq!(Some(nebtm! {"a" => 1, "b" => 2}), NEBTreeMap::try_from_map(map));
let map: BTreeMap<(), ()> = BTreeMap::new();
assert_eq!(None, NEBTreeMap::try_from_map(map));

pub fn iter(&self) -> Iter<'_, K, V>

Returns a regular iterator over the entries in this non-empty map.

For a NonEmptyIterator see Self::nonempty_iter().

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

Returns a regular mutable iterator over the entries in this non-empty map.

For a NonEmptyIterator see Self::nonempty_iter_mut().

pub fn nonempty_iter(&self) -> Iter<'_, K, V>

An iterator visiting all elements in arbitrary order. The iterator element type is (&'a K, &'a V).

pub fn nonempty_iter_mut(&mut self) -> IterMut<'_, K, V>

An iterator visiting all elements in arbitrary order. The iterator element type is (&'a K, &'a mut V).

Panics

If you manually advance this iterator until empty and then call first, you’re in for a surprise.

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

use nonempty_collections::*;

let m = nebtm!["Valmar" => "Vanyar", "Tirion" => "Noldor", "Alqualondë" => "Teleri"];
let mut v: NEVec<_> = m.keys().collect();
v.sort();
assert_eq!(nev![&"Alqualondë", &"Tirion", &"Valmar"], v);

pub fn len(&self) -> NonZeroUsize

Returns the number of elements in the map. Always 1 or more.

use nonempty_collections::nebtm;

let m = nebtm!["a" => 1, "b" => 2];
assert_eq!(2, m.len().get());

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

use nonempty_collections::*;

let m = nebtm!["Valmar" => "Vanyar", "Tirion" => "Noldor", "Alqualondë" => "Teleri"];
let mut v: NEVec<_> = m.values().collect();
v.sort();
assert_eq!(nev![&"Noldor", &"Teleri", &"Vanyar"], v);

impl<K, V> NEBTreeMap<K, V>

where K: Ord,

pub fn contains_key<Q>(&self, k: &Q) -> bool

where K: Borrow<Q>, Q: Ord + ?Sized,

Returns true if the map contains a value.

use nonempty_collections::nebtm;

let m = nebtm!["Jack" => 8];
assert!(m.contains_key("Jack"));
assert!(!m.contains_key("Colin"));

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Ord + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s value type, but Hash and Eq on the borrowed form must match those for the key type.

use nonempty_collections::nebtm;

let m = nebtm!["silmarils" => 3];
assert_eq!(Some(&3), m.get("silmarils"));
assert_eq!(None, m.get("arkenstone"));

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>

where K: Borrow<Q>, Q: Ord + ?Sized,

Returns the key-value pair corresponding to the key.

The key may be any borrowed form of the map’s value type, but Hash and Eq on the borrowed form must match those for the key type.

use nonempty_collections::nebtm;

let m = nebtm!["silmarils" => 3];
assert_eq!(Some((&"silmarils", &3)), m.get_key_value("silmarils"));
assert_eq!(None, m.get_key_value("arkenstone"));

pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>

where K: Borrow<Q>, Q: Ord + ?Sized,

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s value type, but Hash and Eq on the borrowed form must match those for the key type.

use nonempty_collections::nebtm;

let mut m = nebtm!["silmarils" => 3];
let mut v = m.get_mut("silmarils").unwrap();

// And thus it came to pass that the Silmarils found their long homes:
// one in the airs of heaven, and one in the fires of the heart of the
// world, and one in the deep waters.
*v -= 3;

assert_eq!(Some(&0), m.get("silmarils"));

pub fn insert(&mut self, k: K, v: V) -> Option<V>

Insert a key-value pair into the map.

If the map did not have this present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See BTreeMap::insert for more.

use nonempty_collections::nebtm;

let mut m = nebtm!["Vilya" => "Elrond", "Nenya" => "Galadriel"];
assert_eq!(None, m.insert("Narya", "Cirdan"));

// The Ring of Fire was given to Gandalf upon his arrival in Middle Earth.
assert_eq!(Some("Cirdan"), m.insert("Narya", "Gandalf"));

Trait Implementations

impl<K, V> AsMut<BTreeMap<K, V>> for NEBTreeMap<K, V>

fn as_mut(&mut self) -> &mut BTreeMap<K, V>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<K, V> AsRef<BTreeMap<K, V>> for NEBTreeMap<K, V>

fn as_ref(&self) -> &BTreeMap<K, V>

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: Clone, V: Clone> Clone for NEBTreeMap<K, V>

fn clone(&self) -> NEBTreeMap<K, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug> Debug for NEBTreeMap<K, V>

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

Formats the value using the given formatter.

impl<'de, K, V> Deserialize<'de> for NEBTreeMap<K, V>

where K: Ord + Clone + Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> Eq for NEBTreeMap<K, V>

where K: Ord, V: Eq,

impl<K, V> Extend<(K, V)> for NEBTreeMap<K, V>

where K: Ord,

fn extend<I: IntoIterator<Item = (K, V)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<K, V> From<NEBTreeMap<K, V>> for BTreeMap<K, V>

where K: Ord,

fn from(m: NEBTreeMap<K, V>) -> Self

use nonempty_collections::nebtm;
use std::collections::BTreeMap;

let m: BTreeMap<&str, usize> = nebtm!["population" => 1000].into();
assert!(m.contains_key("population"));

impl<K, V> FromNonEmptyIterator<(K, V)> for NEBTreeMap<K, V>

where K: Ord,

use nonempty_collections::*;

let v = nev![('a', 1), ('b', 2), ('c', 3), ('a', 4)];
let m0: NEBTreeMap<_, _> = v.into_nonempty_iter().collect();
let m1: NEBTreeMap<_, _> = nebtm!['a' => 4, 'b' => 2, 'c' => 3];
assert_eq!(m0, m1);

fn from_nonempty_iter<I>(iter: I) -> Self

where I: IntoNonEmptyIterator<Item = (K, V)>,

Creates a value from a NonEmptyIterator.

impl<K, V> IntoIterator for NEBTreeMap<K, V>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a NEBTreeMap<K, V>

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V> IntoIterator for &'a mut NEBTreeMap<K, V>

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> IntoNonEmptyIterator for NEBTreeMap<K, V>

type IntoNEIter = IntoIter<K, V>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoNEIter

Creates a NonEmptyIterator from a value.

impl<'a, K, V> IntoNonEmptyIterator for &'a NEBTreeMap<K, V>

type IntoNEIter = Iter<'a, K, V>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoNEIter

Creates a NonEmptyIterator from a value.

impl<K, V> PartialEq for NEBTreeMap<K, V>

where K: Ord, V: PartialEq,

fn eq(&self, other: &Self) -> bool

This is an O(n) comparison of each key/value pair, one by one. Short-circuits if any comparison fails.

use nonempty_collections::*;

let m0 = nebtm!['a' => 1, 'b' => 2];
let m1 = nebtm!['b' => 2, 'a' => 1];
assert_eq!(m0, m1);

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<K, V> Serialize for NEBTreeMap<K, V>

where K: Ord + Clone + Serialize, V: Clone + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V> Singleton for NEBTreeMap<K, V>

where K: Ord,

fn singleton((k, v): Self::Item) -> Self

use nonempty_collections::{NEBTreeMap, Singleton, nebtm};

let m = NEBTreeMap::singleton(('a', 1));
assert_eq!(nebtm!['a' => 1], m);

type Item = (K, V)

impl<K, V> TryFrom<BTreeMap<K, V>> for NEBTreeMap<K, V>

where K: Ord,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(map: BTreeMap<K, V>) -> Result<Self, Self::Error>

Performs the conversion.