Struct ViewOp 

pub struct ViewOp {
    pub format_version: u16,
    pub kind: OpKind,
    pub scope: Option<OpScope>,
    pub provenance: Option<Provenance>,
    pub depends: Vec<ContentHash>,
}

A typed operation carried in OpEntry::payload.

Fields

format_version: u16

Wire-format version this op was written with; see FORMAT_VERSION.

kind: OpKind

What the operation does to the view.

scope: Option<OpScope>

The log and head this op was signed for, when the author bound it to one. Additive (default + skip_serializing_if), so ops written before scopes existed decode as None and re-serialize byte-identically — invariant 1, and the reason adding a replay defence is not a log migration.

provenance: Option<Provenance>

How this op was authored, when not the default author-signed class; see Provenance. Additive under the same rule as scope, so every existing op decodes as None and re-serializes byte-identically.

depends: Vec<ContentHash>

Explicit change dependencies: content hashes of the changes this op declares it builds on. Declared-only — the platform never infers dependencies from file overlap; inference is a separate decision. Additive under the same rule as scope (an empty list is not serialized), and because it sits inside the payload it is covered by the author’s (channel, payload) signature (invariant 4) with no change to the signing scheme: ops written before the field existed re-serialize byte-identically, so their signatures still verify.

Implementations

impl ViewOp

pub fn new(kind: OpKind) -> Self

Wraps kind at the current FORMAT_VERSION, unscoped, in the default author-signed provenance class.

pub fn with_depends(self, depends: Vec<ContentHash>) -> Self

Declares the changes this op builds on. The list rides inside the signed payload, so a relay can neither strip nor extend it.

pub fn with_provenance(self, provenance: Provenance) -> Self

Labels this op with a non-default provenance class. Only the node’s push path does this; admission refuses the label under any other signer, so calling it from an ordinary author buys a rejection, not a classification.

pub fn in_scope(self, node: ContentHash, head: Option<ContentHash>) -> Self

Binds this op to one log and one observed head. The scope is inside the payload, so it is covered by the author’s signature and cannot be stripped or rewritten by whoever relays the bytes.

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

Serializes into an OpEntry::payload.

pub fn from_payload(payload: &[u8]) -> Result<Self, ViewError>

Decodes an OpEntry::payload.

Errors

Returns ViewError::Decode when the bytes are not a valid op.

Trait Implementations

impl Clone for ViewOp

fn clone(&self) -> ViewOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ViewOp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ViewOp

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ViewOp

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ViewOp

impl StructuralPartialEq for ViewOp