Struct Medicine 

pub struct Medicine {
    pub id: String,
    pub name: String,
    pub dose: String,
    pub schedule: Schedule,
    pub prescription: Option<String>,
    pub until: Option<Date>,
    pub paused: bool,
    pub generic: String,
    pub strength: String,
    pub since: Option<Date>,
}

A medicine to take, and when.

Fields

id: String

name: String

Its brand name, or your own word for it: what reminders say. Never empty once saved (its generic name stands in), as Sioul 0.0.3 reads it.

dose: String

“1000 IU”, “1 tablet”.

schedule: Schedule

prescription: Option<String>

The prescription it comes with, by id.

until: Option<Date>

The last day it is taken; none for as long as it goes.

paused: bool

Stopped for now: no reminder.

generic: String

The generic name of its molecule, as typed (the INN, “levothyroxine”): what a doctor or a pharmacist reads, whatever the brand. Written only when given; Sioul 0.0.3 drops it at its next save.

strength: String

Its strength (“75 µg”, “500 mg per tablet”), apart from a take’s amount (“1 tablet”). Written only when given, as generic.

since: Option<Date>

The day it was first taken, when known: how long it has been taken. Written only when given, as generic.

Implementations

impl Medicine

pub fn short_name(&self) -> String

What reminders, the day’s list and a phone’s card call it: its name, else (a file written by hand) its generic name.

pub fn precise(&self) -> String

What it is, precisely, for whoever prescribes or hands it out: its name, then its generic name and strength (“Thyrolan — levothyroxine 75 µg”); the generic name alone when it is the name (“levothyroxine 75 µg”); the name and strength without a generic name.

pub fn amount_at(&self, time: Time) -> String

The amount said with a dose set for time of the day: the take’s own when the takes differ (none when that take has none), else the medicine’s dose.

pub fn takes(&self) -> Vec<Take>

Its takes, at set times each day, in time order, each with its amount (amount_at); a time that does not read is left out, as it never falls due. None for the other kinds.

pub fn usual(&self) -> String

The amount most of its takes have, the earliest first on a tie: what its form shows as its dose, each take saying its own only when it differs. Its dose when the takes do not differ.

pub fn takes_line(&self) -> String

Its takes in a line, in time order: “08:00 · 1 tablet, 20:00 · 2 tablets” (“12:00” alone for a take with no amount). What an older Sioul says with each dose when the takes differ (set_takes).

pub fn set_takes( &mut self, usual: &str, takes: &[Take], ) -> Result<(), TakeProblem>

Takes it at set times each day: takes, each with its own amount, or usual when it says none. The same amount for all: that is its dose, and amounts stays empty (the file as an older Sioul writes it). Amounts that differ: amounts holds every take’s, and its dose is the whole line (takes_line), so that an older Sioul, which reads the times alone, says every take’s amount with each dose rather than one that is wrong for some. The times are what they say, whatever the amounts.

Trait Implementations

impl Clone for Medicine

fn clone(&self) -> Medicine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Medicine

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Medicine

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Medicine

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Medicine

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 Medicine