Struct Needs 

pub struct Needs {
    pub meals_on: bool,
    pub meals: Vec<Block>,
    pub naps_on: bool,
    pub naps: Vec<Block>,
    pub sleep_on: bool,
    pub sleep: Sleep,
    pub heads_up: u32,
    pub later: u32,
}

Meals, naps and the night, each kind on or off; three meals when meals are first turned on, one of them in the evening (Murphy et al. 2010).

Fields

meals_on: bool

meals: Vec<Block>

naps_on: bool

naps: Vec<Block>

sleep_on: bool

sleep: Sleep

heads_up: u32

Minutes between the heads-up and the time it starts.

later: u32

Minutes “Later” moves a block, today only.

Implementations

impl Needs

pub fn rebased(&self, shown: &Needs, current: &Needs) -> Needs

The settings’ change, from what the page showed (shown) to what it sends (self), set over the settings as the file holds them now (current): each field the page changed, the page’s; the others as they are now; the meals and naps as lists (settings::rebased), so that one another device added meanwhile stays.

impl Needs

pub fn kept_around( &self, now: &Zoned, days: &Days, held: &[(i64, i64)], ) -> Vec<Kept>

What is kept free around now, in order of start: today’s and tomorrow’s meals and naps (those added for the day too), and the nights ending this morning, starting tonight and tomorrow night; each as its day has it (days: moved, times changed), meals pushed past the events in held (their times with their margins, Unix seconds). A block taken out that day is not there; a quiet one is (it is still kept: only its notices are off). For whatever asks whether a meal, a nap or the night is on at some time (the hours’ states): kept stable.

pub fn kept_on( &self, date: Date, zone: &TimeZone, shift: &dyn Fn(&str) -> i64, ) -> Vec<Kept>

What is kept free on date, in order: each meal and nap on that weekday, and the nights touching it (the one ending that morning, the one starting that evening). shift moves a block that day only, in minutes, by its key (“Later”).

pub fn kept_with( &self, date: Date, zone: &TimeZone, days: &Days, shift: &dyn Fn(&str) -> i64, ) -> Vec<Kept>

The same with each day’s changes (days): a block moved, its times changed, quiet (no notice) or off that day, and those added that day. Notices are said by the day a block starts on: the night ending this morning said its own yesterday, unless its bedtime was after midnight.

pub fn blocks_of( &self, date: Date, zone: &TimeZone, days: &Days, shift: &dyn Fn(&str) -> i64, ) -> Vec<Kept>

The blocks that are date’s own, in order: its meals and naps, those added that day, and the night starting that evening (its bedtime after midnight: the next morning). What the Health page lists for a day.

fn day_blocks( &self, date: Date, zone: &TimeZone, days: &Days, shift: &dyn Fn(&str) -> i64, ) -> Vec<Kept>

date’s meals and naps on that weekday, as changed that day, and those added that day.

fn night_of( &self, night: Date, zone: &TimeZone, days: &Days, shift: i64, ) -> Option<Kept>

The night starting the evening of night (its bedtime after midnight: the next morning), as changed that day, moved shift minutes; none when off that day.

pub fn alarm_of( &self, night: Date, zone: &TimeZone, days: &Days, ) -> Option<Alarm>

The alarm at the end of the night starting the evening of night, as that day has it (its waking moved or changed): when the weekday of the morning it ends on is ticked (Sleep::alarm). None when no night is set, when it is taken out that day, or when that weekday is not ticked; skipped when “No alarm” was asked for that night. A night “Not that day” (quiet) still rings. Zoned: the waking is on the clock in zone, whatever the change of hour that night.

pub fn wakings(&self, now: &Zoned, days: &Days, ahead: i64) -> Vec<Alarm>

The alarms that ring after now, in order, until the same time ahead days later (days on the clock, not 24 hours): each night’s end, as its day has it (alarm_of), those skipped left out.

pub fn past_events_on( &self, date: Date, zone: &TimeZone, days: &Days, held: &[(i64, i64)], ) -> BTreeMap<String, i64>

The day’s meals pushed past the events they would fall in (held: the events’ times with their margins, Unix seconds), as minutes by key: to the end of the event, by whole five minutes; a meal pushed into a next event goes past it too. Not a meal whose time you set for that day, nor one added that day: you chose it, the day in view.

pub fn past_events( &self, date: Date, zone: &TimeZone, moved: &BTreeMap<String, i64>, held: &[(i64, i64)], ) -> BTreeMap<String, i64>

Moves given as minutes by key (moved), each meal pushed past the events it would fall in (held: their times with their margins, Unix seconds): from those moves, later only, to the end of the event, by whole five minutes; a meal pushed into a next event goes past it too. The days’ changes go through past_events_on.

pub fn busy_on( &self, date: Date, zone: &TimeZone, shift: &dyn Fn(&str) -> i64, ) -> Vec<(i64, i64)>

The spans kept free on date, for the plan: no task in them.

pub fn lengths( &self, date: Date, key: &str, days: &Days, ) -> Option<(u32, u32, u32)>

A block’s lengths on date, as that day has them, in minutes: it lasts, to get it ready (the night: to wind down), to come back after it. None for a key that names no block.

pub fn change_day( &self, days: &mut Days, date: Date, edit: &DayEdit, now: &Zoned, held: &[(i64, i64)], ) -> Result<(), DayProblem>

edit made on days, for date only, as the Health page asks: “later” (by minutes, else as many as “Later” moves by), “move” (to start at from), “times” (from–to; a meal’s minutes to get it ready, a nap’s to come back, the night’s bedtime), “quiet” and “loud” (no notice that day, or back), “off” and “on” (taken out that day, or put back; one added that day goes), “usual” (as usual that day), “add” (one for that day only, a meal or a rest); the night’s “no-alarm” and “alarm” (no alarm the morning it ends, or back). A day before now’s stays as it was, but for the alarm of a night still going on (after midnight, yesterday’s). Moves count from the block as the page shows it (meals pushed past the events in held), and are kept as times on the clock; lengths only where they differ from the usual ones.

pub fn long_gaps(&self) -> Vec<(String, String)>

Meals planned more than four hours apart, as (end of one, start of the next) on a usual day: said quietly where they are set, never in a notice (Murphy et al. 2010: rarely more than four hours between).

Trait Implementations

impl Clone for Needs

fn clone(&self) -> Needs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Needs

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

Formats the value using the given formatter.

impl Default for Needs

fn default() -> Needs

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Needs

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Needs

impl PartialEq for Needs

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Needs

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 Needs