Skip to content

feat: make TrieNode sized #1416

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
wants to merge 1 commit into
base: main
Choose a base branch
from
Draft

feat: make TrieNode sized #1416

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 33 additions & 33 deletions storage/src/tries/iter.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -20,35 +20,35 @@ pub struct IterDescending;
/// respectively.
#[derive(Debug)]
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct TrieEdgeIter<'a, N: ?Sized, V: ?Sized, D> {
pub struct TrieEdgeIter<'root, N, V: ?Sized, D> {
leading_path: PathBuf,
stack: Vec<Frame<'a, N, V>>,
stack: Vec<Frame<'root, N, V>>,
marker: std::marker::PhantomData<D>,
}

/// An iterator over the key-value pairs in a key-value trie.
#[derive(Debug)]
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct TrieValueIter<'a, N: ?Sized, V: ?Sized, D> {
edges: TrieEdgeIter<'a, N, V, D>,
pub struct TrieValueIter<'root, N, V: ?Sized, D> {
edges: TrieEdgeIter<'root, N, V, D>,
}

#[derive(Debug)]
struct Frame<'a, N: ?Sized, V: ?Sized> {
node: &'a N,
hash: Option<&'a HashType>,
struct Frame<'root, N, V: ?Sized> {
node: N,
hash: Option<&'root HashType>,
leading_path_len: usize,
children: Option<std::array::IntoIter<PathComponent, { PathComponent::LEN }>>,
marker: std::marker::PhantomData<V>,
}

impl<'a, N, V, D> TrieEdgeIter<'a, N, V, D>
impl<'root, N, V, D> TrieEdgeIter<'root, N, V, D>
where
N: TrieNode<V> + ?Sized,
V: AsRef<[u8]> + ?Sized,
N: TrieNode<'root, V>,
V: AsRef<[u8]> + ?Sized + 'root,
{
/// Creates a new iterator over the given key-value trie.
pub fn new(root: &'a N, root_hash: Option<&'a HashType>) -> Self {
pub fn new(root: N, root_hash: Option<&'root HashType>) -> Self {
let mut this = Self {
leading_path: PathBuf::new_const(),
stack: Vec::new(),
Expand All @@ -60,15 +60,15 @@ where

/// Transforms this iterator into an iterator over the key-value pairs in
/// the trie.
pub const fn node_values(self) -> TrieValueIter<'a, N, V, D> {
pub const fn node_values(self) -> TrieValueIter<'root, N, V, D> {
TrieValueIter { edges: self }
}

fn push_frame(
&mut self,
leading_component: Option<PathComponent>,
node: &'a N,
hash: Option<&'a HashType>,
node: N,
hash: Option<&'root HashType>,
) {
let frame = Frame {
node,
Expand Down Expand Up @@ -115,12 +115,12 @@ macro_rules! descend {
};
}

impl<'a, N, V> Iterator for TrieEdgeIter<'a, N, V, IterAscending>
impl<'root, N, V> Iterator for TrieEdgeIter<'root, N, V, IterAscending>
where
N: TrieNode<V> + ?Sized,
V: AsRef<[u8]> + ?Sized,
N: TrieNode<'root, V>,
V: AsRef<[u8]> + ?Sized + 'root,
{
type Item = (PathBuf, TrieEdgeState<'a, N>);
type Item = (PathBuf, TrieEdgeState<'root, N>);

fn next(&mut self) -> Option<Self::Item> {
while let Some(&mut Frame {
Expand Down Expand Up @@ -157,12 +157,12 @@ where
}
}

impl<'a, N, V> Iterator for TrieEdgeIter<'a, N, V, IterDescending>
impl<'root, N, V> Iterator for TrieEdgeIter<'root, N, V, IterDescending>
where
N: TrieNode<V> + ?Sized,
V: AsRef<[u8]> + ?Sized,
N: TrieNode<'root, V>,
V: AsRef<[u8]> + ?Sized + 'root,
{
type Item = (PathBuf, TrieEdgeState<'a, N>);
type Item = (PathBuf, TrieEdgeState<'root, N>);

fn next(&mut self) -> Option<Self::Item> {
while let Some(&mut Frame {
Expand Down Expand Up @@ -192,25 +192,25 @@ where
}
}

impl<'a, N, V> Iterator for TrieValueIter<'a, N, V, IterAscending>
impl<'root, N, V> Iterator for TrieValueIter<'root, N, V, IterAscending>
where
N: TrieNode<V> + ?Sized,
V: AsRef<[u8]> + ?Sized + 'a,
N: TrieNode<'root, V>,
V: AsRef<[u8]> + ?Sized + 'root,
{
type Item = (PathBuf, &'a V);
type Item = (PathBuf, &'root V);

fn next(&mut self) -> Option<Self::Item> {
self.edges
.find_map(|(path, node)| node.value().map(|v| (path, v)))
}
}

impl<'a, N, V> Iterator for TrieValueIter<'a, N, V, IterDescending>
impl<'root, N, V> Iterator for TrieValueIter<'root, N, V, IterDescending>
where
N: TrieNode<V> + ?Sized,
V: AsRef<[u8]> + ?Sized + 'a,
N: TrieNode<'root, V>,
V: AsRef<[u8]> + ?Sized + 'root,
{
type Item = (PathBuf, &'a V);
type Item = (PathBuf, &'root V);

fn next(&mut self) -> Option<Self::Item> {
self.edges
Expand All @@ -220,7 +220,7 @@ where

// auto-derived implementations would require N: Clone, V: Clone which is too much

impl<N: ?Sized, V: ?Sized, D> Clone for TrieEdgeIter<'_, N, V, D> {
impl<N: Copy, V: ?Sized, D> Clone for TrieEdgeIter<'_, N, V, D> {
fn clone(&self) -> Self {
Self {
leading_path: self.leading_path.clone(),
Expand All @@ -235,7 +235,7 @@ impl<N: ?Sized, V: ?Sized, D> Clone for TrieEdgeIter<'_, N, V, D> {
}
}

impl<N: ?Sized, V: ?Sized, D> Clone for TrieValueIter<'_, N, V, D> {
impl<N: Copy, V: ?Sized, D> Clone for TrieValueIter<'_, N, V, D> {
fn clone(&self) -> Self {
Self {
edges: self.edges.clone(),
Expand All @@ -247,7 +247,7 @@ impl<N: ?Sized, V: ?Sized, D> Clone for TrieValueIter<'_, N, V, D> {
}
}

impl<N: ?Sized, V: ?Sized> Clone for Frame<'_, N, V> {
impl<N: Copy, V: ?Sized> Clone for Frame<'_, N, V> {
fn clone(&self) -> Self {
Self {
node: self.node,
Expand Down
47 changes: 25 additions & 22 deletions storage/src/tries/kvp.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -279,67 +279,70 @@ impl<'a, T: AsRef<[u8]> + ?Sized> HashedKeyValueTrieRoot<'a, T> {
}
}

impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for KeyValueTrieRoot<'_, T> {
type PartialPath<'a>
= PackedPathRef<'a>
where
Self: 'a;
impl<'root, T> TrieNode<'root, T> for &'root KeyValueTrieRoot<'root, T>
where
T: AsRef<[u8]> + ?Sized + 'root,
{
type PartialPath = PackedPathRef<'root>;

fn partial_path(&self) -> Self::PartialPath<'_> {
fn partial_path(self) -> Self::PartialPath {
self.partial_path
}

fn value(&self) -> Option<&T> {
fn value(self) -> Option<&'root T> {
self.value
}

fn child_hash(&self, pc: PathComponent) -> Option<&HashType> {
fn child_hash(self, pc: PathComponent) -> Option<&'root HashType> {
let _ = pc;
None
}

fn child_node(&self, pc: PathComponent) -> Option<&Self> {
fn child_node(self, pc: PathComponent) -> Option<Self> {
self.children[pc].as_deref()
}

fn child_state(&self, pc: PathComponent) -> Option<super::TrieEdgeState<'_, Self>> {
fn child_state(self, pc: PathComponent) -> Option<super::TrieEdgeState<'root, Self>> {
self.children[pc]
.as_deref()
.map(|node| super::TrieEdgeState::UnhashedChild { node })
}
}

impl<T: AsRef<[u8]> + ?Sized> TrieNode<T> for HashedKeyValueTrieRoot<'_, T> {
type PartialPath<'a>
= PackedPathRef<'a>
where
Self: 'a;
impl<'root, T> TrieNode<'root, T> for &'root HashedKeyValueTrieRoot<'root, T>
where
T: AsRef<[u8]> + ?Sized + 'root,
{
type PartialPath = PackedPathRef<'root>;

fn partial_path(&self) -> Self::PartialPath<'_> {
fn partial_path(self) -> Self::PartialPath {
self.partial_path
}

fn value(&self) -> Option<&T> {
fn value(self) -> Option<&'root T> {
self.value
}

fn child_hash(&self, pc: PathComponent) -> Option<&HashType> {
fn child_hash(self, pc: PathComponent) -> Option<&'root HashType> {
self.children[pc].as_deref().map(|c| &c.computed)
}

fn child_node(&self, pc: PathComponent) -> Option<&Self> {
fn child_node(self, pc: PathComponent) -> Option<Self> {
self.children[pc].as_deref()
}

fn child_state(&self, pc: PathComponent) -> Option<super::TrieEdgeState<'_, Self>> {
fn child_state(self, pc: PathComponent) -> Option<super::TrieEdgeState<'root, Self>> {
self.children[pc]
.as_deref()
.map(|node| super::TrieEdgeState::from_node(node, Some(&node.computed)))
}
}

impl<T: AsRef<[u8]> + ?Sized> HashedTrieNode<T> for HashedKeyValueTrieRoot<'_, T> {
fn computed(&self) -> &HashType {
impl<'root, T> HashedTrieNode<'root, T> for &'root HashedKeyValueTrieRoot<'root, T>
where
T: AsRef<[u8]> + ?Sized + 'root,
{
fn computed(self) -> &'root HashType {
&self.computed
}
}
Expand Down
Loading