Struct CapOverride 

pub struct CapOverride {
    pub subject: Subject,
    pub scope: Scope,
    pub effect: Effect,
    pub access: Access,
    pub id: String,
    pub expiry: Expiry,
    pub granted_by: Option<Principal>,
}

One sandbox capability.

Fields

subject: Subject

scope: Scope

effect: Effect

access: Access

id: String

Stable id: revocation and the replicated map key on it.

expiry: Expiry

granted_by: Option<Principal>

Who granted it, for audit and the share list.

Implementations

impl CapOverride

pub fn paths() -> CapOverridePaths<CapOverride>

The typed paths into a CapOverride, rooted at it.

impl CapOverride

pub fn new( subject: Subject, scope: Scope, effect: Effect, access: Access, ) -> CapOverride

pub fn grant(subject: Subject, scope: Scope, access: Access) -> CapOverride

pub fn with_id(self, id: impl Into<String>) -> CapOverride

pub fn with_expiry(self, unix_seconds: u64) -> CapOverride

pub fn expiring(self, expiry: Expiry) -> CapOverride

pub fn granted_by(self, who: Principal) -> CapOverride

pub fn is_live_at(&self, now: Option<u64>) -> bool

pub fn persists_across_restart(&self) -> bool

Trait Implementations

impl Clone for CapOverride

fn clone(&self) -> CapOverride

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CapOverride

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CapOverride

fn deserialize<__D>( __deserializer: __D, ) -> Result<CapOverride, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Fields for CapOverride

const ITEM_FIELDS: &'static [&'static str] = Self::__COLLECTIONS

The collection fields whose items are published as item resources (Collection, Keyed, Ordered); #[derive(Model)] lists them.

fn read_fields(doc: &AutoCommit, obj: &ExId) -> Result<CapOverride, ModelError>

Errors

fn write_fields( &self, doc: &mut AutoCommit, obj: &ExId, ) -> Result<(), ModelError>

fn write_changed_fields( &self, before: &CapOverride, doc: &mut AutoCommit, obj: &ExId, dirty: &Delta, ) -> Result<(), ModelError>

Write the fields to the map obj, which holds before: the operations write_fields would write, with each field compared to its value in before rather than read back (see Model::store_changed). #[derive(Model)] writes only the fields that changed; the default writes every field.

fn edit_fields( doc: &mut AutoCommit, obj: &ExId, path: &[Segment], op: &EditOp, cx: &mut ActionCx, ) -> Result<(), ModelError>

Apply the field edit op at path below the map obj; see Model::edit. #[derive(Model)] routes each field segment to its field; the default edits nothing.

fn refresh_fields( &mut self, doc: &AutoCommit, obj: &ExId, delta: &Delta, ) -> Result<(), ModelError>

Bring fields read earlier from the map obj up to date after the changes in delta, re-reading only the fields they touched.

fn item_collections(&self) -> Vec<ItemCollection>

The items of each Collection field, so actions on an item can be offered on the item (see [crate::items]), at most ITEM_PAGE of each. #[derive(Model)] lists them; the default has none.

fn item_label(&self, field: &str, id: &Id) -> Option<String>

The label the item id of the collection field field is offered under, or None when there is no such item.

fn item_search(&self) -> Vec<ItemText>

Every item of the collection fields whose type has a #[model(label)], with its text: what search indexes by default.

fn item_collection_sizes(&self) -> Vec<(&'static str, usize)>

How many items each Collection field holds, by field, in the order of item_collections, without listing them. #[derive(Model)] counts them; the default lists them.

impl Model for CapOverride

const SHAPE: Shape

How the value is laid out in the document; see Shape. Types written whole keep the default.

const CHECKS: bool

Whether this type or any value inside it has a #[model(check)] invariant; Self::check has nothing to do otherwise.

const OPS: bool

Whether this type or a value inside it has a vocabulary of its own (Operations, rich text’s): a record routes those edits’ gestures, landing places and schemas only into such fields, and never instantiates the routing for the others.

const TABLE: &'static ModelTable

The type’s functions as data, which a record holding it reaches it through ([crate::table]): by default its own functions, erased.

type Paths<__R> = CapOverridePaths<__R>

The typed paths into a value of this type, rooted in the record R: a struct of field paths for a record, the Path itself for a value edited whole or through its own operations.

fn paths_at<__R>( path: Path<__R, CapOverride>, ) -> <CapOverride as Model>::Paths<__R>

The paths of the value at path.

fn to_json(&self) -> Value

The value as JSON: what [EditOp::Set] carries and history shows.

fn from_json(value: &Value) -> Result<CapOverride, ModelError>

A value from its Self::to_json form.

fn edit( doc: &mut AutoCommit, slot: Slot<'_>, path: &[Segment], op: &EditOp, cx: &mut ActionCx, ) -> Result<(), ModelError>

Apply the field edit op at path, below the value in slot, touching only what it changes, then run the invariants of the values it touched. The default edits a value only as a whole.

fn check(&self) -> Result<(), Refusal>

Run every #[model(check)] invariant of this value and the values inside it.

fn op_coalesces( path: &[Segment], previous: &Value, next: &Value, ) -> Option<bool>

Whether two edits in the own vocabulary of the value at path below this type are one gesture (Operations); None when nothing there has one.

fn op_continuable(path: &[Segment], op: &Value) -> Option<bool>

Whether a gesture may go on after the edit op at path.

fn diff<__E>( &self, after: &CapOverride, path: &[Segment], out: &mut Vec<Edit<__E>>, )

The field edits that turn self into after, at path below the record: what a surface that edited a local copy submits. The default sets the value whole when it changed; containers and records edit only what differs, item by item and field by field. A value that would store as it is (Self::stores_as) is compared in memory, without turning either side into JSON.

fn op_describe(path: &[Segment], op: &Value) -> Option<OpDescription>

What the edit op at path below this type did, in the history entry’s terms (Operations::describe).

fn op_lands(&self, path: &[Segment], op: &Value) -> Option<Place>

Where the actor of the edit op at path below this value is after it applied.

fn op_schemas(prefix: &str, out: &mut Vec<(String, Value)>)

The schemas of the own vocabularies of the values below this type, by path pattern from prefix (* for every item).

fn get_at(&self, path: &[Segment]) -> Option<&(dyn Any + 'static)>

The value at path below this one, if it is there. A value with nothing inside it is found only at the empty path.

fn load( doc: &AutoCommit, value: &Value<'_>, id: &ExId, ) -> Result<CapOverride, ModelError>

Read from the value a parent found in its slot.

fn value_schema() -> Value

The JSON Schema of this value’s JSON form (Self::to_json), as the published field edit describes what a path takes; the default accepts any value.

fn field_type(types: &mut TypeSet) -> FieldType

This value’s type in the language-neutral vocabulary a surface publishes (FieldType), declaring the records and enums it names in types. The default describes no type: any value.

fn missing() -> Result<CapOverride, ModelError>

The value of an absent slot. Types with a natural empty value return it, so a field added to a schema reads older documents without migration.

fn store(&self, doc: &mut AutoCommit, slot: Slot<'_>) -> Result<(), ModelError>

Write self into slot, changing only what differs from what the slot already holds.

fn stores_as(&self, before: &CapOverride) -> bool

Whether writing self over a slot that holds before, as a store left it, would change nothing: an in-memory comparison, so an action that changed one item of a long collection does not visit the others. Must only answer true when store would write no operation; the default answers false (unknown).

fn store_changed( &self, before: &CapOverride, doc: &mut AutoCommit, slot: Slot<'_>, dirty: &Delta, ) -> Result<(), ModelError>

Write self into slot, which holds before: exactly the operations store would write, found by comparing with before where store would read the document.

fn refresh( &mut self, doc: &AutoCommit, value: &Value<'_>, id: &ExId, delta: &Delta, ) -> Result<(), ModelError>

Bring a value read earlier up to date after the changes in delta, re-reading only what they touched. value and id are what the parent’s slot holds now — the same object as when self was read, or the parent would have read it anew. The default reads the value again, which is right for scalars and short values.

fn collect_text(&self, out: &mut Vec<String>)

Append the human-readable text this value carries, for search indexing.

const NULLABLE: bool = false

Whether null is a value of the type: an absent Option. A field edit setting any other type to null is refused.

const SCALAR: bool = false

Whether store writes one scalar, with nothing inside it that a concurrent writer could add to. A record made just now leaves out such a field holding its missing value: an absent key reads as it. An object (text, a map, a list) is always made with its record, so two writers fill the same one.

fn nested_collections(&self) -> Vec<ItemCollection>

The item collections inside this value, when it is an item of a collection itself (a slide’s elements); #[derive(Model)] lists a record’s, the default has none.

fn read_whole(&mut self, doc: &AutoCommit) -> Result<(), ModelError>

Read everything this value holds, for a field marked #[model(whole)]: a value read lazily (rich text reads its paragraphs as views ask for them) reads all of it, so every reader of the record — a verb, search, read_content — sees all of it. The default has nothing more to read.

fn label(&self) -> Option<String>

What names this value for people (#[model(label)]): history, search, agents and item resources use it.

impl PartialEq for CapOverride

fn eq(&self, other: &CapOverride) -> 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 Serialize for CapOverride

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CapOverride

impl Settable for CapOverride

impl StructuralPartialEq for CapOverride