Struct SubtreePath

pub struct SubtreePath<'b, B> { /* private fields */ }

Path to a GroveDB’s subtree with no owned data and cheap to clone.

Implementations

impl SubtreePath<'static, [u8; 0]>

pub const fn empty() -> Self

Get empty subtree path (meaning it’ll point to the root tree).

impl<B> SubtreePath<'_, B>

pub fn len(&self) -> usize

Returns the length of the subtree path.

pub fn is_empty(&self) -> bool

Returns whether the path is empty (the root tree).

impl<'b, B: AsRef<[u8]>> SubtreePath<'b, B>

pub fn derive_owned(&self) -> SubtreePathBuilder<'b, B>

Get a derived path that will reuse this Self as it’s base path and capable of owning data.

pub fn derive_owned_with_child<'s, S>( &'b self, segment: S, ) -> SubtreePathBuilder<'b, B>

where S: Into<CowLike<'s>>, 's: 'b,

Get a derived path with a child path segment added.

pub fn derive_parent(&self) -> Option<(SubtreePath<'b, B>, &'b [u8])>

Get a derived subtree path for a parent with care for base path slice case. The main difference from SubtreePath::derive_parent is that lifetime of returned Self if not limited to the scope where this function was called so it’s possible to follow to ancestor paths without keeping previous result as it still will link to 'b (latest SubtreePath or initial slice of data).

pub fn into_reverse_iter(self) -> SubtreePathIter<'b, B>

Get a reverse path segments iterator.

pub fn is_root(&self) -> bool

Retuns true if the subtree path is empty, so it points to the root tree.

pub fn to_vec(&self) -> Vec<Vec<u8>>

Collect path as a vector of vectors, but this actually negates all the benefits of this library.

Trait Implementations

impl<B> Clone for SubtreePath<'_, B>

For the same reason as for Hash implementation, derived impl requires generics to carry trait bounds that actually don’t needed.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'b, B: Debug> Debug for SubtreePath<'b, B>

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

Formats the value using the given formatter.

impl<'b, B> From<&'b [B]> for SubtreePath<'b, B>

fn from(value: &'b [B]) -> Self

Converts to this type from the input type.

impl<'b, B, const N: usize> From<&'b [B; N]> for SubtreePath<'b, B>

fn from(value: &'b [B; N]) -> Self

Converts to this type from the input type.

impl<'s, 'b, B> From<&'s SubtreePath<'b, B>> for SubtreePathBuilder<'b, B>

fn from(value: &'s SubtreePath<'b, B>) -> Self

Converts to this type from the input type.

impl<'s, 'b, B> From<&'s SubtreePathBuilder<'b, B>> for SubtreePath<'s, B>

Create a link to existing SubtreePath that cannot outlive it, because it possibly owns some of the path segments.

fn from(value: &'s SubtreePathBuilder<'b, B>) -> Self

Converts to this type from the input type.

impl<'b, B: AsRef<[u8]>> Hash for SubtreePath<'b, B>

Hash order is the same as iteration order: from most deep path segment up to root.

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<'bl, 'br, BL, BR> PartialEq<SubtreePath<'br, BR>> for SubtreePath<'bl, BL>

where BL: AsRef<[u8]>, BR: AsRef<[u8]>,

fn eq(&self, other: &SubtreePath<'br, BR>) -> 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<'bl, 'br, BL, BR> PartialEq<SubtreePath<'br, BR>> for SubtreePathBuilder<'bl, BL>

where BL: AsRef<[u8]>, BR: AsRef<[u8]>,

fn eq(&self, other: &SubtreePath<'br, BR>) -> 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<'bl, 'br, BL, BR> PartialEq<SubtreePathBuilder<'br, BR>> for SubtreePath<'bl, BL>

where BL: AsRef<[u8]>, BR: AsRef<[u8]>,

fn eq(&self, other: &SubtreePathBuilder<'br, BR>) -> 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<'b, B: AsRef<[u8]>> Eq for SubtreePath<'b, B>