Struct Balance 

pub struct Balance {
    pub started: usize,
    pub closed: usize,
    pub open: usize,
    pub unaccounted: i64,
    pub agrees: bool,
    pub note: String,
}

What the ledger says about episode lifecycle against what the store holds.

The invariant ADR 0052 asks for, stated as arithmetic a person can check: every episode that started either closed or is still open. When started exceeds closed + open, the difference is episodes whose close was never recorded — the shape of the outage that ADR describes, where events kept arriving and the records they should have produced did not.

The sign matters and the two directions mean opposite things. Positive unaccounted is the outage: episodes that started, are not open, and produced no closed record — work that happened and left nothing behind. Negative is ordinary bookkeeping: the ledger was rotated, or a record was committed from a checkout whose ledger lines are not in this one, so there are more records than started lines to account for them.

use majordomus_cli::capability::builtin::lifecycle::Balance;
use serde_json::json;

let of = |started, closed, open, unaccounted, agrees| -> Balance {
    serde_json::from_value(json!({
        "started": started, "closed": closed, "open": open,
        "unaccounted": unaccounted, "agrees": agrees, "note": "as measured",
    })).unwrap()
};

// the good case: every episode that started either closed or is still open
let sound = of(40, 37, 3, 0, true);
assert_eq!(sound.started as i64 - sound.closed as i64 - sound.open as i64, sound.unaccounted);
assert!(sound.agrees);

// the outage ADR 0052 describes: four closes that were never recorded
let lost = of(40, 33, 3, 4, false);
assert!(lost.unaccounted > 0 && !lost.agrees);

// and a rotated ledger, which is not a fault in either half
let rotated = of(2, 37, 3, -38, false);
assert!(rotated.unaccounted < 0, "more records than lines to account for them");

Fields

started: usize

session.started lines in the ledger.

closed: usize

session.closed lines.

open: usize

Open records in the store.

unaccounted: i64

started - closed - open. Zero is the good case; negative means the ledger was rotated under the records, which is ordinary.

agrees: bool

Whether the three agree.

note: String

What the numbers mean, in words.

Trait Implementations

impl Clone for Balance

fn clone(&self) -> Balance

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Balance

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Balance

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Balance

impl JsonSchema for Balance

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 Balance

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

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 Balance