Struct Mem 

pub struct Mem { /* private fields */ }

An in-memory ObjectStore. Generations increase monotonically across the whole store, like GCS.

Implementations

impl Mem

pub fn inject(&self, fault: Fault)

Queue a fault for a future operation (consumed in order, one per call).

pub fn inject_after(&self, skip: u64, fault: Fault)

Let skip operations through, then apply fault — for crash tests that fail each step of a multi-operation protocol in turn.

pub fn clear_faults(&self)

Drop every queued fault.

pub fn ops(&self) -> u64

Operations served so far (every call, failed or not).

pub fn keys(&self) -> Vec<String>

Every key, sorted.

Trait Implementations

impl Debug for Mem

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

Formats the value using the given formatter.

impl Default for Mem

fn default() -> Self

Returns the “default value” for a type.

impl ObjectStore for Mem

type Get<'a> = Ready<Result<Option<Object>, Error>>

Future of get.

type GetRange<'a> = Ready<Result<Bytes, Error>>

Future of get_range.

type Head<'a> = Ready<Result<Option<Meta>, Error>>

Future of head.

type Put<'a> = Ready<Result<u64, Error>>

Future of put.

type List<'a> = Ready<Result<Vec<Meta>, Error>>

Future of list.

type Delete<'a> = Ready<Result<(), Error>>

Future of delete.

fn get<'a>(&'a self, key: &'a str) -> Self::Get<'a>

The whole object, or None if it does not exist.

fn get_range<'a>( &'a self, key: &'a str, range: Range<u64>, ) -> Self::GetRange<'a>

Bytes range of the object. A range running past the end is clipped; a range starting at or past the end is an empty body. A missing object is Error::NotFound.

fn head<'a>(&'a self, key: &'a str) -> Self::Head<'a>

Size and generation, without the body.

fn put<'a>(&'a self, key: &'a str, body: Bytes, cond: Cond) -> Self::Put<'a>

Write body under key if cond holds; returns the new generation.

fn list<'a>(&'a self, prefix: &'a str) -> Self::List<'a>

Every object whose key starts with prefix, sorted by key. An empty prefix lists everything; a non-empty prefix is validated like a key (a trailing / is allowed).

fn delete<'a>(&'a self, key: &'a str) -> Self::Delete<'a>

Remove the object. Deleting a missing key succeeds.