Struct TrieHardSized 

pub struct TrieHardSized<'a, T, I> { /* private fields */ }

Inner representation of a trie-hard trie that is generic to a specific size of integer.

Implementations

impl<'a, T> TrieHardSized<'a, T, u8>

where T: Copy,

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Option<T>

Get the value stored for the given key. Any key type can be used here as long as the type implements AsRef<[u8]>. The byte slice referenced will serve as the actual key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get("dad".to_owned()).is_some());
assert!(sized_trie.get(b"do").is_some());
assert!(sized_trie.get(b"don't".to_vec()).is_none());

pub fn get_from_bytes(&self, key: &[u8]) -> Option<T>

Get the value stored for the given byte-slice key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get_from_bytes(b"dad").is_some());
assert!(sized_trie.get_from_bytes(b"do").is_some());
assert!(sized_trie.get_from_bytes(b"don't").is_none());

pub fn iter(&self) -> TrieIterSized<'_, 'a, T, u8>

Create an iterator over the entire trie. Emitted items will be ordered by their keys

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.iter().map(|(_, v)| v).collect::<Vec<_>>(),
    ["and", "ant", "dad", "do", "dot"]
);

pub fn prefix_search<K: AsRef<[u8]>>( &self, prefix: K, ) -> TrieIterSized<'_, 'a, T, u8>

Create an iterator over the portion of the trie starting with the given prefix

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.prefix_search("d").map(|(_, v)| v).collect::<Vec<_>>(),
    ["dad", "do", "dot"]
);

impl<'a, T> TrieHardSized<'a, T, u16>

where T: Copy,

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Option<T>

Get the value stored for the given key. Any key type can be used here as long as the type implements AsRef<[u8]>. The byte slice referenced will serve as the actual key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get("dad".to_owned()).is_some());
assert!(sized_trie.get(b"do").is_some());
assert!(sized_trie.get(b"don't".to_vec()).is_none());

pub fn get_from_bytes(&self, key: &[u8]) -> Option<T>

Get the value stored for the given byte-slice key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get_from_bytes(b"dad").is_some());
assert!(sized_trie.get_from_bytes(b"do").is_some());
assert!(sized_trie.get_from_bytes(b"don't").is_none());

pub fn iter(&self) -> TrieIterSized<'_, 'a, T, u16>

Create an iterator over the entire trie. Emitted items will be ordered by their keys

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.iter().map(|(_, v)| v).collect::<Vec<_>>(),
    ["and", "ant", "dad", "do", "dot"]
);

pub fn prefix_search<K: AsRef<[u8]>>( &self, prefix: K, ) -> TrieIterSized<'_, 'a, T, u16>

Create an iterator over the portion of the trie starting with the given prefix

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.prefix_search("d").map(|(_, v)| v).collect::<Vec<_>>(),
    ["dad", "do", "dot"]
);

impl<'a, T> TrieHardSized<'a, T, u32>

where T: Copy,

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Option<T>

Get the value stored for the given key. Any key type can be used here as long as the type implements AsRef<[u8]>. The byte slice referenced will serve as the actual key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get("dad".to_owned()).is_some());
assert!(sized_trie.get(b"do").is_some());
assert!(sized_trie.get(b"don't".to_vec()).is_none());

pub fn get_from_bytes(&self, key: &[u8]) -> Option<T>

Get the value stored for the given byte-slice key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get_from_bytes(b"dad").is_some());
assert!(sized_trie.get_from_bytes(b"do").is_some());
assert!(sized_trie.get_from_bytes(b"don't").is_none());

pub fn iter(&self) -> TrieIterSized<'_, 'a, T, u32>

Create an iterator over the entire trie. Emitted items will be ordered by their keys

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.iter().map(|(_, v)| v).collect::<Vec<_>>(),
    ["and", "ant", "dad", "do", "dot"]
);

pub fn prefix_search<K: AsRef<[u8]>>( &self, prefix: K, ) -> TrieIterSized<'_, 'a, T, u32>

Create an iterator over the portion of the trie starting with the given prefix

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.prefix_search("d").map(|(_, v)| v).collect::<Vec<_>>(),
    ["dad", "do", "dot"]
);

impl<'a, T> TrieHardSized<'a, T, u64>

where T: Copy,

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Option<T>

Get the value stored for the given key. Any key type can be used here as long as the type implements AsRef<[u8]>. The byte slice referenced will serve as the actual key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get("dad".to_owned()).is_some());
assert!(sized_trie.get(b"do").is_some());
assert!(sized_trie.get(b"don't".to_vec()).is_none());

pub fn get_from_bytes(&self, key: &[u8]) -> Option<T>

Get the value stored for the given byte-slice key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get_from_bytes(b"dad").is_some());
assert!(sized_trie.get_from_bytes(b"do").is_some());
assert!(sized_trie.get_from_bytes(b"don't").is_none());

pub fn iter(&self) -> TrieIterSized<'_, 'a, T, u64>

Create an iterator over the entire trie. Emitted items will be ordered by their keys

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.iter().map(|(_, v)| v).collect::<Vec<_>>(),
    ["and", "ant", "dad", "do", "dot"]
);

pub fn prefix_search<K: AsRef<[u8]>>( &self, prefix: K, ) -> TrieIterSized<'_, 'a, T, u64>

Create an iterator over the portion of the trie starting with the given prefix

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.prefix_search("d").map(|(_, v)| v).collect::<Vec<_>>(),
    ["dad", "do", "dot"]
);

impl<'a, T> TrieHardSized<'a, T, u128>

where T: Copy,

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Option<T>

Get the value stored for the given key. Any key type can be used here as long as the type implements AsRef<[u8]>. The byte slice referenced will serve as the actual key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get("dad".to_owned()).is_some());
assert!(sized_trie.get(b"do").is_some());
assert!(sized_trie.get(b"don't".to_vec()).is_none());

pub fn get_from_bytes(&self, key: &[u8]) -> Option<T>

Get the value stored for the given byte-slice key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get_from_bytes(b"dad").is_some());
assert!(sized_trie.get_from_bytes(b"do").is_some());
assert!(sized_trie.get_from_bytes(b"don't").is_none());

pub fn iter(&self) -> TrieIterSized<'_, 'a, T, u128>

Create an iterator over the entire trie. Emitted items will be ordered by their keys

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.iter().map(|(_, v)| v).collect::<Vec<_>>(),
    ["and", "ant", "dad", "do", "dot"]
);

pub fn prefix_search<K: AsRef<[u8]>>( &self, prefix: K, ) -> TrieIterSized<'_, 'a, T, u128>

Create an iterator over the portion of the trie starting with the given prefix

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.prefix_search("d").map(|(_, v)| v).collect::<Vec<_>>(),
    ["dad", "do", "dot"]
);

impl<'a, T> TrieHardSized<'a, T, U256>

where T: Copy,

pub fn get<K: AsRef<[u8]>>(&self, key: K) -> Option<T>

Get the value stored for the given key. Any key type can be used here as long as the type implements AsRef<[u8]>. The byte slice referenced will serve as the actual key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get("dad".to_owned()).is_some());
assert!(sized_trie.get(b"do").is_some());
assert!(sized_trie.get(b"don't".to_vec()).is_none());

pub fn get_from_bytes(&self, key: &[u8]) -> Option<T>

Get the value stored for the given byte-slice key.

let trie = ["and", "ant", "dad", "do", "dot"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert!(sized_trie.get_from_bytes(b"dad").is_some());
assert!(sized_trie.get_from_bytes(b"do").is_some());
assert!(sized_trie.get_from_bytes(b"don't").is_none());

pub fn iter(&self) -> TrieIterSized<'_, 'a, T, U256>

Create an iterator over the entire trie. Emitted items will be ordered by their keys

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.iter().map(|(_, v)| v).collect::<Vec<_>>(),
    ["and", "ant", "dad", "do", "dot"]
);

pub fn prefix_search<K: AsRef<[u8]>>( &self, prefix: K, ) -> TrieIterSized<'_, 'a, T, U256>

Create an iterator over the portion of the trie starting with the given prefix

let trie = ["dad", "ant", "and", "dot", "do"]
    .into_iter()
    .collect::<TrieHard<'_, _>>();

let TrieHard::U8(sized_trie) = trie else {
    unreachable!()
};

assert_eq!(
    sized_trie.prefix_search("d").map(|(_, v)| v).collect::<Vec<_>>(),
    ["dad", "do", "dot"]
);

Trait Implementations

impl<'a, T: Clone, I: Clone> Clone for TrieHardSized<'a, T, I>

fn clone(&self) -> TrieHardSized<'a, T, I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug, I: Debug> Debug for TrieHardSized<'a, T, I>

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

Formats the value using the given formatter.

impl<'a, T, I> Default for TrieHardSized<'a, T, I>

where I: Default + Copy,

fn default() -> Self

Returns the “default value” for a type.