Struct ManagedNode 

pub struct ManagedNode<R> { /* private fields */ }

Shared language-neutral arena, node, edge, and retention building blocks. A role-bearing managed object with stable, ordered strong edges.

Edge storage and identity allocation are deliberately private. Callers can mutate the graph only through checked operations, so identities are never reused and compare-and-mutate failures leave the node unchanged.

Implementations

impl<R> ManagedNode<R>

pub const fn new(role: R) -> ManagedNode<R>

Constructs an empty node carrying caller-owned role evidence.

pub const fn with_edge_limits(role: R, limits: EdgeLimits) -> ManagedNode<R>

Constructs an empty node with explicit total and per-kind hard caps.

pub fn edge_snapshot(&self) -> Vec<EdgeSnapshot>

Returns an allocation-ordered copy of every live outgoing edge.

pub const fn role(&self) -> &R

Borrows the node’s role evidence.

pub fn replace_role(&mut self, role: R) -> R

Replaces the role without changing the managed graph.

pub fn insert_strong( &mut self, target: ManagedId, ) -> Result<EdgeId, StrongEdgeMutationError>

Inserts a strong edge and returns its stable identity.

pub fn replace_strong( &mut self, edge: EdgeId, expected: ManagedId, replacement: ManagedId, ) -> Result<(), StrongEdgeMutationError>

Replaces a strong target only if it still equals expected.

pub fn remove_strong( &mut self, edge: EdgeId, expected: ManagedId, ) -> Result<ManagedId, StrongEdgeMutationError>

Removes a strong edge only if it still equals expected.

pub fn insert_weak( &mut self, target: ManagedId, ) -> Result<EdgeId, WeakEdgeMutationError>

Inserts a weak edge and returns its stable identity.

pub fn replace_weak( &mut self, edge: EdgeId, expected: ManagedId, replacement: ManagedId, ) -> Result<(), WeakEdgeMutationError>

Replaces a weak target only if it still equals expected.

pub fn remove_weak( &mut self, edge: EdgeId, expected: ManagedId, ) -> Result<ManagedId, WeakEdgeMutationError>

Removes a weak edge only if it still equals expected.

pub fn insert_ephemeron( &mut self, key: ManagedId, value: ManagedId, ) -> Result<EdgeId, EphemeronMutationError>

Inserts an ephemeron entry and returns its stable identity.

pub fn replace_ephemeron( &mut self, edge: EdgeId, expected: (ManagedId, ManagedId), replacement: (ManagedId, ManagedId), ) -> Result<(), EphemeronMutationError>

Replaces an ephemeron only if it still contains the expected pair.

pub fn remove_ephemeron( &mut self, edge: EdgeId, expected: (ManagedId, ManagedId), ) -> Result<(ManagedId, ManagedId), EphemeronMutationError>

Removes an ephemeron only if it still contains the expected pair.

Trait Implementations

impl<R> Clone for ManagedNode<R>

where R: Clone,

fn clone(&self) -> ManagedNode<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for ManagedNode<R>

where R: Debug,

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

Formats the value using the given formatter.

impl<R> Eq for ManagedNode<R>

where R: Eq,

impl<R> ManagedObject for ManagedNode<R>

fn trace_edges(&self, visitor: &mut dyn EdgeVisitor)

Enumerates all strong, weak, and ephemeron edges exactly once.

fn clear_weak_edge(&mut self, edge: EdgeId, expected: ManagedId) -> bool

Clears one weak edge if it still points at expected.

fn clear_ephemeron_edge( &mut self, edge: EdgeId, expected_key: ManagedId, expected_value: ManagedId, ) -> bool

Clears one ephemeron entry if it still has the expected key and value. Repeating a successful request must return false.

impl<R> PartialEq for ManagedNode<R>

where R: PartialEq,

fn eq(&self, other: &ManagedNode<R>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<R> RoleBearingManagedObject for ManagedNode<R>

type Role = R

Role label type chosen by the object owner.

fn managed_role(&self) -> &<ManagedNode<R> as RoleBearingManagedObject>::Role

Borrows the current audit role.

fn replace_managed_role( &mut self, role: <ManagedNode<R> as RoleBearingManagedObject>::Role, ) -> <ManagedNode<R> as RoleBearingManagedObject>::Role

Replaces audit role evidence without changing the managed graph.

impl<R> StructuralPartialEq for ManagedNode<R>

where R: PartialEq,