Struct CreationResolved 

pub struct CreationResolved<A: Address> {
    pub creation: CreationId,
    pub kind: CreationKind,
    pub result: Result<A, CreationRejection>,
}

The committed result of one staged behavior::CreateChild request.

Installed is emitted only after fresh allocation, successful initialization, and binding at nonce. The replacement provenance is the provenance supplied by Behavior; an interpreter must never infer it from address reuse or creation order.

Fields

creation: CreationId

kind: CreationKind

result: Result<A, CreationRejection>

Implementations

impl<A: Address> CreationResolved<A>

pub const fn new( creation: CreationId, kind: CreationKind, result: Result<A, CreationRejection>, ) -> Self

pub const fn installed( creation: CreationId, kind: CreationKind, address: A, ) -> Self

pub const fn birth(creation: CreationId, address: A) -> Self

A successfully committed ordinary birth.

pub const fn replacement( creation: CreationId, previous: CreationId, address: A, ) -> Self

A successfully committed replacement incarnation.

pub const fn rejected( creation: CreationId, kind: CreationKind, rejection: CreationRejection, ) -> Self

Trait Implementations

impl<A: Clone + Address> Clone for CreationResolved<A>

fn clone(&self) -> CreationResolved<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug + Address> Debug for CreationResolved<A>

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

Formats the value using the given formatter.

impl<A: Address> From<(CreationId, CreationKind, Result<A, CreationRejection>)> for CreationResolved<A>

fn from( (creation, kind, result): (CreationId, CreationKind, Result<A, CreationRejection>), ) -> Self

Converts to this type from the input type.

impl<A: PartialEq + Address> PartialEq for CreationResolved<A>

fn eq(&self, other: &CreationResolved<A>) -> 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<A: Copy + Address> Copy for CreationResolved<A>

impl<A: Eq + Address> Eq for CreationResolved<A>

impl<A: Address> StructuralPartialEq for CreationResolved<A>