Struct ax_banyan::Forest

pub struct Forest<TT: TreeTypes, R>(/* private fields */);

Implementations

impl<T, R> Forest<T, R>

where T: TreeTypes, R: ReadOnlyStore<T::Link>,

basic random access append only tree

pub fn store(&self) -> &R

impl<T: TreeTypes, R: ReadOnlyStore<T::Link>> Forest<T, R>

pub fn stream_trees<Q, S, V>( &self, query: Q, trees: S ) -> impl Stream<Item = Result<(u64, T::Key, V)>> + Send

where Q: Query<T> + Clone, S: Stream<Item = Tree<T, V>> + Send + 'static, V: BanyanValue,

Given a sequence of roots, will stream matching events in ascending order indefinitely.

This is implemented by calling stream_trees_chunked and just flattening the chunks.

pub fn stream_trees_chunked<S, Q, V, E, F>( &self, query: Q, trees: S, range: RangeInclusive<u64>, mk_extra: &'static F ) -> impl Stream<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + Send + 'static

where S: Stream<Item = Tree<T, V>> + Send + 'static, Q: Query<T> + Clone, V: BanyanValue, E: Send + 'static, F: Send + Sync + 'static + Fn(&NodeInfo<T, R>) -> E,

Given a sequence of roots, will stream chunks in ascending order until it arrives at range.end().

• query: the query
• roots: the stream of roots. It is assumed that trees later in this stream will be bigger
• range: the range which to stream. It is up to the caller to ensure that we have events for this range.
• mk_extra: a fn that allows to compute extra info from indices. this can be useful to get progress info even if the query does not match any events

pub fn stream_trees_chunked_threaded<S, Q, V, E, F>( &self, query: Q, trees: S, range: RangeInclusive<u64>, mk_extra: &'static F, thread_pool: ThreadPool ) -> impl Stream<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + Send + 'static

where S: Stream<Item = Tree<T, V>> + Send + 'static, Q: Query<T> + Clone, V: BanyanValue, E: Send + 'static, F: Send + Sync + 'static + Fn(&NodeInfo<T, R>) -> E,

Given a sequence of roots, will stream chunks in ascending order indefinitely.

Note that this method has no way to know when the query is done. So ending this stream, if desired, will have to be done by the caller using e.g. take_while(...).

• query: the query
• roots: the stream of roots. It is assumed that trees later in this stream will be bigger
• range: the range which to stream. It is up to the caller to ensure that we have events for this range.
• mk_extra: a fn that allows to compute extra info from indices. this can be useful to get progress info even if the query does not match any events

pub fn stream_trees_chunked_reverse<S, Q, V, E, F>( &self, query: Q, trees: S, range: RangeInclusive<u64>, mk_extra: &'static F ) -> impl Stream<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + Send + 'static

where S: Stream<Item = Tree<T, V>> + Send + 'static, Q: Query<T> + Clone, V: BanyanValue, E: Send + 'static, F: Send + Sync + 'static + Fn(&NodeInfo<T, R>) -> E,

Given a sequence of roots, will stream chunks in reverse order until it arrives at range.start().

Values within chunks are in ascending offset order, so if you flatten them you have to reverse them first.

• query: the query
• trees: the stream of roots. It is assumed that trees later in this stream will be bigger
• range: the range which to stream. It is up to the caller to ensure that we have events for this range.
• mk_extra: a fn that allows to compute extra info from indices. this can be useful to get progress info even if the query does not match any events

impl<TT: TreeTypes, R: Clone> Forest<TT, R>

pub fn new(store: R, branch_cache: BranchCache<TT>) -> Self

pub fn transaction<W: BlockWriter<TT::Link>>( &self, f: impl FnOnce(R) -> (R, W) ) -> Transaction<TT, R, W>

impl<T: TreeTypes, R: ReadOnlyStore<T::Link>> Forest<T, R>

pub fn load_stream_builder<V>( &self, secrets: Secrets, config: Config, link: T::Link ) -> Result<StreamBuilder<T, V>>

pub fn load_tree<V>( &self, secrets: Secrets, link: T::Link ) -> Result<Tree<T, V>>

pub fn dump<V>(&self, tree: &Tree<T, V>) -> Result<()>

dumps the tree structure

pub fn dump_graph<S, V>( &self, tree: &Tree<T, V>, f: impl Fn((usize, &NodeInfo<T, R>)) -> S + Clone ) -> Result<(Vec<(usize, usize)>, BTreeMap<usize, S>)>

dumps the tree structure

pub fn roots<V>(&self, tree: &StreamBuilder<T, V>) -> Result<Vec<Index<T>>>

sealed roots of the tree

pub fn left_roots<V>(&self, tree: &Tree<T, V>) -> Result<Vec<Tree<T, V>>>

leftmost branches of the tree as separate trees

pub fn check_invariants<V>( &self, tree: &StreamBuilder<T, V> ) -> Result<Vec<String>>

pub fn is_packed<V>(&self, tree: &Tree<T, V>) -> Result<bool>

pub fn assert_invariants<V>(&self, tree: &StreamBuilder<T, V>) -> Result<()>

pub fn stream_filtered<V: BanyanValue>( &self, tree: &Tree<T, V>, query: impl Query<T> + Clone + 'static ) -> impl Stream<Item = Result<(u64, T::Key, V)>> + 'static

pub fn iter_index<V>( &self, tree: &Tree<T, V>, query: impl Query<T> + Clone + 'static ) -> impl Iterator<Item = Result<Index<T>>> + 'static

Returns an iterator yielding all indexes that have values matching the provided query.

pub fn iter_index_reverse<V>( &self, tree: &Tree<T, V>, query: impl Query<T> + Clone + 'static ) -> impl Iterator<Item = Result<Index<T>>> + 'static

Returns an iterator yielding all indexes that have values matching the provided query in reverse order.

pub fn iter_filtered<V: BanyanValue>( &self, tree: &Tree<T, V>, query: impl Query<T> + Clone + 'static ) -> impl Iterator<Item = Result<(u64, T::Key, V)>> + 'static

pub fn iter_filtered_reverse<V: BanyanValue>( &self, tree: &Tree<T, V>, query: impl Query<T> + Clone + 'static ) -> impl Iterator<Item = Result<(u64, T::Key, V)>> + 'static

pub fn iter_from<V: BanyanValue>( &self, tree: &Tree<T, V> ) -> impl Iterator<Item = Result<(u64, T::Key, V)>> + 'static

pub fn iter_filtered_chunked<Q, V, E, F>( &self, tree: &Tree<T, V>, query: Q, mk_extra: &'static F ) -> impl Iterator<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + 'static

where Q: Query<T>, V: BanyanValue, E: Send + 'static, F: Fn(&NodeInfo<T, R>) -> E + Send + Sync + 'static,

pub fn iter_filtered_chunked_reverse<Q, V, E, F>( &self, tree: &Tree<T, V>, query: Q, mk_extra: &'static F ) -> impl Iterator<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + 'static

where Q: Query<T>, V: BanyanValue, E: Send + 'static, F: Fn(&NodeInfo<T, R>) -> E + Send + Sync + 'static,

pub fn stream_filtered_chunked<Q, V, E, F>( &self, tree: &Tree<T, V>, query: Q, mk_extra: &'static F ) -> impl Stream<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + 'static

where Q: Query<T>, V: BanyanValue, E: Send + 'static, F: Fn(&NodeInfo<T, R>) -> E + Send + Sync + 'static,

pub fn stream_filtered_chunked_reverse<Q, V, E, F>( &self, tree: &Tree<T, V>, query: Q, mk_extra: &'static F ) -> impl Stream<Item = Result<FilteredChunk<(u64, T::Key, V), E>>> + 'static

where Q: Query<T>, V: BanyanValue, E: Send + 'static, F: Fn(&NodeInfo<T, R>) -> E + Send + Sync + 'static,

pub fn get<V: BanyanValue>( &self, tree: &Tree<T, V>, offset: u64 ) -> Result<Option<(T::Key, V)>>

element at index

returns Ok(None) when offset is larger than count, or when hitting a purged part of the tree. Returns an error when part of the tree should be there, but could not be read.

pub fn collect<V: BanyanValue>( &self, tree: &Tree<T, V> ) -> Result<Vec<Option<(T::Key, V)>>>

Collects all elements from a stream. Might produce an OOM for large streams.

pub fn collect_from<V: BanyanValue>( &self, tree: &Tree<T, V>, offset: u64 ) -> Result<Vec<Option<(T::Key, V)>>>

Collects all elements from the given offset. Might produce an OOM for large streams.

Trait Implementations

impl<TT: TreeTypes, R> Clone for Forest<TT, R>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<TT: Debug + TreeTypes, R: Debug> Debug for Forest<TT, R>

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

Formats the value using the given formatter.

impl<T: TreeTypes, R> Deref for Forest<T, R>

type Target = ForestInner<T, R>

The resulting type after dereferencing.

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

Dereferences the value.