Struct SinglePrefixMap 

pub struct SinglePrefixMap<T>(pub Option<T>);

A mapping of the single prefix to a value. This essentially is a boolean value with a different interface.

Tuple Fields

0: Option<T>

Implementations

impl<T> SinglePrefixMap<T>

pub fn len(&self) -> usize

Return the length of the prefix map, i.e., 1 if there is a value stored for the single prefix, and 0 otheriwse.

pub fn is_empty(&self) -> bool

Return wether the prefix map is empty, i.e., wether there is a value stored for the single preifx.

Trait Implementations

impl<T: Clone> Clone for SinglePrefixMap<T>

fn clone(&self) -> SinglePrefixMap<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SinglePrefixMap<T>

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

Formats the value using the given formatter.

impl<T> Default for SinglePrefixMap<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for SinglePrefixMap<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> FromIterator<(SinglePrefix, T)> for SinglePrefixMap<T>

fn from_iter<I: IntoIterator<Item = (SinglePrefix, T)>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for SinglePrefixMap<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T> IntoIterator for &'a SinglePrefixMap<T>

type Item = (&'a SinglePrefix, &'a T)

The type of the elements being iterated over.

type IntoIter = Zip<Repeat<&'a SinglePrefix>, IntoIter<&'a T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for SinglePrefixMap<T>

type Item = (SinglePrefix, T)

The type of the elements being iterated over.

type IntoIter = Zip<Repeat<SinglePrefix>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for SinglePrefixMap<T>

fn eq(&self, other: &SinglePrefixMap<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> PrefixMap<T> for SinglePrefixMap<T>

where T: Clone + PartialEq + Debug + Serialize + for<'de> Deserialize<'de> + Send + Sync + 'static,

type P = SinglePrefix

The type of prefix

type Iter<'a> = Zip<Repeat<&'a SinglePrefix>, IntoIter<&'a T>> where Self: 'a, T: 'a

Type of Union

type Keys<'a> = RepeatN<&'a SinglePrefix> where T: 'a

The type of iterator over the keys (prefixes)

type Values<'a> = Iter<'a, T> where T: 'a

The type of iterator over immutable values.

type ValuesMut<'a> = IterMut<'a, T> where T: 'a

The type of iterator over mutable values.

type Children<'a> = <SinglePrefixMap<T> as PrefixMap<T>>::Iter<'a> where Self: 'a, T: 'a

The type of iterator over children of a given prefix.

fn iter(&self) -> Self::Iter<'_>

Iterate over references of all elements in the map.

fn keys(&self) -> Self::Keys<'_>

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

fn values(&self) -> Self::Values<'_>

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

fn values_mut(&mut self) -> Self::ValuesMut<'_>

An iterator visiting all values mutablyin arbitrary order. The iterator element type is &'a T.

fn children(&self, _prefix: &Self::P) -> Self::Children<'_>

An iterator visiting all keys and values of children of a given prefix. All children are contained within that given prefix, or are equal.

fn clear(&mut self)

Clears the map, removing all key-value pairs. Keeps the allocated memory for reuse.

fn get(&self, _: &Self::P) -> Option<&T>

Returns a reference to the value corresponding to the key.

fn get_mut(&mut self, _: &Self::P) -> Option<&mut T>

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

fn get_mut_or_default(&mut self, _: Self::P) -> &mut T

where T: Default,

Returns a mutable reference to the value corresponding to the key. If the key does not exist yet, create it using a default value.

fn get_lpm(&self, k: &Self::P) -> Option<(&Self::P, &T)>

Returns a reference to the value corresponding to the longest prefix match of the key.

fn contains_key(&self, _: &Self::P) -> bool

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

fn insert(&mut self, _: Self::P, v: T) -> Option<T>

Insert a key-balue pair into the map.

fn remove(&mut self, _: &Self::P) -> Option<T>

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

impl<T> Serialize for SinglePrefixMap<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy> Copy for SinglePrefixMap<T>

impl<T: Eq> Eq for SinglePrefixMap<T>

impl<T> StructuralPartialEq for SinglePrefixMap<T>