Struct Library 

pub struct Library {
    root: Option<Root>,
    recent: RefCell<Vec<DocumentRef>>,
    kept: Store,
}

The origin’s documents, and the short list of them worth offering.

Fields

root: Option<Root>

None where the origin refused its storage, which is every page that is not a secure context. The editor opens either way, on a scratch session that persists nothing.

recent: RefCell<Vec<DocumentRef>>

kept: Store

Implementations

impl Library

pub async fn opening(kept: Store) -> Opened

Open the origin and the document the tab last had, before the first frame runs.

Nothing here refuses to start. An origin that will not open, a remembered document that is gone, a container that cannot be born — each falls back to the next thing down and says what happened.

pub(crate) async fn stands_on(&self) -> (Doc, Option<String>)

The document a tab opens on: always a newborn. A document that breaks the app must not be the one every reload walks back into; the ones before it are a menu away.

async fn sweeps_unclaimed(&self)

The containers a tab that is gone left behind: one born under a name nobody kept, never written into, and held by no view, goes before the library lists it.

The desktop sweeps these on the way out. A closed tab runs nothing, so the question is asked the next time one opens instead, and the lock stands in for what a session would otherwise remember making.

pub async fn containers(&self) -> Vec<Name>

Every container the origin holds, in name order — what File ▸ Open lists, with the recent ones first.

pub async fn listing(&self) -> Vec<Listed>

Every container the origin holds with a glance at each, newest edit first — what the Diagrams section lists. Read without taking any container’s lock, so one open in this tab or another lists the same.

pub async fn born(&self) -> Result<Store<Any>, String>

A document born under a name nothing in the origin stands under.

Errors

The sentence the canvas is told: no storage to be born in, no unused name, or the container that would not be laid down.

pub async fn opens(&self, named: &DocumentRef) -> Result<Store<Any>, String>

The container named, open.

A held lock is an outcome rather than a failure: the store opens read-only with ReadOnlyReason::Locked, which is how a second tab of one document lands. Only a name nothing stands under — or stands under as something that is not a container — is refused.

Errors

The sentence the canvas is told.

pub async fn renames(&self, doc: &mut Doc, to: &str) -> Result<(), String>

Call doc’s container something else, which is what renaming the document means. The session carries straight on into it.

Errors

The sentence the canvas is told.

pub async fn removes(&self, named: &Name) -> Result<(), String>

Remove named and everything in it.

Errors

The sentence the canvas is told.

pub async fn removes_closed(&self, named: &Name) -> Result<(), String>

Remove named, which this tab does not have open — refused where another tab does, whose session would be left writing into nothing.

Errors

The sentence the canvas is told.

pub async fn packs(&self, named: &Name) -> Result<Vec<u8>, String>

The container named, as the one file it travels in.

Read through a second handle on the same directory rather than through the session’s own: the session holds a resident container, so what it owes the origin has to have been drained before this is asked — which is the shell’s to see to.

Errors

The sentence the canvas is told.

pub async fn unpacks( &self, called: &str, archive: &[u8], ) -> Result<Store<Any>, String>

Lay the container archive holds down in the origin under the document name called suggests, and open it.

The name is refused rather than merged into if something already stands under it: an import brings a diagram in, it does not overwrite one.

Errors

The sentence the canvas is told.

pub fn remembers(&self, named: &Name)

Put named at the front of the list the File menu offers.

fn forgets(&self, named: &DocumentRef)

fn origin(&self) -> Result<&Root, String>