Struct MemoryStore 

pub struct MemoryStore { /* private fields */ }

An in-memory tree store that implements the StructFS store conventions:

• Reading a prefix returns its subtree as a Value::Map of children.
• Writing deep paths creates intermediate maps as needed.
• Writing Value::Null deletes the node and its entire subtree (component-wise: deleting accounts does not touch accounts_other).
• Writing a Value::Map at a parent replaces the full state under that path — stale descendants do not survive.

This is the reference implementation certified by the conformance suite; use that suite to verify other stores implement the same semantics.

Example

use structfs_core_store::{MemoryStore, Reader, Writer, Record, Value, path};

let mut store = MemoryStore::new();
store.write(&path!("users/alice/name"), Record::parsed(Value::from("Alice"))).unwrap();

// Reading the prefix returns the subtree
let users = store.read(&path!("users")).unwrap().unwrap();
assert!(users.as_value().unwrap().is_map());

// Null deletes the subtree
store.write(&path!("users"), Record::parsed(Value::Null)).unwrap();
assert!(store.read(&path!("users/alice/name")).unwrap().is_none());

Implementations

impl MemoryStore

pub fn new() -> Self

Create a new empty store.

pub fn with_root(root: Value) -> Self

Create a store with initial contents.

pub fn root(&self) -> &Value

Borrow the root value.

Trait Implementations

impl Debug for MemoryStore

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

Formats the value using the given formatter.

impl Default for MemoryStore

fn default() -> MemoryStore

Returns the “default value” for a type.

impl Reader for MemoryStore

fn read(&mut self, from: &Path) -> Result<Option<Record>, Error>

Read a record from a path.

fn read_children(&mut self, from: &Path) -> Result<Option<Vec<String>>, Error>

Enumerate the child names directly under a path.

impl Writer for MemoryStore

fn write(&mut self, to: &Path, data: Record) -> Result<Path, Error>

Write a record to a path.