Struct DoseReminders 

pub struct DoseReminders {
    pub dose: BTreeMap<String, BTreeMap<String, Tried>>,
}

What each device did to remind each dose, by the dose’s key, then the device’s id.

Fields

dose: BTreeMap<String, BTreeMap<String, Tried>>

Implementations

impl DoseReminders

pub fn default_path() -> PathBuf

pub fn read(path: &Path) -> Result<DoseReminders, Unsound>

The entries as written, or why they cannot be trusted. Never empty in place of a file that does not read, nor of one lost after it was written here (health::witnessed): a device’s word that it sent a notice would look never said.

pub fn update<T>( path: &Path, now: i64, me: &str, change: impl FnOnce(&mut DoseReminders) -> T, ) -> Result<T, Problem>

The entries changed by change, one writer at a time, read again just before, so that nothing written meanwhile is written over; me, this device’s id: its own entries past KEPT_DAYS dropped.

fn save(&mut self, path: &Path, now: i64, me: &str) -> Result<(), String>

Saved, this device’s own entries past KEPT_DAYS dropped, by its clock (each device takes its own out, and the sharing carries that: a clock days ahead would empty the others’ else, the sixth review’s L3, R8); every device’s entries STALE_DAYS after their dose, counted not by this clock alone but by the earlier of it and the newest dose the other devices’ entries name, so that a clock a month ahead, here or on one other device, takes no entry of today’s out (the ninth review’s P1). Use update: it holds the lock.

pub fn forget(&mut self, gone: &[String]) -> bool

The entries of devices that stopped sharing (their own entry says so), taken out by any device that reads it: the one exception to “each its own” but STALE_DAYS (the seventh review’s L5). A device only forgotten here keeps them: forgetting is one device’s view, and its entries may still be today’s for the others (the eighth review’s L6). Whether any was.

pub fn holds_any(&self, devices: &[String]) -> bool

Whether any entry of these devices is here.

pub fn of(&self, key: &str, device: &str) -> Option<Tried>

device’s entry for the dose key, if it wrote one.

pub fn entry(&mut self, key: &str, device: &str) -> &mut Tried

device’s entry for the dose key, made when missing.

pub fn shown(&self, key: &str) -> bool

Whether a device’s notice of the dose was shown, as far as read here.

pub fn maybe_elsewhere(&self, key: &str, me: &str) -> Option<i64>

When the latest notice of the dose another device than me sent went, not known shown; none.

pub fn maybe_by(&self, key: &str, me: &str) -> Option<(String, i64)>

The device whose notice of the dose went latest, not known shown, other than me, and when; none.

pub fn maybe_anywhere(&self, key: &str) -> Option<i64>

When a device’s notice of the dose went without being known shown: a reminder that may not have shown (its question on the past says so).

Trait Implementations

impl Clone for DoseReminders

fn clone(&self) -> DoseReminders

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DoseReminders

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

Formats the value using the given formatter.

impl Default for DoseReminders

fn default() -> DoseReminders

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DoseReminders

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DoseReminders

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for DoseReminders

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 DoseReminders