Struct Stamp 

pub struct Stamp {
    pub id: Id,
    pub event: Event,
}

An ITC stamp: a pair of (ID tree, Event tree).

The stamp is the fundamental unit of causality tracking in ITC. Each agent holds a stamp; operations like fork, join, and event modify the stamp to track causal history.

Fields

id: Id

The identity partition owned by this stamp.

event: Event

The causal history recorded by this stamp.

Implementations

impl Stamp

pub const fn new(id: Id, event: Event) -> Self

Create a new stamp with the given ID and event trees.

pub const fn seed() -> Self

Create the initial seed stamp: owns the full interval with zero events.

This is the starting point for an ITC system. The seed stamp owns the entire [0, 1) interval and has recorded no events.

pub const fn anonymous() -> Self

Create an anonymous stamp: owns nothing, zero events.

An anonymous stamp cannot record events but can receive causality information through join operations.

pub fn is_anonymous(&self) -> bool

Returns true if this stamp owns no interval.

pub fn normalize(self) -> Self

Normalize both the ID and event trees to their minimal representations.

impl Stamp

pub fn fork(&self) -> (Self, Self)

Split this stamp’s ID interval into two halves.

Used when a new agent forks from an existing one. Returns (left, right) where left and right partition the original interval: left ∪ right = original, left ∩ right = ∅.

Both stamps share the same event tree (causal history at time of fork).

Panics

Panics if this stamp is anonymous (owns no interval to split).

pub fn join(a: &Self, b: &Self) -> Self

Merge two stamps into one, combining their ID intervals and taking the pointwise maximum of their event trees.

Used when an agent retires and donates its interval back, or when synchronizing causality information between agents.

pub fn event(&mut self)

Record a new event, inflating the event tree.

Called on every event emission. The event counter is monotonically increased at a position owned by this stamp’s ID. Uses the fill-then-grow strategy from the ITC paper for minimal tree growth.

Panics

Panics if this stamp is anonymous (cannot record events without owning part of the interval).

pub const fn peek(&self) -> &Event

Read the current event tree without incrementing.

pub fn leq(&self, other: &Self) -> bool

Causal dominance: returns true if self happened-before-or-equal other.

This means every event recorded by self is also recorded by other.

pub fn concurrent(&self, other: &Self) -> bool

Returns true if neither stamp causally dominates the other.

Two stamps are concurrent if there exist events in each that the other has not observed.

impl Stamp

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

Serialize this stamp using the compact binary ITC format.

pub fn deserialize_compact(input: &[u8]) -> Result<Self, CodecError>

Deserialize a stamp from the compact binary ITC format.

Errors

Returns CodecError when the input is malformed, truncated, has an unknown format version, or contains trailing data.

Trait Implementations

impl Clone for Stamp

fn clone(&self) -> Stamp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stamp

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Stamp

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Stamp

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

Formats the value using the given formatter.

impl Hash for Stamp

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Stamp

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

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 Stamp

impl StructuralPartialEq for Stamp