Struct Memory 

pub struct Memory(Rc<Held>);

A container’s bytes, keyed by entry name, dying with the process.

A handle on a map rather than the map itself: cloning one hands a second container the same bytes, which is what re-opening a container means where there is no directory to point at twice.

Tuple Fields

0: Rc<Held>

Implementations

impl Memory

pub fn new(name: &str) -> Self

Read as a directory is: an entry at a time, as it is asked for.

pub fn resident(name: &str) -> Self

Read whole at open, with futures that are ready anyway — the residency without the waiting.

pub fn deferred(name: &str) -> Self

A map as asynchronous as origin-private storage is: every future answers Pending once before it completes, so nothing may resolve one by polling it — and, as Storage::release requires of such a storage, a lock of its own rather than an entry it could not remove as it is dropped.

pub fn refusing(self, at: Entry) -> Self

A map that will not write at, so a storage that fails partway through what it was handed can be stood up without breaking one.

fn with(name: &str, residency: Residency, pace: Pace) -> Self

pub fn reads(&self) -> usize

How many entries have been read out of this map — the count that must stop moving once a resident container is open.

pub fn wrote(&self) -> Vec<Entry>

What has been written to this map, in the order it landed.

async fn paced(&self)

Answer Pending once where this map is the deferred kind, so a caller that resolves its futures by polling them is caught.

fn read_one(&self)

fn wrote_one(&self, at: &Entry) -> Result<()>

Trait Implementations

impl Clone for Memory

fn clone(&self) -> Memory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Memory

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

Formats the value using the given formatter.

impl Default for Memory

fn default() -> Self

Returns the “default value” for a type.

impl Storage for Memory

fn name(&self) -> Name

What this container is called.

fn names(&self, at: &Entry) -> String

What a report calls at — a platform path where there is one. Not a promise that anything is there.

fn residency(&self) -> Residency

async fn read<'a>(&'a self, at: &'a Entry) -> Result<Option<Vec<u8>>>

The bytes at at, or None where nothing is — which is not the same as a read that did not work.

async fn exists<'a>(&'a self, at: &'a Entry) -> Result<bool>

Whether anything stands at at. Separate from Self::read because a payload is filed under a content hash, so the answer is all a write needs — and reading a megabyte to learn it is already there is the one thing that would make every commit cost the artwork on the page.

async fn write<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Result<()>

Whole file or nothing: a reader caught mid-write sees the previous contents, never half of each.

async fn append<'a>(&'a self, at: &'a Entry, bytes: &'a [u8]) -> Result<()>

Add bytes to the end of at, durably before returning.

async fn truncate<'a>(&'a self, at: &'a Entry, len: u64) -> Result<()>

async fn list<'a>(&'a self, dir: &'a Entry) -> Result<Vec<String>>

What dir holds, by name, in no particular order.

async fn remove<'a>(&'a self, at: &'a Entry) -> Result<()>

async fn create_dir<'a>(&'a self, dir: &'a Entry) -> Result<()>

Make dir a place entries can be written.

async fn rename<'a>(&'a mut self, to: &'a Name) -> Result<()>

Call this container something else, leaving everything in it where it is — which is what renaming the document means.

async fn discard(&self) -> Result<()>

Remove the container itself. Only ever asked of one that has been emptied.

async fn claim(&self, now: WallTime) -> Result<Claim>

Claim the right to write this container.

fn release(&self)

Give the lock back.

fn disk_path(&self) -> Option<&Path>

Where these bytes sit on a filesystem, for a shell that can name one. None for a storage that has no such thing.