Enum ClaimState 

pub enum ClaimState {
    Held,
    Released,
    Expired(String),
    Conflicted(String),
}

A claim’s standing, and — where it ended or lost — what ended it. The two variants that carry a string exist because the bare verdict is not actionable: a worker told its claim expired needs to know whether its session closed or its runtime stopped beating, and one told its claim is conflicted needs the key of the claim that beat it, which is the same key on every runtime.

use majordomus_cli::mesh::state::ClaimState;

assert!(ClaimState::Held.is_live());
assert!(ClaimState::Conflicted("s/c1".into()).is_live(), "still held, and not the winner");
assert!(!ClaimState::Released.is_live());

// the detail travels with the verdict, so a reader is never left asking who won
let value = serde_json::to_value(ClaimState::Conflicted("s/c1".into())).unwrap();
assert_eq!(value["state"], "conflicted");
assert_eq!(value["detail"], "s/c1");

Variants

Held

Live; for an exclusive claim, the winner of its scope.

Released

Released by its holder.

Expired(String)

Ended without a release: the holder’s session closed or its runtime expired.

Conflicted(String)

Live, exclusive, and beaten to its scope by the claim whose key this names.

Implementations

impl ClaimState

pub fn is_live(&self) -> bool

Whether the claim is live (held or conflicted). A conflicted claim counts as live because it has not gone away: its holder is still working, and the next claim over that scope has to meet it too. Only a release, a closed session or an expired runtime ends a claim.

use majordomus_cli::mesh::state::ClaimState;

assert!(ClaimState::Held.is_live());
assert!(ClaimState::Conflicted("s/c1".into()).is_live(), "losing is not ending");
assert!(!ClaimState::Released.is_live());
assert!(!ClaimState::Expired("its runtime stopped beating".into()).is_live());

Trait Implementations

impl Clone for ClaimState

fn clone(&self) -> ClaimState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClaimState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClaimState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ClaimState

impl JsonSchema for ClaimState

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 PartialEq for ClaimState

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

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 ClaimState