Struct Channel 

pub struct Channel {
    pub kind: TabKind,
    pub name: String,
    pub platform: Platform,
    pub extra: Vec<(Platform, String)>,
    pub temp: bool,
    pub heat: f64,
    pub last_ms: u64,
    pub messages: VecDeque<Message>,
    pub seq: u64,
    /* private fields */
}

live state for a single channel. bounded ring buffer — a raid can flood forever and we never grow past cap (mele is 8GB; resource-conscious). heat is a decaying counter driven by message arrivals.

Fields

kind: TabKind

a real channel, or one of the virtual tabs (see TabKind).

name: String

platform: Platform

primary source — sends target it, and it leads the tab label.

extra: Vec<(Platform, String)>

further sources merged into this tab (a +-joined channel). their lines interleave into the one ring in arrival order.

temp: bool

the unsaved “stream i’m looking at” tab: one slot, never persisted or shared, promoted to a saved tab by keeping it.

heat: f64

last_ms: u64

wall-clock ms of the last heat update — decay is computed against it.

messages: VecDeque<Message>

seq: u64

lines ever appended at the live end — a monotonic clock for “how many arrived since”, unaffected by the ring evicting old ones.

Implementations

impl Channel

pub fn new(name: &str, platform: Platform, cap: usize) -> Channel

pub fn special(kind: TabKind, cap: usize) -> Channel

a virtual tab. it joins nothing: subs() is empty, so no line ever matches it and no part / emote / history call is made for it.

pub fn deliver(&mut self, msg: Message)

append a line to a virtual tab: counts as unread, but keeps the row’s own heat (a feed row’s heat is the server’s, not ours).

pub fn unread(&self) -> Unread

the tab’s unread state.

pub fn ping(&mut self)

flag the most recent line as a ping (caller knows who “me” is).

pub fn set_pin(&mut self, pin: Option<Pin>)

a pin arrived (Some) or was cleared (None).

pub fn visible_pin(&self) -> Option<&Pin>

the pin to show, unless the user dismissed this very one.

pub fn dismiss_pin(&mut self) -> bool

hide the current pin (a newer one will show again). false = none shown.

pub fn flag_event(&mut self)

flag the tab as holding an unseen stream event.

pub fn system(&mut self, msg: Message)

add a client-side line (a send rejection, a connection notice): keeps the cap, but touches neither heat nor unread — it is not chat.

pub fn insert_by_ts(&mut self, msg: Message) -> bool

slot a line in by its own time (extra.ts, seconds) — a replayed or back-dated event, not news: no heat, no unread, no ping. it lands after the last line that is not newer than it. false = it would sit older than everything in a full ring, so it is dropped.

pub fn apply(&mut self, d: &Delete) -> usize

a mod removed lines: mark every matching chat line (events are never struck). returns how many were marked. the caller has already routed d to this tab; platform is checked per line (merged tabs).

pub fn mark_seen(&mut self)

the tab is on screen — everything it holds is now seen.

pub fn subs(&self) -> impl Iterator<Item = (Platform, &str)>

every source feeding this tab, primary first.

pub fn matches(&self, platform: Platform, name: &str) -> bool

does a line for (platform, channel) belong to this tab?

pub fn merged(&self) -> bool

is this a merged (multi-source) tab?

pub fn cool(&mut self, now_ms: u64)

advance heat decay to now_ms without adding anything (idle cooling).

pub fn first_sight( &mut self, platform: Platform, channel: &str, id: Option<&str>, ) -> bool

is this the first time this tab sees the platform message id of channel? false = it was already drawn: drop the copy. a line with no id can’t be told apart from a repeat, so it always counts as new.

pub fn backfill(&mut self, channel: &str, msgs: Vec<Message>)

seed scrollback with archived history of channel: prepended oldest-outward, skipping any message id already drawn (the live feed may overlap the archive’s tail), heat untouched — history is cold by definition. msgs is chronological (oldest first); the cap still bounds the buffer.

pub fn record(&mut self, msg: Message, now_ms: u64)

record a message: decay to now, add one increment, snapshot heat onto the line, then store it (evicting the oldest past the cap).

Trait Implementations

impl Clone for Channel

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Channel

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

Formats the value using the given formatter.