Struct Senders 

pub struct Senders {
    pub safe: SenderList,
    pub neutral: SenderList,
    pub restricted: SenderList,
    pub blocked: SenderList,
    pub known: SenderList,
    pub contacts: Arc<Book>,
}

The four lists of who may reach you: safe, neutral, restricted and blocked, with your address books, their cards and categories, and the senders you let in (docs/porch.md, “Who may reach you, and when”). The most precise entry decides: the person’s own address or number; then their card (contact:<UID>); then its categories; then patterns (a domain, a prefix), the more precise first; then, neutral: let in through the screener, or in your address books; else a stranger. At one level, blocked before restricted before neutral before safe. An address marked safe stays safe in a domain you blocked; a friend you put on neutral stays neutral in a category you marked safe. Lists judge the sender’s address only, after forged mail was set aside: a message whose sender is not verified never changes them (porch.rs, trust.rs), and nobody is judged by the server or the domain another sender shares.

Fields

safe: SenderList

neutral: SenderList

restricted: SenderList

blocked: SenderList

known: SenderList

The senders you let in through the screener: neutral, never strangers.

contacts: Arc<Book>

Your address books: who is in them, their cards’ categories.

Implementations

impl Senders

pub fn load(config: &Config) -> Senders

The lists, the senders you let in, and every address book (kept while their files do not change).

fn lists(&self) -> [(Standing, &SenderList); 4]

The lists, in the order ties are decided.

pub fn region(&self) -> Option<&'static Region>

The country numbers written without one are read as.

pub fn category_standing(&self, name: &str) -> Option<Standing>

The list that names this category, if any (as compared, category_key).

pub fn card_standing(&self, uid: &str) -> Option<Standing>

The list that names this card itself (contact:<UID>), if any.

fn card_choice(&self, card: &BookCard) -> Option<Standing>

A card’s own list: its contact:<UID> line; else the one list that holds every address of it, which is how “Their mail” chose for a person before cards were on the lists themselves.

pub fn person_standing(&self, id: &str) -> Option<Standing>

A person’s own list, by their card’s UID or file (card_choice): what their card’s chooser shows.

fn card_name(&self, cards: &[usize]) -> String

The name of the first of these cards.

fn by_card(&self, cards: &[usize]) -> Option<Judged>

One of these cards on a list, the one whose list comes first in the order ties are decided.

fn by_category(&self, cards: &[usize]) -> Option<Judged>

A category of these cards on a list.

fn by_book(&self, cards: &[usize]) -> Option<Judged>

In your address books on no list: neutral, by their card’s name.

pub fn judge(&self, address: &str) -> Judged

Who an address is, and why: its own entry; else its card’s; else the card’s categories; else the most precise pattern; else neutral when you let it in or a card holds it; else a stranger. At one level, blocked before restricted before neutral before safe.

pub fn who(&self, address: &str) -> Who

Who an address is.

pub fn who_of(&self, card: &Card) -> Who

Who a message’s sender is; one without an address is a stranger.

pub fn judge_number(&self, number: &str) -> Judged

Who a phone number is, and why: its own entry; else its card’s; else the card’s categories; else the longest prefix on a list; else neutral when a card holds it; else a stranger. A number Sioul cannot read, or none (a hidden number), is a stranger here: calls give hidden numbers their own row (attention::Person::Hidden).

pub fn judge_name(&self, name: &str) -> Option<Judged>

Who a name is, for messages whose sender is known by name only (a chat app’s notification): a card with this very name (name_key), its own entry, else its categories, else neutral; between two cards of one name, the one whose list comes first in the order ties are decided. None when no card has that name: the caller decides.

pub fn judge_card(&self, id: &str) -> Option<Judged>

Who a card is, by its UID or its file: its own entry, else its categories, else neutral. None for a card no address book holds.

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

Every whole number known, on a card or on a list, by its key, with who it is (judge_number); prefixes aside (prefixes). Strangers are not among them: a number nobody knows is one.

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

The prefixes on the lists (tel:+3319900*), each with the list it is on: for a number no card and no entry of its own names.

Trait Implementations

impl Clone for Senders

fn clone(&self) -> Senders

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Senders

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

Formats the value using the given formatter.

impl Default for Senders

fn default() -> Senders

Returns the “default value” for a type.