Struct StorageKey 

pub struct StorageKey(/* private fields */);

A hierarchical key for storage operations in the samod-core system.

StorageKey represents a path-like key structure that supports efficient prefix-based operations. Keys are composed of string components that form a hierarchy, similar to filesystem paths or namespaces.

Usage

Storage keys are used throughout samod-core for organizing data in the key-value store. They support operations like prefix matching for range queries and hierarchical organization of related data.

Examples

use samod_core::StorageKey;

// Create keys from string vectors
let key1 = StorageKey::from_parts(vec!["users", "123", "profile"]).unwrap();
let key2 = StorageKey::from_parts(vec!["users", "123", "settings"]).unwrap();
let prefix = StorageKey::from_parts(vec!["users", "123"]).unwrap();

// Check prefix relationships
assert!(prefix.is_prefix_of(&key1));
assert!(prefix.is_prefix_of(&key2));

Implementations

impl StorageKey

pub fn storage_id_path() -> StorageKey

pub fn incremental_prefix(doc_id: &DocumentId) -> StorageKey

pub fn incremental_path( doc_id: &DocumentId, change_hash: ChangeHash, ) -> StorageKey

pub fn snapshot_prefix(doc_id: &DocumentId) -> StorageKey

pub fn snapshot_path( doc_id: &DocumentId, compaction_hash: &CompactionHash, ) -> StorageKey

pub fn from_parts<I: IntoIterator<Item = S>, S: AsRef<str>>( parts: I, ) -> Result<Self, InvalidStorageKey>

Creates a storage key from a slice of string parts.

Arguments

• parts - The parts that make up the key path

Example

use samod_core::StorageKey;

let key = StorageKey::from_parts(&["users", "123", "profile"]).unwrap();

Errors

Returns an error if any part is empty or contains a slash.

pub fn is_prefix_of(&self, other: &StorageKey) -> bool

Checks if this key is a prefix of another key.

Arguments

• other - The key to check against

pub fn onelevel_deeper(&self, prefix: &StorageKey) -> Option<StorageKey>

Checks if this key is one level deeper then the given prefix

Examples

let key = StorageKey::from_parts(vec!["a", "b", "c"]).unwrap();
let prefix = StorageKey::from_parts(vec!["a", "b"]).unwrap();
assert_eq!(key.onelevel_deeper(&prefix), Some(StorageKey::from_parts(vec!["a", "b", "c"]).unwrap()));

let prefix2 = StorageKey::from_parts(vec!["a"]).unwrap();
assert_eq!(key.onelevel_deeper(&prefix2), Some(StorageKey::from_parts(vec!["a", "b"]).unwrap()));

let prefix3 = StorageKey::from_parts(vec!["a", "b", "c", "d"]).unwrap();
assert_eq!(key.onelevel_deeper(&prefix3), None);

pub fn with_suffix(&self, suffix: StorageKey) -> StorageKey

pub fn with_component( &self, component: String, ) -> Result<StorageKey, InvalidStorageKey>

Create a new StorageKey with the given component appended.

Errors

Returns an error if the new component is empty or contains a forward slash.

Trait Implementations

impl Clone for StorageKey

fn clone(&self) -> StorageKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StorageKey

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

Formats the value using the given formatter.

impl Display for StorageKey

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

Formats the value using the given formatter.

impl Eq for StorageKey

impl Hash for StorageKey

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<'a> IntoIterator for &'a StorageKey

type Item = &'a String

The type of the elements being iterated over.

type IntoIter = Iter<'a, String>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoIterator for StorageKey

type Item = String

The type of the elements being iterated over.

type IntoIter = IntoIter<String>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for StorageKey

fn eq(&self, other: &StorageKey) -> 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 StructuralPartialEq for StorageKey