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 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