Struct Health 

pub struct Health {
    pub prescriptions: Vec<Prescription>,
    pub medicines: Vec<Medicine>,
    pub movement: Movement,
    pub chats: ChatLimit,
    pub errands_list: String,
    pub needs: Needs,
}

Everything the health page keeps: $XDG_DATA_HOME/sioul/health.toml.

Fields

prescriptions: Vec<Prescription>

medicines: Vec<Medicine>

movement: Movement

chats: ChatLimit

errands_list: String

Where the pharmacy and the renewals go as tasks: a list on your server (“account/id”), so your phone has them; “” for your usual list.

needs: Needs

Meals, naps and the night: times kept free, set first (needs).

Implementations

impl Health

pub fn default_path() -> PathBuf

pub fn load(path: &Path) -> Health

The health file; empty when there is none. One that no longer reads (edited by hand, written by a newer Sioul on another computer) is copied aside first, as health.toml.unreadable: saving over it then loses no medicine.

pub fn save(&self, path: &Path) -> Result<(), String>

Written next to its place, then moved: never half a file. Yours alone. Under the file’s lock, which the sharing takes too.

pub fn change<R>( path: &Path, change: impl FnOnce(&mut Health) -> Result<R, String>, ) -> Result<R, String>

Read, changed by change and written back, all under the file’s lock, which the sharing takes too: a change is set over the file as it is then, never over a copy read earlier. Returns what change returns.

pub fn new_id(&self, name: &str) -> String

A new id among the others, from a name.

pub fn doses(&self, start: &Zoned, end: &Zoned) -> Vec<Dose>

Every dose from start to end, of the medicines taken then, each with its take’s amount (Medicine::amount_at).

pub fn amount_of(&self, key: &str, zone: &TimeZone) -> Option<String>

The amount of the dose key (<medicine>@<Unix seconds>), as its reminder said it: its take’s, found at its time; else (a dose the schedule no longer has, moved or changed since) the amount at its time of day on this clock. None for a medicine no longer here.

pub fn taken_at(&mut self, key: &str, at: i64) -> Option<(i64, i64)>

A dose taken at at (Unix seconds): for a medicine taken every few hours, the next doses come that many hours after it, early or late, so that the hours between two doses are kept. Medicines at set times keep theirs. Returns where the doses started before and after they moved, to put them back if the mark is taken back; none when nothing moved.

pub fn mend_shifts(&mut self, state: &HealthState) -> bool

The moves of medicines taken every few hours, mended: a dose taken late moves the next ones (taken_at), inside the medicine, which travels whole between devices; changed meanwhile on another device (its note, its dose’s text), the medicine there, its start as it was, can win everywhere, and the next dose would come early, the hours between doses broken (review of 5 October 2026, F23). Each move is kept with its mark (HealthState::moved), which travels apart: a medicine whose start is one a mark moved it from goes again where that mark moved it, its other changes kept. Two moves from one start (the second marked on a device the first had not reached yet): the latest mark’s, by when it was taken (review of 10 October 2026, R10). Returns whether one moved.

pub fn taken_back(&mut self, key: &str, before: i64, after: i64) -> bool

A mark taken back: the doses it moved go back where they were, unless they moved again since. Returns whether they did.

pub fn errands(&self) -> Vec<Errand>

The pharmacy and the doctor, as errands: when a prescription’s medicines run out (two days before) and when it ends (two weeks before).

Trait Implementations

impl Clone for Health

fn clone(&self) -> Health

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Health

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

Formats the value using the given formatter.

impl Default for Health

fn default() -> Health

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Health

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Health

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Health

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 Health