Struct Ledger 

pub struct Ledger {
    pub held: BTreeMap<String, Held>,
    pub apps: BTreeMap<String, SeenApp>,
    pub conversations: BTreeMap<String, SeenTalk>,
    pub sites: BTreeMap<String, SeenSite>,
    pub back: Vec<Back>,
    pub heard: i64,
    pub released: i64,
    pub released_by: BTreeMap<String, i64>,
    pub applied: BTreeMap<String, i64>,
    pub released_through: i64,
    pub ahead: BTreeMap<String, i64>,
}

What Sioul held and saw, on this phone ($XDG_STATE_HOME/sioul/app-notes-seen.toml).

Fields

held: BTreeMap<String, Held>

Held now, by key_hash.

apps: BTreeMap<String, SeenApp>

conversations: BTreeMap<String, SeenTalk>

sites: BTreeMap<String, SeenSite>

back: Vec<Back>

heard: i64

When the listener last heard from Android (Unix seconds): the access works.

released: i64

The latest release applied before releases were kept by device (the build of 20 October 2026): every device’s stamps up to it count as applied. Never written again.

released_by: BTreeMap<String, i64>

The latest release applied, by the device that asked it (milliseconds, its stamp: everywhere::Switch::release_stamps): each device’s stamps applied once, apart, so that one far ahead never stands in the way of another’s (review of part 3, F3).

applied: BTreeMap<String, i64>

The stamp each of those marks was applied for (milliseconds, as it was asked), when it was ahead of this phone’s clock: applied once, though the mark is the phone’s now (check of a23cf0c, C-1).

released_through: i64

What the releases let through: what was held at or before then (Unix seconds, this phone’s clock; a stamp ahead of it read as its own now when applied, never releasing what is held after).

ahead: BTreeMap<String, i64>

Stamps passed over, more than RELEASE_AHEAD ahead of this phone’s clock when first met, by device: said once in the log, and never applied later, when the phone’s clock comes within a day of them (review of part 3, R-2).

Implementations

impl Ledger

pub fn apply_releases( &mut self, stamps: &[(String, i64)], now: i64, ) -> (bool, Vec<String>)

The releases asked (stamps, by device, milliseconds, each device’s clock), applied at now (Unix seconds), each device’s once: whether one is new, and the devices whose stamp is passed over now, too far ahead (said once). What was held at or before a stamp’s time, or before now for a stamp ahead of this phone’s clock, then comes back (released_before). Never during a pause: the caller waits (F5).

pub fn released_before(&self, held: &Held) -> bool

Whether a notification held now was first held at or before the last release applied.

pub fn default_path() -> PathBuf

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

As kept; empty when missing or unreadable (what was held comes back at its time all the same).

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

pub fn note( &mut self, p: &Posted, kind: &Kind, who: Option<Who>, admitted: bool, area: Option<Area>, decision: &Decision, now: i64, )

A notification decided: the app, its conversation or site seen; held, kept to be worked out again.

pub fn came_back(&mut self, hash: &str, now: i64)

A held notification Android brought back and that comes now: no longer held, and said on the Porch with what came back with it.

pub fn returning(&self, hash: &str, now: i64) -> bool

Whether this notification is one Sioul held that Android brings back now (or a little before its time).

pub fn forget_old(&mut self, now: i64, choices: &Choices)

The old forgotten: held marks long past their time (the app took the notification away meanwhile), apps, sites and conversations not seen for weeks (unless chosen for), what came back yesterday.

Trait Implementations

impl Clone for Ledger

fn clone(&self) -> Ledger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ledger

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

Formats the value using the given formatter.

impl Default for Ledger

fn default() -> Ledger

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Ledger

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Ledger

impl PartialEq for Ledger

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Ledger

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 Ledger