Class export=

Builds the window. It asks nothing of the store until attach().

Puts an entry the STORE holds: not a write. For a restore and for a row another process wrote.

Whether any windowed entry of a realm holds an attribute: a change made here first, then the store.

Gives the window its bridge, once the store is open, and drops every CLEAN answer given before it — an absence recorded before the store could be asked is not an absence.

Whether the store can be asked yet.

Whether a key has a change here not yet written, or one in flight, or was handed out since the last flush — the states in which a row from another process must wait for the flush rather than replace it.

A realm's count for ldap.maxEntries: the store's, read again when the last reading is more than ten seconds old, plus this process's own net since. Stale by at most that much for another process's creates; the ceiling is a ceiling, not a quota to the entry.

Empties a realm: the restore's replaceRealm(). Changes not yet written are dropped with the rest — a restore is "this is the directory".

What the flush writes for the windowed keys, and the release of every entry handed out and left unchanged.

The flush wrote what collect() answered: each base is what was sent, and a key unchanged since is released. A key the store answered differently for (outcomes) is forgotten, or — changed again since — given the store's row as its base.

How many entries are strictly under a base, from the store's count and this process's changes not yet written.

Removes a key: a write, pinned until the flush writes it.

Hands fn the NAMES of the entries under a base in the store, a page at a time — { key, dn, origin, uid }, no entry read whole — and counts the ones fn answers true for. For the identity register a windowed worker fills at start (#349).

Calls fn for each RESIDENT entry of a realm: for a walk whose filter can only match an entry outside the windowed containers.

A realm's count read from the store now, for ldap.maxEntries and for a report.

The facade ldap_server.js holds as entries: the ambient realm's view for every Map member, realmMap(id) for a named realm, and the window itself as window.

The flush failed: the keys it took are still changed, and are taken again by the next one.

The windowed entries of a realm matching an indexed question, as this process holds them.

Forgets a key: a row another process wrote or removed, read again when next asked for. A resident key is removed.

The entry at a key, or undefined.

Whether anything is under a key.

Whether a key holds an entry.

The windowed entries under a base that hold an attribute, as this process holds them: the store's holders a page at a time, each read back through the window and asked predicate, and changes made here added.

Whether a key of a realm is windowed: strictly under one of its windowed containers.

Another process changed a key this one is busy with: once this process's flush has let it go — written and merged by the store, or found unchanged — it is dropped, and read again when next asked for. Without this a key merely HANDED OUT when the change arrived would keep the older copy until it was evicted.

The entry held at a key, without asking the store and without handing it out: persistence.js's entryAt() for a windowed key.

The resident entries of a realm, keyed: what persistence.js's write shadow covers. A windowed entry is never in that shadow — the window holds its own base.

Puts an entry at a key: a write, pinned until the flush writes it.

How many entries a realm holds, from the store's count of the windowed containers the first time and this process's own net since.

The window's figures, for a status page and tests.

A Map-shaped view of one realm.

Walks a realm's entries at or under a base, lazily.