Struct ManagedException 

pub struct ManagedException<P, R> { /* private fields */ }

A guest exception payload with caller-defined relation roles.

The payload is the open role carried by the shared ManagedNode. Relation roles are deliberately caller data: this adapter does not prescribe cause, context, group, or suppression semantics.

Implementations

impl<P, R> ManagedException<P, R>

pub const fn new(payload: P) -> ManagedException<P, R>

Creates an exception payload with the managed node’s standard edge limits.

pub const fn with_edge_limits( payload: P, limits: EdgeLimits, ) -> ManagedException<P, R>

Creates an exception payload with explicit managed edge limits.

pub const fn payload(&self) -> &P

Borrows the guest payload.

pub fn replace_payload(&mut self, payload: P) -> P

Replaces the guest payload without changing relation identity.

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

Adds a retaining relation with caller-owned role evidence.

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

Removes exactly the expected relation and returns its role and target.

pub fn relations(&self) -> impl Iterator<Item = (EdgeId, &R, ManagedId)>

Returns relation edges in stable edge-id order.

Trait Implementations

impl<P, R> Clone for ManagedException<P, R>

where P: Clone, R: Clone,

fn clone(&self) -> ManagedException<P, R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P, R> Debug for ManagedException<P, R>

where P: Debug, R: Debug,

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

Formats the value using the given formatter.

impl<P, R> Eq for ManagedException<P, R>

where P: Eq, R: Eq,

impl<P, R> ManagedObject for ManagedException<P, 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<P, R> PartialEq for ManagedException<P, R>

where P: PartialEq, R: PartialEq,

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

Equality operator ==.

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

Inequality operator !=.

impl<P, R> StructuralPartialEq for ManagedException<P, R>

where P: PartialEq, R: PartialEq,