Enum Child 

pub enum Child<Node, T> {
    Path(Node),
    Leaf {
        prefix: IpNet,
        value: T,
    },
    Fringe(T),
}

Entries in a node’s children array.

Variants

Path(Node)

Child containing another node.

Leaf

Path-compressed single descendant.

If a prefix would be inserted that spans multiple octet strides and there is no child for the starting octet, it is instead stored as a single leaf. This is the primary mechanism for path compression.

Fields

prefix: IpNet

The complete prefix for this route.

value: T

Value stored for this route.

Fringe(T)

Fringe nodes store single /8s for this depth in the trie.

This can be seen as an optimization over Leaf for cases where prefix lies on this depth’s /8 boundary.

Implementations

impl<Node, T> Child<&Node, &T>

pub fn cloned(self) -> Child<Node, T>

where Node: Clone, T: Clone,

When this holds refs, clone the values in the refs to return a child-of-owned.

impl<Node, T> Child<Node, T>

pub const fn as_ref(&self) -> Child<&Node, &T>

Convert this ref-to-child into a child-of-ref.

pub const fn as_mut(&mut self) -> Child<&mut Node, &mut T>

Convert this ref-mut-to-child into a child-of-ref-mut.

pub fn map_node<Nu>(self, f: impl FnOnce(Node) -> Nu) -> Child<Nu, T>

If this is a path node, apply f to the contained value.

pub fn into_value(self) -> Option<T>

Get the value directly contained in this node, if it’s a leaf or fringe. Return None iff this is a Path.

pub fn as_node_ref<C, Inner>(&self) -> Child<&Inner, &T>

where C: Storage<Container<Inner> = Node> + ?Sized,

When Node is a Storage, this is as_ref except that it also unwraps the node container type.

pub fn as_node_mut<C, Inner>(&mut self) -> Child<&mut Inner, &mut T>

where C: Storage<Container<Inner> = Node> + ?Sized,

When Node is a Storage, this is as_mut except that it also unwraps the node container type.

pub fn into_node(self) -> Option<Node>

Return the child node if this is a Path.

Trait Implementations

impl<Node: Clone, T: Clone> Clone for Child<Node, T>

fn clone(&self) -> Child<Node, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Node: Copy, T: Copy> Copy for Child<Node, T>

impl<Node, T> Debug for Child<Node, T>

where Node: Debug, T: Debug,

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

Formats the value using the given formatter.

impl<Node: Eq, T: Eq> Eq for Child<Node, T>

impl<Node: Hash, T: Hash> Hash for Child<Node, 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<Node: PartialEq, T: PartialEq> PartialEq for Child<Node, T>

fn eq(&self, other: &Child<Node, 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<Node, T> StructuralPartialEq for Child<Node, T>