Struct Layover 

pub struct Layover {
    pub id: LayoverId,
    pub agent: AgentName,
    pub booked_by: ItineraryId,
    pub waiting_for: String,
    pub handover: Handover,
    pub booked_at: Timestamp,
    pub due_at: Timestamp,
    pub checks: u32,
    pub max_checks: u32,
    pub standing: Standing,
}

Work set down now to be picked up later.

Fields

id: LayoverId

Identifier.

agent: AgentName

Which agent the resumed work should go to.

booked_by: ItineraryId

The itinerary that booked it.

waiting_for: String

One line saying what this is waiting for, for a human reading a list.

handover: Handover

What the resumed run needs to know.

booked_at: Timestamp

When it was booked.

due_at: Timestamp

The soonest it should be picked up.

checks: u32

How many times it has been picked up and set down again.

A layover waiting on a human is checked repeatedly and usually finds nothing. Counting gives the difference between “waiting patiently” and “waiting forever”, which is the difference between a follow-up and a leak.

max_checks: u32

How many checks it may have before it is given up on.

standing: Standing

Where it has got to.

Implementations

impl Layover

pub fn book( agent: AgentName, booked_by: ItineraryId, waiting_for: impl Into<String>, handover: Handover, booked_at: Timestamp, due_at: Timestamp, max_checks: u32, ) -> Self

Books a layover.

pub fn is_due(&self, now: Timestamp) -> bool

Returns true when this should be picked up at now.

pub fn set_down_again(&mut self, now: Timestamp)

Records that it was picked up and the thing it waits for had not happened.

Each check pushes the next one further out, so a layover waiting on a human does not poll at the same rate on day six as on minute one. Backing off is what makes a long wait affordable — the alternative is paying for a run every few minutes to be told nothing has changed.

pub fn resumed(&mut self)

Records that a new itinerary has been opened for this work.

pub fn cancel(&mut self)

Gives up on it, because the work it was following stopped mattering.

pub fn minutes_until_due(&self, now: Timestamp) -> Option<i64>

How long until it is next due, in whole minutes, or None when it is due now.

Trait Implementations

impl Clone for Layover

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Layover

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Layover

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Layover

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Layover

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Layover