Struct Attention 

pub struct Attention {
    cells: [[Level; 9]; 36],
    sources: BTreeMap<String, [Level; 9]>,
    names: BTreeMap<String, String>,
}

The matrix: a level in each cell, as set; and the sources’ own rows, an app’s or a conversation’s on a phone, by id (app.<package>, conversation.<key>), each with its name when written with one.

Fields

cells: [[Level; 9]; 36]

sources: BTreeMap<String, [Level; 9]>

names: BTreeMap<String, String>

Implementations

impl Attention

pub fn usual() -> Attention

What Sioul does unless you change it (usual).

pub fn of(config: &Config) -> Attention

As the configuration says: the usual cells; while no [attention] is written, what the older keys changed (seeded); then each row’s words. A fixed cell, a value not offered there and a word not understood are left aside; of two words for one column, the later counts.

pub fn cell(&self, row: Row, column: Column) -> Level

pub fn set( &mut self, row: Row, column: Column, level: Level, ) -> Result<(), String>

A cell changed; refused when it is fixed, or when the value is not one it may take (choices).

pub fn words(&self, row: Row) -> Vec<String>

A row as the configuration writes it, whole: “work” for at once, “sleep:later” for another value.

pub fn changes_from(&self, other: &Attention) -> usize

How many cells differ from another matrix’s (a preset’s); the sources’ own rows aside, which no preset sets.

pub fn source(&self, id: &str) -> Option<[Level; 9]>

A source’s own row (app.<package>, conversation.<key>): its nine cells; none while every one says as usual.

pub fn sources(&self) -> &BTreeMap<String, [Level; 9]>

The sources’ rows set, by id.

pub fn source_name(&self, id: &str) -> &str

The name a source’s row was written with (an app’s, for your other devices, which never saw it); “” when none.

pub fn set_source( &mut self, id: &str, column: Column, level: Level, ) -> Result<(), String>

A source’s cell changed; refused when the id names no source, or the value is not one a source’s cell takes (SOURCE_CHOICES). A row as usual everywhere is no row: taken out.

pub fn name_source(&mut self, id: &str, name: &str)

A source’s name, kept beside its row (“” takes it out).

pub fn source_words(&self, id: &str) -> Vec<String>

A source’s row as the configuration writes it: its cells set (“work” for at once, “admin:later”), as usual unsaid, then its name (“name=Discord”); nothing when as usual everywhere.

pub fn has_sources(&self, ids: &[String]) -> bool

Whether one of these sources has a row set: a notification from them reads it.

fn source_cells(&self, ids: &[String]) -> Vec<[Level; 9]>

The rows set among these sources, the most precise first.

fn base_at(&self, base: Base, column: Column, now: &Now) -> Level

What a row, or a person on a channel, gives at one column, as level and person read it (= and ☆ resolved, “Nothing at all” holding the states’ rows in Free time): what a source’s “as usual” stands for.

fn over(&self, base: Base, sources: &[[Level; 9]], now: &Now) -> (Level, bool)

A row, or a person, read with sources’ rows over it (sources, the most precise first: a conversation’s, then its app’s): at each column the first cell set, else the row’s own (base_at); then as level reads a moment, the least strict of the times, the stricter of that and each layer that holds. With it, whether a source’s cell said any of the columns read now.

fn lent(&self, row: Row, column: Column, week: Week) -> Level

A row’s cell at a time column, lent as the week says for the people’s rows: while admin has no hours of its own, work time takes admin’s cell too; while work has none, admin time takes work’s (areas::in_view).

pub fn level(&self, row: Row, now: &Now) -> Level

A row now: the least strict of the time’s columns, then the stricter of that and each layer that holds. A state’s row waits in a Free time of “Nothing at all”. Always through’s own values read here as what the row alone lets through (= waits, ☆ comes); person reads them against a person’s own row.

pub fn person( &self, channel: Channel, person: Person, always: bool, now: &Now, ) -> Level

Someone on a channel now: the blocked never (blocked beats Always through); on the Always through list, that row, its = read as their own row, its ☆ as a layer that does not hold them; else their own row.

pub fn listed(&self, person: Person, always: bool, now: &Now) -> bool

A call after the fact (declined, on the Porch’s list; a missed call’s notification): when its caller’s Calls row lets them through now (docs/attention.md, Q23); a row that rings at no time at all (strangers, as usual) in work and admin time, the Porch’s own hours, so that no call is never listed. The blocked never.

fn meets( &self, channel: Channel, person: Person, area: Area, week: Week, ) -> bool

Whether a person’s row lets them through at some time of the week that an area is for: when none, the area holds nothing back for good.

impl Attention

pub fn decide(&self, event: &Event, now: &Now) -> Output

What comes of an event now, step by step (docs/attention.md, §2): the blocked first, then the content, the floors, the exceptions, the matrix, what the source is for, the named holds. Which device tells it and how stays the caller’s (§8).

pub fn mail( &self, t: &Triaged, senders: &Senders, always: &People, area: Area, now: &Now, ) -> Output

A message as the Porch judged it, now: its sender’s row as the Porch weighs it (set aside or unproven, a stranger’s), Always through when the list holds its proven address, what the address it came to is for. Shown says whether the Porch shows it now, told whether new mail’s notification may name it (its lane aside: mailnote::never).

fn own(&self, kind: Kind, event: &Event, now: &Now) -> Output

fn letter( &self, who: Who, always: bool, lane: Lane, event: &Event, now: &Now, ) -> Output

fn call( &self, who: Option<Who>, always: bool, emergency: bool, repeat: bool, now: &Now, ) -> Output

fn message( &self, via: Channel, who: Who, group: bool, always: bool, event: &Event, now: &Now, ) -> Output

fn site( &self, call: bool, live: bool, named: Option<Who>, event: &Event, now: &Now, ) -> Output

impl Attention

pub fn silence_at(&self, now: &Now, phone: Phone) -> Silence

What a mode lets through at a moment (Now): as level reads it, the times together the least strict, a layer (do-not-disturb over the time now) the stricter, “Nothing at all” holding the states’ rows. Calls: where this phone screens them, every contact’s, Sioul having declined the others already; else the starred, Android’s nearest to Always through; anyone’s while “Let every call through” holds (Now::through), so that the mode lets ring what the screening lets through. Messages: the starred when the matrix lets anyone write then, never wider, though Sioul may hold other apps’ notifications: Android sounds a notification before any listener hears of it (docs/android.md, “Sound”), so a contact’s message let through the mode, then held by Sioul, would ring once; the mode alone keeps a held message silent.

pub fn silence( &self, columns: &[Column], nothing: bool, phone: Phone, ) -> Silence

The same for columns (the pause’s, Free time’s, sleep’s; a layer, the switch’s): the times among them together, the layers above them, as silence_at reads them, every hours set. A layer alone says what it lets through by itself.

Trait Implementations

impl Clone for Attention

fn clone(&self) -> Attention

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Attention

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

Formats the value using the given formatter.

impl Default for Attention

fn default() -> Attention

Returns the “default value” for a type.

impl Eq for Attention

impl PartialEq for Attention

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Attention