Struct NotificationArchiveModel 

pub struct NotificationArchiveModel { /* private fields */ }

Shared model — clones share state. Constructed by the install helper from NotificationArchive + AppPaths; apps reach it via ctx.app_state::<Rc<NotificationArchiveModel>>().

NotificationLog and NotificationCenterButton consume this model directly.

Implementations

impl NotificationArchiveModel

pub fn open( archive: &NotificationArchive, paths: &AppPaths, debounce: Duration, ) -> Result<Self, NotificationArchiveError>

Construct from a NotificationArchive config. For Persistent mode, resolves the path through AppPaths. Tests use AppPaths::for_testing(tmpdir) + Duration::ZERO debounce.

pub fn in_memory() -> Self

Convenience: construct an NotificationArchive::InMemory archive with the default cap, without going through paths. Mostly useful for tests and apps that explicitly want no persistence.

pub fn entries(&self) -> &ListModel<NotificationEntry>

Reactive handle on the entries. Bind to a ListView / Repeater for live UI.

pub fn unread_count(&self) -> &Signal<usize>

Signal of the unread count. Drives the bell-button badge.

pub fn version_signal(&self) -> &Signal<u64>

Reactive handle on the archive’s mutation version. Widgets that render the archive (NotificationLog, NotificationCenterButton) bind to this at BindingLevel::Rebuild, in every window — one signal is enough for N of them, see ToastRegistry::version_signal for the history of why that had to be said out loud.

pub fn limit(&self) -> usize

pub fn flush_now(&self) -> Result<(), SettingsFileError>

Force the persistent backing file to disk synchronously. No-op for InMemory. Tests call this between mutations and re-opening the file to verify persistence.

pub fn push(&self, entry: NotificationEntry)

Push a notice that has just been raised. Inserts at index 0 (newest first), evicts the oldest if the resulting length exceeds limit. Stamps the entry’s id field from next_id. Bumps unread_count when the entry is unread (which is the typical case from a toast push).

If entry.dedup_id matches an existing row, the notice is that row raised again: an operation that failed this morning and fails again now, under the same Toast::id. No new row is inserted. The row moves to the front, takes the entry’s timestamp, records a NotificationUpdate and takes the entry’s read state, which makes it unread again, even when the notice says exactly what it said before: the log and the bell show that it happened again. Every other field is merged as push_update describes.

pub fn push_update(&self, entry: NotificationEntry)

Push an in-place update of a notice that is still on screen: a progress notice’s next step, or its result. This is what the toast registry calls when a Toast::id matches a live toast.

If entry.dedup_id matches an existing row, that row is updated in place: same position, and it keeps the time the notice was raised. The row then shows the notice as it now stands, the way the live toast it mirrors does:

• title, body, severity, priority, actions and route are the update’s. An update offering no actions leaves the row offering none: a progress notice’s Cancel must not outlive the notice that said the work was cancelled, nor stand in for the Open and See report a finished one offers.
• group and source are the update’s when it names them, and stay as they were when it does not.
• id, timestamp (when the notice was raised, which places the row in the log) and dedup_id stay.
• A NotificationUpdate is appended when the update changes what the row shows (its wording, severity or actions), carrying the update’s timestamp and whichever of title and body changed. A row keeps the most recent UPDATE_HISTORY_LIMIT of them. An update that repeats the row exactly records nothing and leaves its read state alone.
• A change gives the row the update’s read state, which for a toast is unread. unread_count counts rows, so it grows only when the row had been read.

With no matching row (the user cleared it, or it was evicted), the update is pushed as a new row, like push.

pub fn mark_read_where(&self, predicate: impl FnMut(&NotificationEntry) -> bool)

Mark every UNREAD entry matching predicate as read, decrementing unread_count by exactly how many were flipped. This is the scoped counterpart of mark_all_read: a bell scoped to one window/audience must only mark ITS entries read on close — calling the unscoped mark_all_read from a scoped bell would incorrectly clear every OTHER window’s/audience’s unread state too.

pub fn mark_all_read(&self)

Mark every archived entry as read; reset unread_count to 0. Called by NotificationCenterButton when its popover closes.

pub fn clear(&self)

Clear the entire archive (resets unread_count to 0).

pub fn clear_where(&self, predicate: impl FnMut(&NotificationEntry) -> bool)

Remove every entry matching predicate, decrementing unread_count for each removed entry that was unread. The scoped counterpart of clear: a bell scoped to one window/audience must only clear ITS entries — the unscoped clear() wipes the ENTIRE shared archive (every window’s history), which would be wrong for a scoped “Clear” button.

pub fn remove_by_id(&self, id: u64)

Remove the entry with the given stable id (see NotificationEntry::id — “assigned by the archive on first push; never reused”). Updates unread_count if the removed entry was unread. No-op (no version bump) when no entry has that id.

Deliberately id-based rather than index-based: an index is a snapshot of the list’s shape at the moment it was read, and is meaningless once anything else — a concurrent peer-process reload merged in via the live archive, another push, another remove — has shifted rows out from under it. A caller that captured “the row I want to dismiss” as an index earlier and replays it later against a since-mutated list can silently remove the wrong entry; keying off id instead re-resolves the row’s current position at the moment of removal, so it always removes the entry the caller meant.

Trait Implementations

impl Debug for NotificationArchiveModel

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

Formats the value using the given formatter.