Struct MetaCache 

pub struct MetaCache { /* private fields */ }

Meta bytes keyed by their own keccak256 hash.

The key is not a name for the bytes, it is a digest of them, and this type exists to make that true by construction rather than by discipline. The map is a BTreeMap so serializing twice gives the same bytes. std::collections::HashMap iterates in an order randomized per process, which would make a serialized cache unreproducible for no gain - every access here is by key.

Implementations

impl MetaCache

pub fn insert_verified( &mut self, hash: &[u8], bytes: Vec<u8>, ) -> Result<&Vec<u8>, Error>

Caches bytes under hash, and only if they hash to it.

A mismatch is Error::CorruptRecord rather than a miss: the responder answered a question about one hash with bytes that are another, which is not the same fact as the hash being absent. rainlanguage/rain.metadata#234 and #213 settled that distinction for the query layer; this is the same distinction at the cache.

pub fn get(&self, hash: &[u8]) -> Option<&Vec<u8>>

The bytes cached under hash, if any.

pub fn contains_key(&self, hash: &[u8]) -> bool

Whether anything is cached under hash.

pub fn remove(&mut self, hash: &[u8])

Drops whatever is cached under hash. Removing cannot break the invariant, so it needs no check.

pub fn iter(&self) -> impl Iterator<Item = (&Vec<u8>, &Vec<u8>)>

Every cached pair. Entries are verified by construction, so copying one into another MetaCache cannot introduce an unverified entry.

pub fn is_empty(&self) -> bool

Whether anything is cached at all.

pub fn len(&self) -> usize

How many metas are cached.

Trait Implementations

impl Clone for MetaCache

fn clone(&self) -> MetaCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MetaCache

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

Formats the value using the given formatter.

impl Default for MetaCache

fn default() -> MetaCache

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MetaCache

Deserializing is a way into the cache, so it goes through the same gate.

A derived impl would build inner directly, which is how the invariant leaked the first time this type was written: entries refused by MetaCache::insert_verified were accepted wholesale off the wire. A cache is only as good as the worst entry in it, so one bad pair rejects the whole map rather than being dropped quietly - unlike a responder’s single answer, a serialized cache is something this process wrote and should not be able to get wrong.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl PartialEq for MetaCache

fn eq(&self, other: &MetaCache) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for MetaCache

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MetaCache