All Classes and Interfaces
Class
Description
Base implementation shared by every per-phase context: resolves all
ViewContext
accessors from the bound session and routes the mutating operations through the engine.Asynchronous
PageSource backed by an AsyncPageSupplier.Loads one page of elements asynchronously, typically from a database.
Default
SettleDispatcher: settles route to the viewer's region thread (Folia) or
the main thread (legacy Spigot/Paper) via the injected PlatformScheduler.Click policy and routing (spec §6): pre-cancel from config and per-component override,
handler dispatch with last-writer-wins cancellation, the safety-floor actions
force-cancelled after handlers, and end-of-tick post-actions.
Context for
View.onClose: the session is tearing down.Context for
View.onClose: the session is tearing down.Session teardown: idempotent on closed sessions, cancels the update task, marks the
session closed, runs
onClose (a throw is logged, teardown always completes),
unregisters the session, drops pending deferred operations and closes a container the
client still shows after an engine-initiated close.Why a session closed; exposed through
CloseContext.reason().Immutable materialized item component: fixed slots, item source, visibility predicate,
click handlers, post-actions and watched token ids.
Per-session component registry: maps slots to their owning component and resolves the
components watching a set of dirty token ids.
Resolver from a public
ViewContext to its state backing; token impls never cast
to concrete context classes, only to StateBackedContext.In-memory
PageSource: serves slices of a fixed list and settles every request
synchronously on the calling thread.Second half of the open pipeline:
onFirstRender, component materialization,
initial paint, session registration, container show, activation and update-task start.Grid-parsed
Layout backing Layout.ofGrid(java.lang.String...): ' ' is empty, every
other character is a fill slot ordered by character code point (Unicode value), then occurrence.Reflective dispatcher for the protected
View lifecycle handlers.Internal seam exposing the table-assigned int id of a state token.
Mutable state token bound from
ViewArguments at open: the open phase validates
the argument type and writes the value straight into the session's StateStore.Default beans for the inventory module.
Bootstraps the inventory-api view engine: initializes the
ViewRegistry, which
discovers and registers every
RegisterView-annotated
View subclass under the host plugin's base package and instantiates each through
the dependency manager.Fluent declaration of one item component, returned by
RenderContext.slot(...)/layoutSlot(...).Mutable collector behind
ItemComponentBuilder; gathers a component declaration
and materializes it into an immutable ComponentInstance bound to fixed slots.An ordered sequence of inventory slot positions used as a fill order, created from an
ASCII grid (
Layout.ofGrid(java.lang.String...)) or from explicit slot indices (Layout.ofSlots(int...)).Read-only state token computed once per context on the first read and stored in the
session's
StateStore; a null result is cached via a private sentinel so
the computation never re-runs for that context.Mutable per-context state.
Mutable per-context state token; values live in the session's
StateStore.Fallback
PlaceholderApplier that returns the input text unchanged.Page-by-page paginator.
Context for
View.onOpen: runs before any container exists.Context for
View.onOpen: records per-open overrides and the cancel decision.First half of the open pipeline (spec §7.2-7.6): session and store creation,
initial-state binding,
onOpen with cancellation, previous-session replacement,
per-open config merge, layout resolution and container creation.Explicit-order
Layout backing Layout.ofSlots(int...): the i-th given index is
the i-th fill position.Creates the
RenderedItem for one element of the current page; supplied by the
pagination binding so the engine stays free of renderer concerns.Immutable description of one page load issued by a paginator; safe to share across threads.
Immutable outcome of one page load: the page's items plus the total number of elements in the
backing store, which drives
getTotalPages() and navigation clamping.Strategy answering "where do page items come from" for a paginator.
Reactive pagination token, declared once per view through the
View.paginate* factories
and built by PaginationBuilder.build().Per-(session, token) pagination runtime: records pre-init navigation, builds the
per-context page source and geometry engine at open time, owns the page-element
components of the current frame and implements the
PaginationHost seam the
relocated engine paints and settles through.Static lookup helpers over a session's pagination bindings.
Fluent declaration of one pagination token, returned by the
View.paginate*
factories.PaginationBuilder implementation behind View.paginate*: collects the
declaration fluently (value errors rejected at setter time), validates the combination
at PaginationBuilderImpl.build(), resolves geometry and target, and constructs the registered
PaginationImpl token.Invoked when an async page load fails (exceptional completion,
null future, synchronous
throw, or timeout).The world-facing seam the relocated pagination engine talks to instead of the 2.x
Viewer/InventoryEditor pair.The
Pagination token implementation: a per-view singleton declared at view
construction time whose per-context runtime lives in a PaginationBinding stored
in this token's own StateStore slot.Pagination init step of the open pipeline (spec §7 step 7): initializes every pagination
binding of a freshly opened session between layout resolution and
onFirstRender —
target slots resolve against the session layout, the per-context page source is built,
the geometry engine is constructed and pending navigation recorded during onOpen
is replayed.Renders one element of the current page into a component builder.
Immutable source declaration of one pagination token: which of the four source kinds the
view declared, and how to construct the
PageSource for one context.The four ways a view can declare where page elements come from.
Immutable pagination declaration built by
PaginationBuilderImpl.build(): geometry,
paint target, renderer and frame items, the source declaration, and the async plumbing
consumed by PaginationSourceSpec.createSource(ViewContext, PaginationSpec, tech.guilhermekaua.spigotboot.core.spigot.scheduler.PlatformScheduler).How elements are distributed across pages.
Where the page items are painted.
Internal page-source geometry engine: navigation, page-load dispatch and frame painting
over a
PaginationHost.PlaceholderApplier that delegates to PlaceholderAPI when the plugin is enabled at
runtime.Paginates a source list across one or more
Layout patterns, cycling through the
patterns as the player pages forward.Resolves placeholder tokens in user-facing text (item display names, lore lines, titles).
Plain phase-less context handed out by
ViewService.contextOf; adds nothing on top of
the base context behavior.Immutable registration record of one view class: the singleton instance and the frozen
config its
onInit produced at registration time.Marks a
View subclass for boot-time
discovery and registration, after which it can be opened through
ViewService#open(Player, Class).Context for
View.onFirstRender: declares this session's components.Context for
View.onFirstRender: collects component declarations in order and
freezes them into the session's component table via RenderContextImpl.materializeAll(), called by
the first-render phase after the handler returns.One slot's worth of pagination engine output: a user-declared element builder, a plain
frame item (a
null item clears the slot), or the failure sentinel that keeps the
slot's previous content entirely.Parsed form of
ViewConfig.layout(): maps each named layout character to its
container slots in row-major order; ' ' marks an unnamed position and is skipped.Sliding-window paginator.
Tracks the live view session of every player, keyed by player UUID (one open view per
player); the v3 counterpart of the 2.x
ViewerRegistry as a DI-managed bean.Decides which thread runs the settle (state application + callback delivery) of an
asynchronously completed page load.
One value per view singleton, shared by all viewers; not context-keyed.
Shared state token: one atomic value per view singleton, readable and writable from any
thread.
Context for component click handlers and
View.onClick: one instance per
intercepted InventoryClickEvent.Context for component click handlers and
View.onClick: wraps one Bukkit click
event.Writes item stacks into container slots, applying placeholders to display name and lore
at paint time on a clone of the given item (mirrors the 2.x
InventoryEditorImpl
placeholder behavior); the caller's item is never mutated.Thrown when a state token is accessed through a context belonging to a different view
class or to an already closed session.
Read access to a per-context value identified by this token.
Seam between state token impls and context implementations: a context exposing the
session's state store, owning view and liveness.
Per-session state storage: an array indexed by token id plus the set of dirty token ids
awaiting the next coalesced flush.
Marker for watchable per-view tokens; implemented by
State and pagination
tokens.Shared threading assertions for the inventory-api internals.
Updates the title of the inventory currently open for a player without forcing the player to
close and reopen the GUI.
Per-view registry of state tokens.
Thrown when a view is opened (through ViewService.open or context navigation)
but the target view class is not registered.
Context for
View.onUpdate: fired by scheduled ticks, state flushes, explicit
updates and pagination settles.Context for
View.onUpdate: a plain context carrying the trigger of the pass.Update pass: invokes
View.onUpdate with the trigger, then repaints components —
all of them plus every pagination area on a full pass, or only the watchers of a dirty
token set (plus dirty pagination areas and their element watchers) during a scoped
flush.Why an update pass runs; exposed through
UpdateContext.trigger().Base class for inventory views.
Immutable, typed key-value arguments passed to a view when it is opened.
Mutable accumulator for
ViewArguments.Immutable, validated view configuration produced by
ViewConfigBuilder.build();
frozen at registration and merged with per-open overrides via ViewConfig.withOverrides(java.lang.String, java.lang.Integer).Fluent, mutable builder for
ViewConfig, used in View.onInit;
ViewConfigBuilder.build() validates and freezes the configuration.Thrown at registration or build time when a view configuration, layout or component
declaration violates a validation rule.
Base contract shared by every per-phase context handed to
View lifecycle handlers.Finds every concrete
View subclass annotated with RegisterView under the
user's base package.Orchestrator of the view lifecycle: composes the fixed-order phase handlers and is the
sole mutator of sessions.
Single Bukkit listener bridge of the v3 view engine: resolves the clicking, dragging,
closing, quitting or disabling player's session in the
SessionRegistry and
delegates to the matching ViewEngine entry point.Registry of view singletons and their frozen configs, keyed by view class.
DI facade for opening and closing views.
Runtime state of one (player, open) pair: lifecycle status, container, effective config,
resolved layout, component table, state storage and deferred end-of-tick operations.
Lifecycle status of a session.
Per-session scheduled update runnable, started by the first-render phase when
updateIntervalTicks > 0 and cancelled by the close phase.