Struct Creations 

pub struct Creations<Item> { /* private fields */ }

One ordered creation batch.

The batch is the all-or-none unit for runtime route preparation. After routing succeeds, each child still settles independently in this declared order.

Implementations

impl<Item> Creations<Item>

pub const fn empty() -> Self

Construct an empty creation batch.

pub fn one(item: Item) -> Self

pub fn into_one(self) -> Result<Item, Self>

Consume a batch containing exactly one item.

Errors

Returns the complete ordered batch when it is empty or contains more than one item.

pub fn and(self, item: Item) -> Self

pub fn map<Mapped>(self, map: impl FnMut(Item) -> Mapped) -> Creations<Mapped>

Transform every item while preserving declared order and cardinality.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'_, Item>

Trait Implementations

impl<A, New> ActionItem for Creations<CreateChild<A, New>>

where A: Address, A::Nonce: Send, New: Send,

type Custody = (Option<Creations<CreateChild<A, New>>>, Option<<Creations<CreateChild<A, New>> as ActionItem>::Reply>)

type Input<'a> = &'a mut Option<Creations<CreateChild<A, New>>> where Self: 'a

type Reply = ItemSettlement<Creations<CreateChild<A, New>>, <Creations<CreateChild<A, New>> as ActionItem>::Accepted, <Creations<CreateChild<A, New>> as ActionItem>::Rejection, <Creations<CreateChild<A, New>> as ActionItem>::Prerequisite>

type Accepted = Creations<RoutedCreation<A, New>>

type Rejection = ChildNamespaceExhausted

type Prerequisite = Never

fn prepare_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::Custody, Self::Reply>>, )

fn interpretation_input<'a>( custody: &'a mut Self::Custody, ) -> Option<(Self::Input<'a>, &'a mut Option<Self::Reply>)>

where Self: 'a,

fn finish_interpretation( progress: &mut Option<InterpretationProgress<Self, Self::Custody, Self::Reply>>, )

fn retain_accepted(_: Self::Accepted) -> Option<Self::Accepted>

Keep an accepted value only while it still carries terminal custody.

impl<Item> ClassifySettlement for Creations<Item>

where Item: ClassifySettlement,

fn settlement_status(&self) -> SettlementStatus

Inspect every member without consuming or rewriting the settlement.

impl<Item: Clone> Clone for Creations<Item>

fn clone(&self) -> Creations<Item>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Item: Debug> Debug for Creations<Item>

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

Formats the value using the given formatter.

impl<Item> Default for Creations<Item>

fn default() -> Self

Returns the “default value” for a type.

impl<Item> Extend<Item> for Creations<Item>

fn extend<Items: IntoIterator<Item = Item>>(&mut self, items: Items)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<Item> FromIterator<Item> for Creations<Item>

fn from_iter<Items: IntoIterator<Item = Item>>(items: Items) -> Self

Creates a value from an iterator.

impl<'a, Item> IntoIterator for &'a Creations<Item>

type Item = &'a Item

The type of the elements being iterated over.

type IntoIter = Iter<'a, Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Item> IntoIterator for Creations<Item>

type Item = Item

The type of the elements being iterated over.

type IntoIter = IntoIter<Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Item: PartialEq> PartialEq for Creations<Item>

fn eq(&self, other: &Creations<Item>) -> 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<Host, RootEvent> SourceSettlementCustody<Host, RootEvent> for Creations<Never>

type Custody = Creations<Never>

fn prepare_source(progress: &mut Option<SourceProgress<Self, Self::Custody>>)

fn offer_next_to_source( _: &mut Self::Custody, _: &mut Host, ) -> impl Future<Output = ()> + Send

fn finish_source(progress: &mut Option<SourceProgress<Self, Self::Custody>>)

impl<Item: Eq> Eq for Creations<Item>

impl<Item> StructuralPartialEq for Creations<Item>