Struct Packing 

pub struct Packing<'a> { /* private fields */ }

Whatever a Codec can write down, kept — by a Keeper that never finds out any of it was ever anything but bytes.

A store and a wire ask an opaque value the same question, so the pair (keeper, codec) is wired up once here rather than once per tenant. What is decided here is that the directions are not symmetrical: failing to name a value costs the name and the run goes on, while failing to keep it or to read it back is the keeper’s error.

Implementations

impl<'a> Packing<'a>

pub fn over(inner: &'a dyn Keeper, codec: &'a dyn Codec) -> Self

That keeper, with that codec in front of it.

Trait Implementations

impl Keeper for Packing<'_>

fn present(&self, keys: &[&Key]) -> Result<Vec<bool>, KeeperError>

Straight through: whether something is kept is a question about names, and a codec has nothing to say about a name.

fn key_of(&self, value: &Value) -> Option<Key>

The key of a value by its content, which only a root needs: from there down, keys come from keys. None if the value cannot leave this process, which is not a failure — nothing below it is cached either.

fn combine(&self, parts: &[&str]) -> Key

One key out of the ingredients of a recipe, in the order given. The parts have to stay apart: run together, ["ab", "c"] and ["a", "bc"] would name the same thing.

fn recall(&self, keys: &[&Key]) -> Result<Vec<Option<Kept>>, KeeperError>

What is kept under each of these, in the order they were asked. In batch form from the first day: against a remote store, one question per item is one round trip per item.

fn keep( &self, key: &Key, value: &Value, meta: &[(&str, &str)], ) -> Result<(), KeeperError>

Keeps this, with what should be remembered beside it — the fingerprint of the code that produced it, above all, which is not in the key and is what a hit gets compared against.