Struct KeyTables 

pub struct KeyTables {
    pub types: Vec<KeyStruct>,
    pub ops: Vec<OpKeys>,
}

The key tables of a schema (or of a server’s accepted contracts).

ops is kept sorted by (op, digest), so two tables built from the same contracts are equal and serialise to the same bytes whatever the order the contracts were added in.

Fields

types: Vec<KeyStruct>

ops: Vec<OpKeys>

Implementations

impl KeyTables

pub fn to_bytes(&self) -> Vec<u8>

The artifact bytes: deterministic, so equal tables give equal bytes.

pub fn from_bytes(bytes: &[u8]) -> Result<KeyTables, CompactError>

Reads an artifact to_bytes wrote. Refuses another format number, trailing bytes, a struct index past the table and a digest that is not 32 bytes.

impl KeyTables

pub fn add_contract( &mut self, digest: [u8; 32], contract: &Value, ) -> Result<(), CompactError>

Adds the tables of one op’s canonical contract JSON (the form op_contract_json prints and ContractLock stores) under digest. The op key comes from the contract itself. Adding the same (op, digest) again replaces the entry.

The digest is taken on trust, as the lock’s own entries are checked by whoever reads the lock (ContractLock::parse recomputes them).

impl KeyTables

pub fn from_schema(schema: &Schema) -> KeyTables

Tables for every op schema exposes, each at its current contract digest (the ops op_keys lists, in that order).

let schema: cratestack_core::Schema = serde_json::from_str(
    r#"{"datasource":null,"auth":null,"config_blocks":[],"mixins":[],
        "models":[],"types":[],"enums":[],"procedures":[]}"#,
)
.unwrap();
assert!(cratestack_core::compact::KeyTables::from_schema(&schema).ops.is_empty());

impl KeyTables

pub fn find(&self, op: &str, selector: &ContractSelector) -> Option<&OpKeys>

The op op whose digest starts with selector’s bytes. When two accepted digests share the prefix, the first in digest order wins.

pub fn find_digest(&self, op: &str, digest: &[u8; 32]) -> Option<&OpKeys>

The op op at exactly digest.

pub fn node<'a>(&self, keys: &'a OpKeys, dir: Direction) -> &'a KeyNode

The root node of keys for one direction.

Trait Implementations

impl Clone for KeyTables

fn clone(&self) -> KeyTables

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyTables

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

Formats the value using the given formatter.

impl Default for KeyTables

fn default() -> KeyTables

Returns the “default value” for a type.

impl Eq for KeyTables

impl PartialEq for KeyTables

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for KeyTables