Struct sp_core::bounded::bounded_btree_map::BoundedBTreeMap

pub struct BoundedBTreeMap<K, V, S>(_, _);

A bounded map based on a B-Tree.

B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing the amount of work performed in a search. See BTreeMap for more details.

Unlike a standard BTreeMap, there is an enforced upper limit to the number of items in the map. All internal operations ensure this bound is respected.

Implementations

impl<K, V, S> BoundedBTreeMap<K, V, S>where
    S: Get<u32>,

pub fn bound() -> usize

Get the bound of the type in usize.

Examples found in repository

src/bounded/bounded_btree_map.rs (line 94)

	pub fn into_inner(self) -> BTreeMap<K, V> {
		debug_assert!(self.0.len() <= Self::bound());
		self.0
	}

	/// Consumes self and mutates self via the given `mutate` function.
	///
	/// If the outcome of mutation is within bounds, `Some(Self)` is returned. Else, `None` is
	/// returned.
	///
	/// This is essentially a *consuming* shorthand [`Self::into_inner`] -> `...` ->
	/// [`Self::try_from`].
	pub fn try_mutate(mut self, mut mutate: impl FnMut(&mut BTreeMap<K, V>)) -> Option<Self> {
		mutate(&mut self.0);
		(self.0.len() <= Self::bound()).then(move || self)
	}

	/// Clears the map, removing all elements.
	pub fn clear(&mut self) {
		self.0.clear()
	}

	/// Return a mutable reference to the value corresponding to the key.
	///
	/// The key may be any borrowed form of the map's key type, but the ordering on the borrowed
	/// form _must_ match the ordering on the key type.
	pub fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
	where
		K: Borrow<Q>,
		Q: Ord + ?Sized,
	{
		self.0.get_mut(key)
	}

	/// Exactly the same semantics as [`BTreeMap::insert`], but returns an `Err` (and is a noop) if
	/// the new length of the map exceeds `S`.
	///
	/// In the `Err` case, returns the inserted pair so it can be further used without cloning.
	pub fn try_insert(&mut self, key: K, value: V) -> Result<Option<V>, (K, V)> {
		if self.len() < Self::bound() || self.0.contains_key(&key) {
			Ok(self.0.insert(key, value))
		} else {
			Err((key, value))
		}
	}

	/// Remove a key from the map, returning the value at the key if the key was previously in the
	/// map.
	///
	/// The key may be any borrowed form of the map's key type, but the ordering on the borrowed
	/// form _must_ match the ordering on the key type.
	pub fn remove<Q>(&mut self, key: &Q) -> Option<V>
	where
		K: Borrow<Q>,
		Q: Ord + ?Sized,
	{
		self.0.remove(key)
	}

	/// Remove a key from the map, returning the value at the key if the key was previously in the
	/// map.
	///
	/// The key may be any borrowed form of the map's key type, but the ordering on the borrowed
	/// form _must_ match the ordering on the key type.
	pub fn remove_entry<Q>(&mut self, key: &Q) -> Option<(K, V)>
	where
		K: Borrow<Q>,
		Q: Ord + ?Sized,
	{
		self.0.remove_entry(key)
	}

	/// Gets a mutable iterator over the entries of the map, sorted by key.
	///
	/// See [`BTreeMap::iter_mut`] for more information.
	pub fn iter_mut(&mut self) -> sp_std::collections::btree_map::IterMut<K, V> {
		self.0.iter_mut()
	}

	/// Consume the map, applying `f` to each of it's values and returning a new map.
	pub fn map<T, F>(self, mut f: F) -> BoundedBTreeMap<K, T, S>
	where
		F: FnMut((&K, V)) -> T,
	{
		BoundedBTreeMap::<K, T, S>::unchecked_from(
			self.0
				.into_iter()
				.map(|(k, v)| {
					let t = f((&k, v));
					(k, t)
				})
				.collect(),
		)
	}

	/// Consume the map, applying `f` to each of it's values as long as it returns successfully. If
	/// an `Err(E)` is ever encountered, the mapping is short circuited and the error is returned;
	/// otherwise, a new map is returned in the contained `Ok` value.
	pub fn try_map<T, E, F>(self, mut f: F) -> Result<BoundedBTreeMap<K, T, S>, E>
	where
		F: FnMut((&K, V)) -> Result<T, E>,
	{
		Ok(BoundedBTreeMap::<K, T, S>::unchecked_from(
			self.0
				.into_iter()
				.map(|(k, v)| (f((&k, v)).map(|t| (k, t))))
				.collect::<Result<BTreeMap<_, _>, _>>()?,
		))
	}
}

impl<K, V, S> Default for BoundedBTreeMap<K, V, S>
where
	K: Ord,
	S: Get<u32>,
{
	fn default() -> Self {
		Self::new()
	}
}

impl<K, V, S> Clone for BoundedBTreeMap<K, V, S>
where
	BTreeMap<K, V>: Clone,
{
	fn clone(&self) -> Self {
		BoundedBTreeMap(self.0.clone(), PhantomData)
	}
}

impl<K, V, S> sp_std::fmt::Debug for BoundedBTreeMap<K, V, S>
where
	BTreeMap<K, V>: sp_std::fmt::Debug,
	S: Get<u32>,
{
	fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result {
		f.debug_tuple("BoundedBTreeMap").field(&self.0).field(&Self::bound()).finish()
	}
}

impl<K, V, S1, S2> PartialEq<BoundedBTreeMap<K, V, S1>> for BoundedBTreeMap<K, V, S2>
where
	BTreeMap<K, V>: PartialEq,
	S1: Get<u32>,
	S2: Get<u32>,
{
	fn eq(&self, other: &BoundedBTreeMap<K, V, S1>) -> bool {
		S1::get() == S2::get() && self.0 == other.0
	}
}

impl<K, V, S> Eq for BoundedBTreeMap<K, V, S>
where
	BTreeMap<K, V>: Eq,
	S: Get<u32>,
{
}

impl<K, V, S> PartialEq<BTreeMap<K, V>> for BoundedBTreeMap<K, V, S>
where
	BTreeMap<K, V>: PartialEq,
{
	fn eq(&self, other: &BTreeMap<K, V>) -> bool {
		self.0 == *other
	}
}

impl<K, V, S> PartialOrd for BoundedBTreeMap<K, V, S>
where
	BTreeMap<K, V>: PartialOrd,
	S: Get<u32>,
{
	fn partial_cmp(&self, other: &Self) -> Option<sp_std::cmp::Ordering> {
		self.0.partial_cmp(&other.0)
	}
}

impl<K, V, S> Ord for BoundedBTreeMap<K, V, S>
where
	BTreeMap<K, V>: Ord,
	S: Get<u32>,
{
	fn cmp(&self, other: &Self) -> sp_std::cmp::Ordering {
		self.0.cmp(&other.0)
	}
}

impl<K, V, S> IntoIterator for BoundedBTreeMap<K, V, S> {
	type Item = (K, V);
	type IntoIter = sp_std::collections::btree_map::IntoIter<K, V>;

	fn into_iter(self) -> Self::IntoIter {
		self.0.into_iter()
	}
}

impl<'a, K, V, S> IntoIterator for &'a BoundedBTreeMap<K, V, S> {
	type Item = (&'a K, &'a V);
	type IntoIter = sp_std::collections::btree_map::Iter<'a, K, V>;

	fn into_iter(self) -> Self::IntoIter {
		self.0.iter()
	}
}

impl<'a, K, V, S> IntoIterator for &'a mut BoundedBTreeMap<K, V, S> {
	type Item = (&'a K, &'a mut V);
	type IntoIter = sp_std::collections::btree_map::IterMut<'a, K, V>;

	fn into_iter(self) -> Self::IntoIter {
		self.0.iter_mut()
	}
}

impl<K, V, S> MaxEncodedLen for BoundedBTreeMap<K, V, S>
where
	K: MaxEncodedLen,
	V: MaxEncodedLen,
	S: Get<u32>,
{
	fn max_encoded_len() -> usize {
		Self::bound()
			.saturating_mul(K::max_encoded_len().saturating_add(V::max_encoded_len()))
			.saturating_add(codec::Compact(S::get()).encoded_size())
	}
}

impl<K, V, S> Deref for BoundedBTreeMap<K, V, S>
where
	K: Ord,
{
	type Target = BTreeMap<K, V>;

	fn deref(&self) -> &Self::Target {
		&self.0
	}
}

impl<K, V, S> AsRef<BTreeMap<K, V>> for BoundedBTreeMap<K, V, S>
where
	K: Ord,
{
	fn as_ref(&self) -> &BTreeMap<K, V> {
		&self.0
	}
}

impl<K, V, S> From<BoundedBTreeMap<K, V, S>> for BTreeMap<K, V>
where
	K: Ord,
{
	fn from(map: BoundedBTreeMap<K, V, S>) -> Self {
		map.0
	}
}

impl<K, V, S> TryFrom<BTreeMap<K, V>> for BoundedBTreeMap<K, V, S>
where
	K: Ord,
	S: Get<u32>,
{
	type Error = ();

	fn try_from(value: BTreeMap<K, V>) -> Result<Self, Self::Error> {
		(value.len() <= Self::bound())
			.then(move || BoundedBTreeMap(value, PhantomData))
			.ok_or(())
	}

impl<K, V, S> BoundedBTreeMap<K, V, S>where
    K: Ord,
    S: Get<u32>,

pub fn retain<F: FnMut(&K, &mut V) -> bool>(&mut self, f: F)

Exactly the same semantics as BTreeMap::retain.

The is a safe &mut self borrow because retain can only ever decrease the length of the inner map.

pub fn new() -> Self

Create a new BoundedBTreeMap.

Does not allocate.

Examples found in repository

src/bounded/bounded_btree_map.rs (line 210)

	fn default() -> Self {
		Self::new()
	}

pub fn into_inner(self) -> BTreeMap<K, V>

Consume self, and return the inner BTreeMap.

This is useful when a mutating API of the inner type is desired, and closure-based mutation such as provided by try_mutate is inconvenient.

pub fn try_mutate(self, mutate: impl FnMut(&mut BTreeMap<K, V>)) -> Option<Self>

Consumes self and mutates self via the given mutate function.

If the outcome of mutation is within bounds, Some(Self) is returned. Else, None is returned.

This is essentially a consuming shorthand Self::into_inner -> ... -> Self::try_from.

pub fn clear(&mut self)

Clears the map, removing all elements.

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

Return a mutable reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

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

Exactly the same semantics as BTreeMap::insert, but returns an Err (and is a noop) if the new length of the map exceeds S.

In the Err case, returns the inserted pair so it can be further used without cloning.

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

Remove a key from the map, returning the value at the key if the key was previously in the map.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

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

Remove a key from the map, returning the value at the key if the key was previously in the map.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

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

Gets a mutable iterator over the entries of the map, sorted by key.

See BTreeMap::iter_mut for more information.

pub fn map<T, F>(self, f: F) -> BoundedBTreeMap<K, T, S>where
    F: FnMut((&K, V)) -> T,

Consume the map, applying f to each of it’s values and returning a new map.

pub fn try_map<T, E, F>(self, f: F) -> Result<BoundedBTreeMap<K, T, S>, E>where
    F: FnMut((&K, V)) -> Result<T, E>,

Consume the map, applying f to each of it’s values as long as it returns successfully. If an Err(E) is ever encountered, the mapping is short circuited and the error is returned; otherwise, a new map is returned in the contained Ok value.

Methods from Deref<Target = BTreeMap<K, V>>

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

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get(&1), Some(&"a"));
assert_eq!(map.get(&2), None);

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

Returns the key-value pair corresponding to the supplied key.

The supplied key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.get_key_value(&1), Some((&1, &"a")));
assert_eq!(map.get_key_value(&2), None);

pub fn first_key_value(&self) -> Option<(&K, &V)>where
    K: Ord,

Returns the first key-value pair in the map. The key in this pair is the minimum key in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
assert_eq!(map.first_key_value(), None);
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.first_key_value(), Some((&1, &"b")));

pub fn last_key_value(&self) -> Option<(&K, &V)>where
    K: Ord,

Returns the last key-value pair in the map. The key in this pair is the maximum key in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "b");
map.insert(2, "a");
assert_eq!(map.last_key_value(), Some((&2, &"a")));

pub fn contains_key<Q>(&self, key: &Q) -> boolwhere
    K: Borrow<Q> + Ord,
    Q: Ord + ?Sized,

Returns true if the map contains a value for the specified key.

The key may be any borrowed form of the map’s key type, but the ordering on the borrowed form must match the ordering on the key type.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(1, "a");
assert_eq!(map.contains_key(&1), true);
assert_eq!(map.contains_key(&2), false);

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

Constructs a double-ended iterator over a sub-range of elements in the map. The simplest way is to use the range syntax min..max, thus range(min..max) will yield elements from min (inclusive) to max (exclusive). The range may also be entered as (Bound<T>, Bound<T>), so for example range((Excluded(4), Included(10))) will yield a left-exclusive, right-inclusive range from 4 to 10.

Panics

Panics if range start > end. Panics if range start == end and both bounds are Excluded.

Examples

Basic usage:

use std::collections::BTreeMap;
use std::ops::Bound::Included;

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");
for (&key, &value) in map.range((Included(&4), Included(&8))) {
    println!("{key}: {value}");
}
assert_eq!(Some((&5, &"b")), map.range(4..).next());

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

Gets an iterator over the entries of the map, sorted by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "c");
map.insert(2, "b");
map.insert(1, "a");

for (key, value) in map.iter() {
    println!("{key}: {value}");
}

let (first_key, first_value) = map.iter().next().unwrap();
assert_eq!((*first_key, *first_value), (1, "a"));

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

Gets an iterator over the keys of the map, in sorted order.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(2, "b");
a.insert(1, "a");

let keys: Vec<_> = a.keys().cloned().collect();
assert_eq!(keys, [1, 2]);

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

Gets an iterator over the values of the map, in order by key.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
a.insert(1, "hello");
a.insert(2, "goodbye");

let values: Vec<&str> = a.values().cloned().collect();
assert_eq!(values, ["hello", "goodbye"]);

pub fn len(&self) -> usize

Returns the number of elements in the map.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

Basic usage:

use std::collections::BTreeMap;

let mut a = BTreeMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

Trait Implementations

impl<K, V, S> AsRef<BTreeMap<K, V, Global>> for BoundedBTreeMap<K, V, S>where
    K: Ord,

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

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

impl<K, V, S> Clone for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V, S> Debug for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Debug,
    S: Get<u32>,

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

Formats the value using the given formatter.

impl<K, V, S> Decode for BoundedBTreeMap<K, V, S>where
    K: Decode + Ord,
    V: Decode,
    S: Get<u32>,

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn skip<I: Input>(input: &mut I) -> Result<(), Error>

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<K, V, S> DecodeLength for BoundedBTreeMap<K, V, S>

fn len(self_encoded: &[u8]) -> Result<usize, Error>

Return the number of elements in self_encoded.

impl<K, V, S> Default for BoundedBTreeMap<K, V, S>where
    K: Ord,
    S: Get<u32>,

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, S> Deref for BoundedBTreeMap<K, V, S>where
    K: Ord,

type Target = BTreeMap<K, V, Global>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<K, V, S> Encode for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Encode,
    PhantomData<S>: Encode,

fn encode_to<__CodecOutputEdqy: Output + ?Sized>(
    &self,
    __codec_dest_edqy: &mut __CodecOutputEdqy
)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8, Global>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> Rwhere
    F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<K, V, S> From<BoundedBTreeMap<K, V, S>> for BTreeMap<K, V>where
    K: Ord,

fn from(map: BoundedBTreeMap<K, V, S>) -> Self

Converts to this type from the input type.

impl<'a, K, V, S> IntoIterator for &'a BoundedBTreeMap<K, V, S>

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, S> IntoIterator for &'a mut BoundedBTreeMap<K, V, S>

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, S> IntoIterator for BoundedBTreeMap<K, V, S>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V, S> MaxEncodedLen for BoundedBTreeMap<K, V, S>where
    K: MaxEncodedLen,
    V: MaxEncodedLen,
    S: Get<u32>,

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<K, V, S> Ord for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Ord,
    S: Get<u32>,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<K, V, S> PartialEq<BTreeMap<K, V, Global>> for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: PartialEq,

fn eq(&self, other: &BTreeMap<K, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V, S1, S2> PartialEq<BoundedBTreeMap<K, V, S1>> for BoundedBTreeMap<K, V, S2>where
    BTreeMap<K, V>: PartialEq,
    S1: Get<u32>,
    S2: Get<u32>,

fn eq(&self, other: &BoundedBTreeMap<K, V, S1>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V, S> PartialOrd<BoundedBTreeMap<K, V, S>> for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: PartialOrd,
    S: Get<u32>,

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<I, K, V, Bound> TryCollect<BoundedBTreeMap<K, V, Bound>> for Iwhere
    K: Ord,
    I: ExactSizeIterator + Iterator<Item = (K, V)>,
    Bound: Get<u32>,

type Error = &'static str

The error type that gets returned when a collection can’t be made from self.

fn try_collect(self) -> Result<BoundedBTreeMap<K, V, Bound>, Self::Error>

Consume self and try to collect the results into C.

impl<K, V, S> TryFrom<BTreeMap<K, V, Global>> for BoundedBTreeMap<K, V, S>where
    K: Ord,
    S: Get<u32>,

type Error = ()

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<K, V, S> TypeInfo for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: TypeInfo + 'static,
    PhantomData<S>: TypeInfo + 'static,
    K: TypeInfo + 'static,
    V: TypeInfo + 'static,
    S: 'static,

type Identity = BoundedBTreeMap<K, V, S>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<K, V, S> EncodeLike<BTreeMap<K, V, Global>> for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Encode,

impl<K, V, S> EncodeLike<BoundedBTreeMap<K, V, S>> for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Encode,
    PhantomData<S>: Encode,

impl<K, V, S> Eq for BoundedBTreeMap<K, V, S>where
    BTreeMap<K, V>: Eq,
    S: Get<u32>,