Enum Disposition 

pub enum Disposition {
    Integrated,
    Published,
    LocalOnly,
    Uncommitted,
}

Where the work a holding carries can be reached from.

The order is the order of safety: everything above Disposition::LocalOnly is reachable by somebody who is not the worker that made it.

use majordomus_cli::convergence::Disposition;

// declared in the order of safety, so the derived order says which is worse
assert!(Disposition::Integrated < Disposition::Published);
assert!(Disposition::Published < Disposition::LocalOnly);
assert_eq!(serde_json::to_string(&Disposition::LocalOnly).unwrap(), "\"local_only\"");

Variants

Integrated

The trunk reaches it: it is in the repository’s own history.

Published

A remote reaches it: another checkout can fetch it, and it survives this disk.

LocalOnly

Committed here and nowhere else. One disk away from being lost.

Uncommitted

Not committed at all: files in a work tree, or a stash entry.

Implementations

impl Disposition

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

The word this disposition is reported under — the same word its serialisation carries, so a tally keyed by it and a holding carrying it agree.

use majordomus_cli::convergence::Disposition;

assert_eq!(Disposition::LocalOnly.as_str(), "local_only");
let json = serde_json::to_string(&Disposition::Uncommitted).unwrap();
assert_eq!(json, format!("\"{}\"", Disposition::Uncommitted.as_str()));

pub fn at_risk(&self) -> bool

This holding’s work exists on one disk only: the verdict refuses over exactly these.

use majordomus_cli::convergence::Disposition;

let risky: Vec<_> = [
    Disposition::Integrated,
    Disposition::Published,
    Disposition::LocalOnly,
    Disposition::Uncommitted,
]
.into_iter()
.filter(Disposition::at_risk)
.collect();
assert_eq!(risky, [Disposition::LocalOnly, Disposition::Uncommitted]);

Trait Implementations

impl Clone for Disposition

fn clone(&self) -> Disposition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Disposition

impl Debug for Disposition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Disposition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Disposition

impl JsonSchema for Disposition

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Ord for Disposition

fn cmp(&self, other: &Disposition) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Disposition

fn eq(&self, other: &Disposition) -> 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 PartialOrd for Disposition

fn partial_cmp(&self, other: &Disposition) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Disposition

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 Disposition