Enum Landed 

pub enum Landed {
    Yes {
        evidence: LandingEvidence,
    },
    InPart {
        evidence: LandingEvidence,
        unlanded: NonZeroUsize,
    },
    No,
    Unknown,
}

Whether the work reached the base, and — where it did — what says so.

The evidence travels inside the answer rather than beside it, so a yes with nothing behind it and a no naming a landing commit are both unrepresentable: only tiers 1 to 3 answer yes or in-part, and only the content comparison answers the other two.

Variants

Yes

It reached the base, and this is the record that says so.

Fields

evidence: LandingEvidence

Which tier decided it, and the commit that is the evidence.

InPart

A tier found the landing, and the branch has gone on since: the landing commit is on the base and does not account for everything the branch now carries.

Two answers in one, because both are true and each has its own reader. There is work left to publish — so this is not a landing for is_landed, the row keeps its resume command, and recoverable keeps the row. And the work that did land reached the base at the commit named here — so a release is sequenced against it rather than held on a question nothing will ever close.

What a retried dispatch leaves behind, which is the ordinary shape of a branch on a host that retries: a session lands, the next session continues the same name, and the commits it adds are the ones the landing never saw.

Fields

evidence: LandingEvidence

Which tier found the landing, and the commit that is the evidence — the same value the tier would have answered yes with.

unlanded: NonZeroUsize

How many commits the branch holds that the landing does not integrate.

The count is what makes this readable as an amount of work rather than as a qualifier: one commit above a landing is a follow-up, and thirty is a branch whose landing says almost nothing about it.

Never zero, and the type is what says so rather than a rule somebody has to remember: a landing with nothing above it is a landing, which is Landed::Yes. So a document claiming an in-part landing of zero unlanded commits does not deserialize at all, for the reason every other contradiction in this crate’s serialized shapes is refused where it is read.

No

Nothing records that it reached the base, and the base does not carry what it changed. The last tier — a comparison of content, not a record — so this is “there is work here and nothing says it landed” rather than a proof that it did not.

Unknown

Nothing records that it reached the base, and the base already carries everything it changed.

Undecidable from history, and deliberately not a no: it is what a branch that landed with no change request and not through this crate leaves behind, and it is also what somebody else making the same change leaves behind.

The default, and the only one that could be: a document written before there was a field to write said nothing about landing, and nothing is not “no”.

Implementations

impl Landed

pub fn is_landed(&self) -> bool

Whether the work is finished: it reached the base and the branch holds nothing the landing did not carry.

The question every caller acts on is “is there work left to publish”, and this is its inverse — which is why Landed::InPart answers false here while naming a landing commit. A row whose branch went on after its landing keeps the command that lands the rest.

pub fn tier(&self) -> &'static str

The tier that decided it, in the words a rendering names it by — which are prose rather than the kebab-case the answer serializes as, because the one place they are read is a sentence.

Trait Implementations

impl Clone for Landed

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 Landed

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

Formats the value using the given formatter.

impl Default for Landed

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Landed

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Landed

impl PartialEq for Landed

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Landed

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 Landed