Enum Event 

pub enum Event {
    Leaf(u32),
    Branch(u32, Box<Self>, Box<Self>),
}

An ITC event tree, tracking causal history as a binary tree of counters.

The effective count at any position is the sum of counters along the root-to-leaf path. Interior nodes carry a base counter that is shared by both subtrees. Normalization lifts the minimum of two children’s leaf values into the parent and collapses uniform branches.

Variants

Leaf(u32)

Leaf with a counter value.

Branch(u32, Box<Self>, Box<Self>)

Branch with a base counter and left/right subtrees.

The effective value at any leaf in this subtree is base plus the value accumulated through the child path.

Implementations

impl Event

pub const fn leaf(value: u32) -> Self

Create a leaf node with the given counter value.

pub const fn zero() -> Self

Create a zero leaf (no events recorded).

pub fn branch(base: u32, left: Self, right: Self) -> Self

Create a branch, automatically normalizing degenerate cases.

Normalization rules:

• Branch(n, Leaf(a), Leaf(b)) where a == b → Leaf(n + a)
• Otherwise, lifts the minimum of leaf children into the base: Branch(n, l, r) → Branch(n + min, l - min, r - min)

pub const fn is_leaf(&self) -> bool

Returns true if this is a leaf node.

pub const fn is_branch(&self) -> bool

Returns true if this is a branch node.

pub const fn value(&self) -> u32

The base value at this node.

For leaves, this is the counter value. For branches, the base counter.

pub fn min_value(&self) -> u32

The minimum effective value in the entire subtree.

For leaves, this is just the counter. For branches, it is the base plus the minimum of the two children’s minimums.

pub fn max_value(&self) -> u32

The maximum effective value in the entire subtree.

For leaves, this is just the counter. For branches, it is the base plus the maximum of the two children’s maximums.

pub fn depth(&self) -> usize

Depth of the tree (0 for leaves).

pub fn node_count(&self) -> usize

Number of nodes in the tree (leaves + branches).

pub fn normalize(self) -> Self

Normalize the tree to its minimal representation.

Recursively normalizes children, then applies:

• Branch(n, Leaf(a), Leaf(b)) where a == b → Leaf(n + a)
• Lifts the common minimum into the base counter.

pub fn lift(self, delta: u32) -> Self

Lift the tree by adding delta to the base/leaf value.

Trait Implementations

impl Clone for Event

fn clone(&self) -> Event

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Event

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

Formats the value using the given formatter.

impl Hash for Event

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 Event

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

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 Event

impl StructuralPartialEq for Event