Struct TransportExecution 

pub struct TransportExecution {
    pub id: TransportExecutionId,
    pub delivery_attempt: Option<DomainRecordVersionRef>,
    pub state: TransportExecutionState,
    pub active_itinerary_revision: Option<ItineraryRevisionId>,
    pub current_leg_index: usize,
    pub estimated_arrival_at: Option<SimTime>,
    pub current_endpoint: Option<String>,
    pub revisions: Vec<ItineraryRevision>,
    pub legs: Vec<LegExecution>,
    pub handoffs: Vec<Handoff>,
    pub bookings: Vec<CapacityBooking>,
    pub saga: Option<DeliverySaga>,
}

Fields

id: TransportExecutionId

delivery_attempt: Option<DomainRecordVersionRef>

state: TransportExecutionState

active_itinerary_revision: Option<ItineraryRevisionId>

current_leg_index: usize

estimated_arrival_at: Option<SimTime>

current_endpoint: Option<String>

revisions: Vec<ItineraryRevision>

legs: Vec<LegExecution>

handoffs: Vec<Handoff>

bookings: Vec<CapacityBooking>

saga: Option<DeliverySaga>

Implementations

impl TransportExecution

pub fn new( id: TransportExecutionId, delivery_attempt: Option<DomainRecordVersionRef>, ) -> TransportExecution

pub fn install_initial_itinerary( &mut self, revision: ItineraryRevision, ) -> Result<(), TransportError>

pub fn reroute( &mut self, revision: ItineraryRevision, at: SimTime, ) -> Result<(), TransportError>

pub fn begin_saga( &mut self, delivery_attempt: DomainRecordVersionRef, operation_key: String, ) -> Result<(), TransportError>

pub fn start_current_leg(&mut self, at: SimTime) -> Result<(), TransportError>

pub fn complete_current_leg( &mut self, at: SimTime, endpoint: String, ) -> Result<bool, TransportError>

pub fn fail_current_leg( &mut self, reason: String, at: SimTime, ) -> Result<(), TransportError>

pub fn mark_arrival_pending(&mut self) -> Result<(), TransportError>

pub fn record_handoff(&mut self, handoff: Handoff) -> Result<(), TransportError>

pub fn custody_left_itinerary(&self) -> bool

Whether a terminal seizure has taken custody out of the itinerary.

Such an execution cannot fail or reroute a leg, arrive, settle successfully, book capacity, or record another handoff. Its owner closes it: an execution with a delivery saga through Self::reconcile_information with a failure, which leaves it Failed, and one without a saga through Self::cancel.

pub fn request_booking( &mut self, booking: CapacityBooking, ) -> Result<(), TransportError>

Adds one requested capacity booking to this execution.

The booking must name this execution, still be Requested, carry no allocation evidence, and have an identity unique within the execution. A terminal execution accepts no further bookings.

pub fn settle_arrival( &mut self, at: SimTime, endpoint: String, ) -> Result<(), TransportError>

Completes the final departed leg of an execution that carries no delivery attempt and settles it.

A movement that does not complete an information delivery has nothing to reconcile, so arrival is its terminal fact. An execution with a delivery attempt or saga must instead use Self::complete_current_leg, which enters ArrivalPending, and then Self::reconcile_information.

pub fn cancel(&mut self) -> Result<(), TransportError>

Cancels a non-terminal execution whose subject is not travelling.

No leg of the active itinerary may be departed (a leg in progress must first arrive or fail) and an arrival-pending execution must reconcile instead. Unstarted legs of the active itinerary become Cancelled; a delivery saga enters CompensationPending. Bookings are not changed: the caller closes them through CapacityBooking::transition.

pub fn completion_request( &self, ) -> Result<DeliveryCompletionRequest, TransportError>

pub fn reconcile_information( &mut self, outcome: ReconciliationOutcome, ) -> Result<(), TransportError>

Trait Implementations

impl Clone for TransportExecution

fn clone(&self) -> TransportExecution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransportExecution

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TransportExecution

fn deserialize<__D>( __deserializer: __D, ) -> Result<TransportExecution, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for TransportExecution

impl PartialEq for TransportExecution

fn eq(&self, other: &TransportExecution) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for TransportExecution

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for TransportExecution