Enum managed::ManagedMap

pub enum ManagedMap<'a, K: 'a, V: 'a> {
    Borrowed(&'a mut [Option<(K, V)>]),
    Owned(BTreeMap<K, V>),
}

A managed map.

This enum can be used to represent exclusive access to maps. In Rust, exclusive access to an object is obtained by either owning the object, or owning a mutable pointer to the object; hence, “managed”.

The purpose of this enum is providing good ergonomics with std present while making it possible to avoid having a heap at all (which of course means that std is not present). To achieve this, the variants other than Borrow are only available when the corresponding feature is opted in.

Unlike Managed and ManagedSlice, the managed map is implemented using a B-tree map when allocation is available, and a sorted slice of key-value pairs when it is not. Thus, algorithmic complexity of operations on it depends on the kind of map.

A function that requires a managed object should be generic over an Into<ManagedMap<'a, T>> argument; then, it will be possible to pass either a Vec<T>, or a &'a mut [T] without any conversion at the call site.

See also Managed.

Variants

Borrowed(&'a mut [Option<(K, V)>])

Borrowed variant.

Owned(BTreeMap<K, V>)

Owned variant, only available with the std or alloc feature enabled.

Implementations

impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V>

pub fn clear(&mut self)

pub fn get<Q>(&self, key: &Q) -> Option<&V> where
    K: Borrow<Q>,
    Q: Ord + ?Sized, 

pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V> where
    K: Borrow<Q>,
    Q: Ord + ?Sized, 

pub fn range<'b, 'c, Q: 'c, R>(&'b self, range: R) -> Range<'a, K, V> where
    K: Borrow<Q>,
    Q: Ord + ?Sized,
    R: RangeBounds<Q>,
    'b: 'a, 

pub fn insert(&mut self, key: K, new_value: V) -> Result<Option<V>, (K, V)>

pub fn remove<Q>(&mut self, key: &Q) -> Option<V> where
    K: Borrow<Q>,
    Q: Ord + ?Sized, 

pub fn is_empty(&self) -> bool

ManagedMap contains no elements?

pub fn len(&self) -> usize

Returns the number of elements in the ManagedMap.

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

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

Trait Implementations

impl<'a, K: 'a, V: 'a> Debug for ManagedMap<'a, K, V> where
    K: Debug,
    V: Debug, 

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

Formats the value using the given formatter.

impl<'a, K: 'a, V: 'a> From<&'a mut [Option<(K, V)>]> for ManagedMap<'a, K, V>

fn from(value: &'a mut [Option<(K, V)>]) -> Self

Converts to this type from the input type.

impl<'a, K: 'a, V: 'a> From<BTreeMap<K, V>> for ManagedMap<'a, K, V>

fn from(value: BTreeMap<K, V>) -> Self

Converts to this type from the input type.