Struct CapabilityDiff 

pub struct CapabilityDiff {
    pub node_id: u64,
    pub base_version: u64,
    pub new_version: u64,
    pub ops: Vec<DiffOp>,
    pub timestamp_ns: u64,
}

Capability diff message

Fields

node_id: u64

Source node ID

base_version: u64

Base version this diff applies to

new_version: u64

New version after applying diff

ops: Vec<DiffOp>

Operations to apply (in order)

timestamp_ns: u64

Timestamp (nanoseconds since epoch)

Implementations

impl CapabilityDiff

pub fn new( node_id: u64, base_version: u64, new_version: u64, ops: Vec<DiffOp>, ) -> CapabilityDiff

Create a new capability diff

pub fn is_empty(&self) -> bool

Check if this diff is empty (no operations)

pub fn len(&self) -> usize

Get number of operations

pub fn estimated_size(&self) -> usize

Estimate total serialized size in bytes

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

👎Deprecated:

use try_to_bytes — to_bytes swallows cap-violations as an empty Vec

Serialize to bytes (legacy — silent empty-on-failure path).

Returns Vec::new() on any encoding error or cap violation, indistinguishable from a legitimate empty diff. A sender that hit the cap silently transmits zero bytes; the receiver drops the empty payload and the two sides diverge with no diagnostic. New callers MUST use Self::try_to_bytes, which surfaces the cap violation as a typed error.

pub fn try_to_bytes(&self) -> Result<Vec<u8>, DiffSizeError>

Serialize to bytes with explicit size-cap enforcement.

Returns Err(DiffSizeError::TooManyOps) when ops.len() exceeds MAX_DIFF_OPS, and Err(DiffSizeError::Encoded { … }) when the serialized form exceeds MAX_DIFF_BYTES. Both checks MUST mirror what Self::from_bytes enforces — otherwise the sender would produce bytes the receiver silently discards. Production senders building diffs from peer-supplied or large-cardinality input MUST use this entry point.

pub fn from_bytes(data: &[u8]) -> Option<CapabilityDiff>

Deserialize from bytes.

Rejects inputs over MAX_DIFF_BYTES before parsing, and rejects diffs over MAX_DIFF_OPS after parsing. Both failure modes return None — the existing “malformed-or-too-large” outcome callers already handle. Without these caps a peer-supplied 100 MB JSON would expand into a Vec<DiffOp> of arbitrary length, and apply would iterate every op (each currently a no-op for SetField/UnsetField) — peer-controlled CPU/RAM burn for no useful effect.

Trait Implementations

impl Clone for CapabilityDiff

fn clone(&self) -> CapabilityDiff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CapabilityDiff

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CapabilityDiff

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CapabilityDiff

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.