Struct Folding 

struct Folding<'a> {
    held: &'a Held,
    window: Option<Window>,
    live: bool,
}

The messages a fold has taken out, and the promise that they go back.

This is a guard rather than a straight-line take-and-restore because the render between them is a place a panic can land, and a panic there with no guard is out of all proportion to its trigger: the messages are dropped, folding stays set, and notify_all is never reached - so every reader of the seat parks in Held::lock on a notification that never comes, and the seat is wedged for the process’s life. Through Conversations::apply the same lock is the socket’s single stream folder, so it is every client on every seat that stops being delivered to rather than one page.

With the guard, a panic costs one bad fold: the messages go back, the boundaries are left for the next fold to rebuild, and the readers wake.

Fields

held: &'a Held

window: Option<Window>

live: bool

Implementations

impl<'a> Folding<'a>

fn begin(held: &'a Held) -> Option<Self>

Take the window if a fold is due, or None when there is nothing to do - a fold already running, or nothing moved.

fn messages(&self) -> &[Message]

The messages this fold took.

fn live(&self) -> bool

Whether the seat’s turn was in flight when the window went out.

fn finish(self, rendered: Rendered)

Put the fold back and wake the readers.

Trait Implementations

impl Drop for Folding<'_>

fn drop(&mut self)

Unwinding out of the render: the messages go back, and the seat stays due a fold so the next read rebuilds the boundaries.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.