All Classes and Interfaces
Class
Description
Base class for assets.
Abstract base class for bindings.
Base class for most implementations of
ComponentCallback
, used when
there is an underlying Event
.Base class for link-generating components that are based on a component event request.
Partially implements
ContributionDef
, providing empty implementations of the
three contribute() methods.Provides initialization of the clientId and elementName properties.
Base page for Tapestry internal pages, that should suppress any application changes to the core stack's CSS.
Provides base utilities for classes that generate clickable links.
Abstract implementation of
Messages
that doesn't know where values come from (that information is supplied in
a subclass, via the AbstractMessages.valueForKey(String)
method).Base class for service decorators and service advisors that work by invoking a module method.
Base class for implementing
OptionModel
.Base class for components that output a property value using a
PropertyModel
.Abstract implementation of
Resource
.Base class for
SelectModel
implementations, whose primary job is to provide the AbstractSelectModel.visit(SelectModelVisitor)
method.Abstract implementation of
ObjectCreator
geared towards the creation of the core service implementation,
either by invoking a service builder method on a module, or by invoking a constructor.Abstract base class for implementations of
ServiceDecorator
(i.e., old school) and
ServiceAdvisor
(i.e., new school).Base class for strategies that store their values as keys in the session.
Abstract class for a variety of components that render some variation of a text field.
Base class for constructing a
Validator
.Component that triggers an action on the server with a subsequent full page refresh.
Annotation that may be placed on parameters of event handler methods to define their names
in OpenAPI description.
Marks a field of a page (not a component) as persistent within the URL, as with a page activation context.
Hooks the activate event handler on the component (presumably, a page) to
extract query parameters, and hooks the link decoration events to extract values
and add them to the
Link
.Responsible for adding additional style tags that contain directives for non-standards compatible browsers
Used inside an
AjaxFormLoop
component to spur the addition of a new
row.An annotation that may be placed on a advisor method of a module.
Definition of a service advisor, which (by default) is derived from a service advisor method.
Extended version of
AdvisorDef
introduced to determine any
module method annotated with Advise
as an advisor
method.Equivalent of
InterceptorStackBuilder
, but works using an
AspectInterceptorBuilder
that receives advice from
ServiceAdvisor
s.Marker annotation for methods associated with the AfterRender phase.
Corresponds to
BeforeRenderBody
, allowing additional markup after rendering the body of a component, but
before rendering the rest of the component's template.Corresponds to
BeforeRenderTemplate
, allowing additional markup after rendering the component's template.Marker annotation for services related to processing an Ajax request (rather than a traditional request).
Similar to
ComponentEventRequestHandlerImpl
, but built around the Ajax request cycle, where the action
request sends back an immediate JSON response containing the new content.Performs a partial page render based on a root component.
A filter that intercepts Ajax-oriented requests, thos that originate on the client-side using XmlHttpRequest.
A special form of the
Loop
component that adds Ajax support to handle adding new rows and removing
existing rows dynamically.Interface that allows an enclosing
AjaxFormLoop
to work with enclosed
components such as AddRowLink
or
RemoveRowLink
.Coordinates the rendering of page partials in the context of an
Ajax update to an existing Form.
Filter for the
Ajax
ComponentEventRequestHandler
that informs the AjaxFormUpdateController
about the form's client id and component id.Handles
Link
result types by building a JSON response with key "redirectURL".Processes a Class result by converting the Class to a logical page name, then processing that.
A
ComponentEventResultProcessor
, used for Ajax requests, for a String value
that is interpreted as a logical page name.Used to render portions of a page as part of an Ajax request.
Manages the rendering of a partial page render as part of an Ajax response.
Handles
URL
result types by building a JSON response with key "redirectURL".An Alert that may be presented to the user.
Manages
Alert
s (using the AlertStorage
SSO.Renders out an empty
<div>
element and provides JavaScript initialization to make the element
the container for alerts.A stateless session object used to store Alerts between requests.
Used to wrap plain JavaScript libraries as AMD modules.
Introduced for Tapestry 5.3, contains new methods to provide access to annotations on the class,
and on methods of the class.
Interface implemented by members that may hold annotations.
Standard AnnotationAccess for a specific type.
Checks for the
DataType
annotation, returning its value if present.A source of annotations.
Chain of command for
AnnotationProvider
.Constants for documenting the context wherein the tapestry-provided annotations may be used, in conjunction with
UseWith
.Turns any arbitrary (X)HTML element into a component.
A bridge from Spring's approach to customizing the application context, over to Tapestry's approach.
Used to disambiguate which version of
SymbolProvider
is being referenced.Stores global information about the application and its environment.
Service interface for initializing Tapestry for the application.
Filter interface for
ApplicationInitializer
.Allows for injection of the global application message catalog into services.
Identifies frames for application classes.
A contribution to the configuration of the
ApplicationStateManager
, identifying the strategy and creator for
a particular Session State Object (SSO), identified by the SSO's class.Used by
ApplicationStateManager
and ApplicationStatePersistenceStrategy
to create
a Session State Object (SSO) on demand.Responsible for managing Session State Objects (SSO), objects which persist between
requests but are not tied to
any individual page or component.
Used by
ApplicationStateManager
to manage a specific kind of Session State Object (SSO)
persistence.Used to provide access to
ApplicationStatePersistenceStrategySource
instances
via a logical name for the strategy, such as "session".Looks for the
SessionState
annotations and
converts read and write access on such fields into calls to the ApplicationStateManager
.Simple implementation of
EventContext
.Parses lines like this, in which just the artifact is changed:
{tapestry-ioc => tapestry5-annotations}/src/main/java/org/apache/tapestry5/ioc/annotations/Advise.java (100%)
.A decorator used to create an interceptor that delegates each method's invocation to an
MethodAdvice
for advice.A builder may be obtained from the
AspectDecorator
and allows more
controlled creation of the created interceptor; it allows different methods to be given different advice, and allows
methods to be omitted (in which case the method invocation passes through without advice).An Asset is any kind of resource that can be exposed to the client web browser.
Deprecated.
Binding factory where the expression is a reference to an asset.
Generates a checksum of an arbitrary
Resource
or StreamableResource
which can be incorporated into
the client URL of an Asset.Defines constants for the two basic asset prefixes.
Recognizes requests where the path begins with "/asset/" (actually, as defined by the
SymbolConstants.ASSET_PATH_PREFIX
symbol), and delivers the content therein as a bytestream.Used by
AssetSource
to create new Asset
s as needed.Performs injection of assets, based on the presence of the
Path
annotation.Class that represents the exception of an asset not being found.
Exposes assets (in the current locale).
Encapsulates the logic or creating the path portion of an asset URL, including hooking the
AssetPathConverter
into the generation.Converts the path (or URI) of an asset into a new format.
Marker annotation used to specifically identify the
Dispatcher
used to dispatch
asset requests (so that AssetRequestHandler
s can be contributed).Handler for asset requests, which expose some kind of
Asset
to
the user agent (i.e., the client web browser).Used to find or create an
Asset
with a given path.
Service whose implementations define whether a given request should be handled
asynchronously or not and, if yes, which
Executor
(usually, a thread pool,
but not necessarily) should handle it, possibly different HttpServletRequest
and HttpServletResponse
objects to be used when calling
HttpServletRequest#startAsync()} and an optional AsyncListener.Class used by AsyncRequestHandler to return information on how to handle
a request.
Service that handles Tapestry's support for asynchronous Servlet API requests.
Service that handles Tapestry's support for asynchronous Servlet API requests.
An attribute within an
Element
.Wraps a
StringProvider
as a read-only Binding
.Tracks the qualified name and value of an attribute within a start element
XMLToken.
Stores an attribute/value pair (as part of an XML element).
Directs that the value to be built should be an autobuild instance of the type with injections performed, via
ObjectLocator.html#autobuild(Class).
Checks for the
Autobuild
annotation and, if so
invokes ObjectLocator.autobuild(Class)
on it.A mixin for a text field that allows for autocompletion of text fields.
Used by
Form
to determine which fields will be focused and a what
priority.Used (as part of a
UnknownValueException
to identify what available values
are present.Renders out a
AvailableValues
instance as a <div> enclosing a <ul>.An extension of
ByteArrayInputStream
that is initialized from a Base64 input stream (rather than from a byte
array).An extension of
ByteArrayOutputStream
that allows the final byte array to be converted to a Base64 string.Describes a single client-side constraint.
Provides support for elements that will optionally render a unique
id
attribute, but only if it is
requested.Base implementation of
Locatable
.Base implementation of
OptimizedSessionPersistedObject
.Used when switching between normal/insecure (HTTP) and secure (HTTPS) mode.
Base implementation of
ValidationDecorator
that does nothing.Class that provides Tapestry's basic default data type analyzers.
Class that provides Tapestry-IoC's basic type coercions.
A contribution to the
BeanBlockSource
service, defining a page name and block id (within the page) that can
edit or display a particular type of property.Used to override the default
BeanBlockSource
for a particular data type.A source of
Block
s used to display the properties of a bean (used by the Grid
component), or to edit the properties of a bean (used by the BeanEditForm
component).A component that displays the properties of a bean (or POJO, or any object with properties) as a
simple HTML definition list.
Defines a context for editing a bean via
BeanEditor
.A component that creates an entire form for editing the properties of a particular bean (or POJO, or any object
with properties).
A component that generates a user interface for editing the properties of a bean (or POJO,
or any object with properties).
Provides the information necessary to build a user interface to view, create or edit an instance of a particular
type.
Used by a component to create a default
BeanModel
for a particular bean
class.Utility class for creating
BeanModelSource
instances without
Tapestry-IoC.Utilities used in a few places to modify an existing
BeanModel
.Defines a context for validating beans.
Defines the interface for a chain-of-command that updates JSR-303 configuration in some way before the
ValidatorFactory
is created.Provides list of groups targeted for validation.
Module for JSR-303 services.
Creates
ValidatorFactory
.Marks methods to be invoked when the component rendering state machine hits the point in the component's template
where the body element occurs.
Associated with components that have a template, this phase is invoked to allow the component to decorate its
template with additional markup.
Marker annotation for methods that should be executed at the start of rendering the component.
Base class for parsing/formatting BigInteger and BigDecimal.
A binding is a connection between a component and its container (another component), that allows the embedded
component to gain access to resources defined by the container.
Extension to
Binding
that adds a method to access the generic property type.Constants for the built-in binding prefixes.
Creates a binding of a particular type.
Used to acquire bindings for component parameters.
Designates a field in a mixin which is bound to the parameter of the containing
component corresponding to the value of the annotation.
Responsible for identifying, via the
BindParameter
annotation, mixin fields
that should be bound to a core-component parameter value.Used with the
Select
component to control whether an initial blank
option is supplied.A block is a collection of static text and elements, and components, derived from a component template.
Accesses a named block from the container.
Exception thrown when a
Block
is requested but not found.A block, used to enclose a chunk of template (including components) and control when or if the content is rendered.
A type of page element that has a body that can be added to.
Placeholder for a component's body (within the component's template).
Encapsulates a bit of information that can be represented as a boolean.
Module which defines the options needed to run Tapestry using Bootstrap 4 instead of the default
Bootstrap 3.
Used by the
PipelineBuilderImpl
to create bridge classes and to
create instances of bridge classes.A buffered output stream that, when a certain number of bytes is buffered (the cutover point) will open a compressed
stream (via
Response.getOutputStream(String)
Marks services provided by this module that may need to be unambiguously referenced.
A wrapper around a byte-stream, represented internally as a byte array.
Quick and dirty key/value cache that is subclassed to provide the logic that generates the value for
a missing key.
Indicates that a method should only be evaluated once per request and the result cached.
Caches method return values for methods annotated with
Cached
.Adapted to Tapestry-IoC from the Guice implementation in the reference implementation.
Common subclass for all JCache interceptors
An
ObjectCreator
that delegates to another
ObjectCreator
and caches the result.Used to capture the rendered document from a traditional page render.
Implementation of
ComponentEventCallback
that simply captures the result value.An mapped collection where the keys are always strings and access to values is case-insensitive.
A node that stores parsed character content (CDATA).
Literal text that was enclosed within a !CDATA in the input template (so we should do the same during output).
A service which can assemble an implementation based on a command interface, and an ordered list of objects
implementing that interface (the "commands").
A Checkbox component is simply a <input type="checkbox">.
A validator that enforces that the value is true.
Implements a barrier that periodically asks the
UpdateListenerHub
to check for
updates to files.A list of checkboxes, allowing selection of multiple items in a list.
Utility used by
AssetRequestHandler
implementations
where the first folder in the extra path is actually a computed checksum of the resource's content.The end result of a class transformation is a ClassInstantiator that can be used to
instantiate an instance of the transformed class.
Externalizes the logic for defining which classes will be loaded (and possibly transformed) by the class loader, and
which will be loaded by the parent class loader.
Interface that defines types who provide a class name for URLChangeTracker purposes.
Scans the classpath for top-level classes within particular packages.
Deprecated.
Deprecated in 5.4, with no replacement.
Generates Assets for files on the classpath.
Chain-of-responsibility service which defines rules for blocking access to classpath resources
based on their paths.
A handler for asset requests for classpath assets (within a specific folder).
Used to determine which files will be included in the set of matches paths within a particular
package.
A marker annotation used to select the correct
AssetFactory
for injection.Implementation of
Resource
for files on the classpath (as defined by a ClassLoader
).Makes a
Resource
on the classpath available as a SymbolProvider
Used to scan a portion of the classpath for files that match a particular pattern, defined by a
ClasspathMatcher
.Used by
ClassNameLocator
to convert URLs from one protocol to another.Default implementation that returns the URLs unchanged.
Organizes all
PropertyAdapter
s for a particular class.Class that represents information about one class being renamed and/or moved
between artifacts (JARs) and/or packages.
Used when a component event handler returns a class value.
Identifies the type of class referenced in a
PlasticClassEvent
.Marker annotation for component methods associated with the terminal phase for the component rendering state machine.
Deprecated.
Deprecated in 5.4 with no replacement.
Extends
ClientElement
with the concept of a body, a Block that can be rendered to provide the content
within.Applies client-side validation constraints based on a particular JSR 303 annotation.
Source for
ClientConstraintDescriptor
.A service used when a component or service needs to encode some amount of data on the client as a string.
Allows binary object data to be encoded into a string.
Interface for any kind of object (typically, a component) that can provide a client-side
id, typically used in the generation of client-side (JavaScript) logic.
Provides a number of symbols related to client-side localization; by exposing these in the global message catalog,
they are available to the client (via the "t5/core/messages" module).
Describes an object that can store
PersistentFieldChange
s, and manage a query parameter stored into a Link
to maining this data across requests.Manages client-persistent values on behalf of a
ClientPersistentFieldStorageImpl
.Implements simple client-persistent properties.
Controls if and how client-side form input validation occurs.
Analyzes the current request to see if it is on the whitelist (of clients with access to certain key pages).
Creates a proxy for the interface that delegates each method to a Clojure function.
A thin wrapper around
HttpSession
that supports re-storing of mutable
session attributes at the end of the request (see ClusteredSessionImpl.restoreDirtyObjects()
).Responsible for converting from one type to another.
Exception used when a
Coercion
throws an exception while
trying to coerce a value.Exception used when
TypeCoercer
doesn't find a coercion from a type to another.An immutable object that represents a mapping from one type to another.
Static factory methods to ease the creation of new collection types (when using generics).
Identifies how a column within a
GridSortModel
is sorted.A node that represents a comment within the DOM.
A node representing a comment embedded in the source input.
Marks a method of a service (or a component method) as transactional: the active transaction should commit after invoking the method.
Searches for methods that have the
CommitAfter
annotation and adds
logic around the method to commit or abort the transaction.Allows for a number of anonymous injections based on the type of field that is to be injected.
Some utility methods used in different Tapestry subprojects.
Used globally to track what compatibility traits are enabled.
Defines services for managing compatibility across releases.
Used to define an embedded component within another component.
Interface that defines the lifecycle of a component, within a page, allowing for callbacks into the component for
many different events.
An action that is associated with a component.
Used to collection component actions, with the ultimate goal being the creation of a MIME-encoded string of the
serialization of those actions.
Provides access to
ComponentAssembler
s (this is used by the assemblers
to find related assemblers).The "component:" binding prefix, which allows access to a child component via its id.
Callback interface, used when invoking lifecycle methods on components.
A cache for converting between class names and component (or other) classes.
Marker annotation used to inject the correct InvalidationEventHub service
responsible for invalidations when underlying component class files are changed.
Resolves page names and component types to fully qualified class names.
Interface for a set of objects that can perform transformation of component classes.
A service that can be injected into a component to provide common defaults for various types of parameters.
Service that generates a Graphviz DOT description file
for a given component's dependency graph or for the whole set of dependencies of all components.
Internal service that registers direct dependencies between components (including components, pages and
base classes).
Enum class defining the types of dependency components, pages and mixins can
have among them.
An event that may originate in application logic, or as a result of a client interaction (a GET or POST from the
client).
Callback interface for a render phase event or
ComponentEvent
, notified when a non-null value is returned from some event
handler method.Processes component action events sent as requests from the client.
A wrapper exception around any exception thrown when invoking a component event handler.
Interface used with
TransformationSupport.addEventHandler(String, int, String, ComponentEventHandler)
}.Responsible for creating
Link
s for page render requests and for component event
requests, and for parsing incoming paths to identify requests that are component event or page render requests.Allows for selective replacement of the default
Link
used to represent a component event request.Filter interface for
ComponentEventRequestHandler
.Handler interface for component event requests.
Encapsulates all the information that may be provided in a component event request URL.
Responsible for handling the return value provided by a component event handler method.
Marker for
ComponentEventResultProcessor
to identify the particular
implementation used for handling Component
instances (i.e., pages).Creates
Instantiator
s for components, based on component class name.A wrapper around a
PlasticManager
that allows certain classes to be modified as they are loaded.Marker annotation used to identify a service from the component layer that conflicts, in terms of service interface,
with a service from elsewhere.
Page used to describe the component libraries being used in the application.
Class that encapsulates information about a component library, going beyond what a library mapping
provides.
Default
ComponentLibraryInfo.SourceUrlResolver
implementation.Interface that provides the source URL for a given
ComponentLibraryInfo
.Service that provides information about component libraries.
Marker annotation used to inject the correct
InvalidationEventHub
service
responsible for validations when component message catalog (i.e., ".properties") files change.Used to connect a Tapestry component to its message catalog, or to obtain the application catalog (that all
component message catalogs extend from).
Defines a component in terms of its capabilities, parameters, sub-components, etc.
Access to component models (as provided via
ComponentInstantiatorSource
).Used to construct component names.
Service that allows replacing one component, page or mixin class by another without changing the sources.
Implements
RenderCommand
and represents a component within an overall page.Provides access to common methods of various services, needed by implementations of
ComponentPageElement
and
InternalComponentResources
.Provides access to the
ComponentPageElementResources
facade.Constants for core component parameters defined by
Symbol
Filter interface for
ComponentRequestHandler
.A facade around
ComponentEventRequestHandler
and PageRenderRequestHandler
that allows for simplified filters that cover both types of
requests.Terminator for the
ComponentRequestHandler
pipeline, that feeds out into the
ComponentEventRequestHandler
and PageRenderRequestHandler
pipelines.Determines the
ComponentResourceSelector
for the current request.A central service that encapsulates the rules for locating resources for components.
Provides a component instance with the resources provided by the framework.
Interface implemented by components (after they have been transformed at load time).
Operations shared by the public
ComponentResources
interface and
ComponentPageElement
interface (on the internal side).Encapsulates the information that is used when locating a template or message catalog associated with a component.
Deprecated.
In Tapestry 5.4; use
MethodAdvice
and other parts of the new (in 5.3) plastic library.Renders
ComponentResources
instance, showing the complete id and the class name and the location (if a
location is available, it won't be for pages).A wrapper around
ComponentEventResultProcessor
that encapsulates capturing the exception.Used by classes that need to retrieve a component by its complete id, or a page by its logical page name or root
component class.
A parsed component template, containing all the tokens parsed from the template.
Deprecated.
Deprecated in 5.3, override or decorate
ComponentResourceSelector
instead.Marker annotation used to inject the correct
InvalidationEventHub
service
responsible for validations when component template files change.Provides access to cached
ComponentTemplate
s.Service implementation that manages a cache of parsed component templates.
Finds fields with the
Component
annotation and updates
the model.Aggregates together a number of field validator instances as a single unit.
Combines two coercions to create a coercion through an intermediate type.
GZip compressed representation of a
StreamableResource
.Identifies which content types are compressable.
Indicates how the content inside a
StreamableResource
is (potentially) compressed.Provides an indirect, or computed, value.
A barrier used to execute code in a context where it is guarded by read/write locks.
Condition used with
InstructionBuilder.when(Condition, WhenCallback)
.Object passed into a service contributor method that allows the method provide contributed values to the service's
configuration.
Defines the three types of configurations a service may request.
Responsible for writing attributes needed to configure the client, into the
HTML element.
A mixin that can be placed on a clickable component, such as
LinkSubmit
,
and will raise a confirmation dialog when the element is clicked.Encapsulates the initial construction of an object instance, followed by a series
InitializationPlan
s to initialize fields and invoke other methods of the constructed object.Supplies construction-time logic for the class' constructor.
Wraps the invocation of a constructor (with exception reporting) as an
Invokable
.A service creator based on an implementation class' constructor, rather than a service builder method.
An annotation on a page component used to identify the content type the page returns.
Represents an HTTP content type.
Used to determine the MIME content type for a resource.
An API agnostic version of
ServletContext
, used to bridge the gaps between the Servlet API and
the Portlet API.Implementation of
AssetFactory
for assets that are part of the web application context.Handles requests for context assets, screening out attempt to
access anything under WEB-INF or META-INF.
An interface implemented by exceptions that get special handling in the default
RequestExceptionHandler
service.Specialization of
AssetBindingFactory
that is explicitly limited to
context assets.A service to provide utilities needed for event context encoding and decoding to and from (partial) URL paths.
Marker annotation to select the correct
AssetFactory
for injection.A resource stored with in the web application context.
Used to convert values used in event contexts to client string representations and back.
An annotation that may be placed on a contributor method of a module.
Contribution to a service configuration.
Extended version of
ContributionDef
introduced to determine any
module method annotated with Contribute
as a contributor method.Starting in Tapestry 5.3, contributions could be optional.
Defines how a particular controlled package is processed.
A fluent API to create and write cookies.
Used by other services to obtain cookie values for the current request, or to write cookie values as part of the
request.
Implementation of the
Cookies
service interface.You can write cookies to it.
Provides the cookies from the browser.
Marker annotation for services that are provided by the Tapestry core module.
Interface implemented by classes handling CORS (Cross-Origin Resource Sharing) in requests.
Service that provides useful methods for
CorsHandler
implementations.Default
CorsHandlerHelper
implementation.Enumeration that defines the possible outcomes of
CorsHandler.handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
HttpServletRequestFilter that handles CORS.
Provides a parser and evaluator for unix-like cron expressions.
Deprecated.
Deprecated in 5.4 with no replacement.
Rewrites the
url()
attributes inside a CSS (MIME type "text/css")) resource.Organizes the tabs on the
T5Dashboard
page.Identifies a tab that will be present on the Tapestry Dashboard page.
Constants related to client-side behaviors; generally, these are attributes added to elements on the server
side to trigger behaviors on the client-side.
Used to explicitly set the data type used to select an editor (or display) block.
Used by
BeanModelSource
to identify the type of data associated with a particular property (represented as a
PropertyAdapter
).Defines the names of data types used to select an editor (or display) block for a property.
A component used to collect a provided date from the user using a client-side JavaScript calendar.
Formatting utilities for dates; this is primarily used when communicating server-side dates to the clients in ISO-8601 format.
An annotation that may be placed on a decorator method of a module.
Definition of a service decorator, which (by default) is derived from a service decorator method.
Extended version of
DecoratorDef
introduced to determine any
module method annotated with Decorate
as a decorator
method.
Default
CorsHandler
implementation.The default data type analyzer, which is based entirely on the type of the property (and not on annotations or naming
conventions).
Simply calls configure() to do the default Hibernate configuration.
Creates default implementations of a class.
Worker for the
Inject
annotation that delegates out to the master
MasterObjectProvider
to access the value.Default implementation that transforms a camelCased method-name to a clojure-style function name.
Default implementation of
MarkupModel
that is appropriate for traditional (X)HTML
markup.Starting from the Class for a module, identifies all the services (service builder methods),
decorators (service
decorator methods) and (not yet implemented) contributions (service contributor methods).
Default strategy, which is to do nothing: null values stay null.
Default object renderer as a catch all for class
Object
.OpenApiDescriptionGenerator that generates lots, if not most, of the application's
OpenAPI 3.0 documentation.
OpenApiTypeDescriber
implementation that handles some basic types, mostly primitives and String.Default implementation of
RequestExceptionHandler
that displays the standard ExceptionReport page.Default catch-all implementation of
SessionPersistedObjectAnalyzer
.Manages a Set of String
TreeNode
ids.A default implementation of TreeModel that starts with a
ValueEncoder
(for the element to string conversion),
a TreeModelAdapter
, and a list of root nodes.Default implementation of
TreeSelectionModel
.Uses the
TypeCoercer
to convert an arbitrary value to a string.After processing the component event request (including Ajax requests), or the page render request,
checks for the
TapestryConstants.RESPONSE_RENDERER
request attribute,
and invokes it to render the deferred response.A token from a template that defines a namespace prefix.
A component that does not do any rendering of its own, but will delegate to some other object that can do rendering.
Delegating annotation access is used when resolving annotations on a class; it searches the primary
annotation access and if not found there (and
Inherited
is on the annotation being searched),
it searches in the inherited access.Chain of command for InjectionDefaultProvider.
Class that wraps an Request, delegating all its methods.
Base class for
StreamableResourceSource
implementations.Combines multiple symbol providers.
Used to report deprecation warnings for components.
Annotation used by Tapestry to describe the annotated class or package in runtime,
specially in the T5Dashboard page.
Renders a dropdown menu of useful options when developing.
Exception used when trying to assemble a page but different versions of the same class are found.
Disables strict checks Tapestry-IoC or Tapestry may perform on methods.
Marks a method of a page or a component to discard all persistent field changes.
Discards a component's body.
A dispatcher is responsible for recognizing an incoming request.
Contribution to
BeanBlockSource
identifying a block that is used to display a property.Overrides the DOCTYPE of the rendered document (via
Document.dtd(String, String, String)
which can be useful when different component templates that render to the same document disagree about what the correct DOCTYPE
is.The root node of a DOM.
Responsible for injecting script and style links into the <head> and <body> element of the rendered HTML
document.
Representation of a document type.
A capturing of the data from
LexicalHandler.startDTD(String, String, String)
.Represents the presence of a Document Type declaration within a template.
Controls how long an
Alert
is displayed to the end user.The Dynamic component allows a component to render itself differently at different times, by making use of
an external template file.
Used by implementations of
DynamicTemplate
to obtain Block
s as replacements
for elements within the template.A dynamic template is used by the
Dynamic
component to allow
a component to significantly alter its presentation at runtime.A close cousin to
RenderCommand
used inside a DynamicTemplate
.Parses a dynamic template based on a resource or an input stream.
Does the heavy lifting for
DynamicTemplateParserImpl
.Marker annotation placed on a service builder method to indicate that the service should be eagerly loaded: realized
as if a service method had been invoked.
Interface implemented by all service proxies.
Contribution to
BeanBlockSource
identifying a block that is used to edit a property.An element that will render with a begin tag and attributes, a body, and an end tag.
A validator that checks if a given string is well-formed email address.
The model for a component embedded within another component, as defined by the
Component
annotation.Placeholder used when no context is available.
Ends a previously started element (including components, parameters, blocks, etc.).
Makes sure that
PerthreadManager.cleanup()
is invoked at the end of each
request (normally handled by TapestryFilter
).Manages request notifications for the
EndOfRequestListener
interface.Event listener interface for objects that need to know when the current request finishes.
Part of a
MarkupModel
, used to define how end tags are handled when the Document
in rendered out as a
text stream.Persists Hibernate entities as SSOs by storing their primary key in the
Session
.Manages
EntityManager
s for the current thread.Responsible for creating an EntityManager as needed.
Persists Hibernate entities by storing their id in the session.
Persists JPA entities by storing their id in the session.
A basic select model for a particular Enum type.
A value encoder that can be used for arbitrary Enum types.
Deprecated.
this class is superseded by
TypeCoercedValueEncoderFactory
and
scheduled to be removed in Tapestry 5.5Provides a label from enum.
Provides access to environment objects, which are almost always provided to enclosed components by enclosing
components.
Defines a field of a component class that is replaced at runtime with a read-only value obtained from the
Environment
service.Much like
PropertyShadowBuilder
, except that instead of accessing a property of some other service, it
accesses a value from within the Environment
service.Obtains a value from the
Environment
service based on the field type.A non-threadsafe implementation (expects to use the "perthread" service lifecyle).
Holds the current (overrides) Messages object and override id for placemnt into the environment
by FieldValidatorDefaultSourceImpl so ValidationConstraintGenerator implementations have access
to the catalog if necessary.
Provides a client-side element to contain validation errors; this renders as a
<p class="help-block">
.Responsible for writing an error report for the current test, after an assertion fails.
A wrapper around a standard command processor that adds additional exception reporting when a
failure occurs.
Standard validation error presenter.
The core methods related to event handling.
Constant values for common event names fired by Tapestry components.
A collection of parameters that may eventually be passed to an event handler method.
Renders out the values stored inside a
EventContext
.Supplies one parameter value when invoking a component event handler method.
Used to encapsulate the list of
EventHandlerMethodParameterProvider
s for a particular
method of a particular component, providing OperationTracker
behavior as parameter values
are obtained/computed/coerced.A close relative of
ActionLink
except in two ways.Annotation applied to components to document what events a component may trigger.
An analysis of an exception (including nested exceptions).
Analyzes an exception, providing an analysis.
Integral part of the default
ExceptionReport
page used to break apart and
display the properties of the exception.A contribution to the default
RequestExceptionHandler
service, this is mapped to an exception class,
allowing class specific (based on an inheritance search) handling of an exception.Contains information about an analyzed exception.
Responsible for reporting runtime exceptions.
A link the user may press to perform an action (e.g., "Reload page").
Interface implemented by a page used for reporting exceptions.
Used by the default
ExceptionReporter
implementation to convert an exception into
a stream of text that can be stored to a file.Used by
LoggingDecorator
to track which exceptions have been logged during
the current request (the ExceptionTracker is perthread).Contains static methods useful for manipulating exceptions.
A token containing an expression expansion from the template.
An extensible implementation of
JavaScriptStack
that can be used as the implementation of a service.A Tapestry module that is started for every specification which uses Spock's
Tapestry extension.
A token that represents the replacement of a portion of the template with the content of an extension point, or an
override of that extension point.
Functional operations on collections with generics support.
Used to disambiguate which version of
SymbolProvider
is being referenced.ObjectMapperSource
implementation that always returns the
same object returned by instantiating ObjectMapper
.Defines a field within a form.
A
FieldConduit
is an object that effectively replaces the field in the instantiated object.Used to determine which field on a page should receive focus, based on its status.
Allows read/write access directly to a field (bypassing accessors).
A wrapper around
Translator
that combines the translator for a specific Field
and (sometimes) an override of the default validation message (used when an input value
can't be parsed).For a particular field, generates the default
FieldTranslator
for the field.Services to help with field validation and translation.
Responsible for validation of a single field.
For a particular field, generates the default validation for the field, in accordance with a number of factors and
contributions.
Used to create
FieldValidator
s for a particular Field
component.
Interface that can be implemented to provide access to field values based on their name.
Interface that defines a file refactor parser.
Used by
PipelineBuilderImpl
to analyze service interface methods
against filter interface methods to find the position of the extra service parameter (in the filter method).Implementation of
MetaDataExtractor
that is used to set a fixed
value for a fixed meta-data key, when a given annotation is present.The "flash" strategy stores data inside the
session
, just like SessionPersistentFieldStrategy
, but also removes the values from the session on first use.A flow is a a functional interface for working with an ordered collection of elements.
Renders an
<i>
tag with the CSS class to select a FontAwesome 4.7.0 icon.Forces a reload of all caches and invalidates the component class cache.
An HTML form, which will enclose other components to render out the various
types of fields.
Service providing methods related to names that shouldn't be used as form control element
names or ids.
Deprecated.
As of release 5.4, replaced by
OverrideFieldFocus
A FormFragment is a portion of a Form that may be selectively displayed.
Applied to a
Field
, this provides the outer layers of markup to correctly
render text fields, selects, and textareas using Bootstrap:
an outer <div class="field-group">
containing a <label class="control-label">
and the field itself.Exception thrown by Tapestry's
Form
component
when the request method is other than POST.Handles
FormsRequirePostException
s (thrown by the Form
component when the request method was
other than post) by redirecting to the page containing the form.Services provided by an enclosing Form control component to the various form element components it encloses.
An implementation of
FormSupport
that delegates all behavior to another
instance of FormSupport.Provides support to components enclosed by a form when the form is rendering (allowing the components to registry
form submit callback commands), and also during form submission time.
Allows control over the validation concerns of a Form component.
Overrides the default mapping from method name to Clojure function name.
Methods related to the use of Java 5+ generics.
Convenience class for getting a
GenericsResolver
instance.Implementation copied from Tapestry 5.4's GenericUtils (commons package).
Static methods related to the use of JDK 1.5 generics.
An implementation of
ValueEncoderFactory
that returns a pre-wired instance of ValueEncoder
.Used when matching identifiers.
Renders a
<span>
tag with the CSS class to select a Bootstrap Glyphicon.Provide CompilerOptions for the GoogleClosureMinimizer.
Component that renders a Graphviz graph using
@hpcc-js/wasm.
A grid presents tabular data.
Part of
Grid
that renders the markup inside a single data cell.Renders out the column headers for the grid, including links (where appropriate) to control column sorting.
Defines how a
Grid
component (and its sub-components) gain access to
the row data that is displayed on the page.A provider of model data to the sub-components of the
Grid
component.Generates a series of links used to jump to a particular page index within the overall data set.
Used by the
Grid
component to control where the pager portion of the Grid should be displayed.Store pagination information, such as the current page, sort column, and
sort ascending vs.
Standard implementation of
GridPaginationModel
.Renders out a series of rows within the table.
Models the sorting applied to the a
GridDataSource
.GuavaGenericsResolver
implementation using Guava.Filter that adds GZIP compression to the response, if the client supports it.
Allows for deferred execution of logic, useful when trying to get multiple components to coordinate behavior.
Marks a component method as deferred until the end of the
Heartbeat
.Defines the interface for a chain-of-command that updates Hibernate configuration in some way before the
SessionFactory
is created.Defines constants used inside the Tapestry Hibernate intergration.
Marker annotation used to identify services defined in the
HibernateCoreModule
.Defines core services that support initialization of Hibernate and access to the Hibernate
Session
.Contains a set of contributed package names from which to load entities.
A simple implementation of
GridDataSource
based on a Hibernate Session and a known
entity class.Supplements the services defined by
HibernateCoreModule
with additional
services and configuration specific to Tapestry web application.Constants for persistent field strategies.
Manages the Hibernate session for the current thread.
Responsible for creating a Hibernate session as needed.
Page used to see the Hibernate statistics.
Configuration symbols, for use with contributions to
ApplicationDefaults
.A replacement for
HibernateTransactionDecorator
.Service that can create an interceptor that wraps around a service implementation.
Used to record a page property as a value into the form.
Provides some assistance in determining where to place a hidden field based on standard (X)HTML elements.
Used to position a hidden field (as part of a form-related component).
An object that holds some type of other object.
A component used to collect a provided date from the user using the native HTML5 date picker
(<input type="date">)
Implementation of
MarkupModel
that correctly handles HTML5 void
elements.Service related to Tapestry's support of HTML5 features.
An event handler method may return an instance of this class to send an error response to the client.
Handles
HttpError
by invoking Response.sendError(int, String)
.Service that converts the body of an HTTP request to a given target class.
Filter interface for
HttpServletRequestHandler
.The first step in handing an incoming request to the servlet filter,
this constructed as a pipeline.
An event handler method may return an instance of this class to send an specific HTTP status
code to the client.
Handles
HttpStatus
.values returned by event handler methods.Optional annotation, used with
Inject
, which exists to provide the id of an object when it can not be
determined by other means (such as from the field name).Used to "uniquify" names within a given context.
Returns the default asset path unchanged.
A matcher of fully qualified ids.
A wrapper around a
GlobPatternMatcher
used to glob-match service ids.Used to order objects into an "execution" order.
Conditionally renders its body.
Marker annotation that can be placed on a session-persisted object to indicate that the object is immutable, and
therefore does not require end-of-request restoring into the session.
Annotations to control the importing of JavaScript stacks and libraries as well as stylesheets.
Attached to a module class, this annotation identifies other module classes that should also be added to the
Registry.
Implements the
Import
annotation, both at the class and at the method level.Shows an OpenAPI definition viewer based on Swagger UI.
Used to track which methods are implemented by a base class, which is often needed when transforming
a subclass.
Used to search from a particular class up the inheritance hierarchy of extended classes and implemented interfaces.
Provided by
JavaScriptSupport.require(String)
to allow additional, optional, details of the module-based page initialization
to be configured.Performs one initialization step on a newly created object.
Sets the priority for JavaScript initialization scripting.
Filter contributed into the
ComponentRequestHandler
pipeline to set the
activePageName property
.This annotation serves is something of the Swiss Army knife for operations related to injection of dependencies into
an arbitrary method of Java Bean.
Allows components defined in the template to be injected as read-only properties.
Recognizes the
InjectComponent
annotation, and converts the field into a
read-only field containing the component.Used to inject the component which contains this component.
Identifies the
InjectContainer
annotation and adds code
to initialize it to
the core component.Provides some form of injection when the value for an
Inject
annotation is
present.Provides for the injection of specific types of values as resources as opposed to services or objects
obtained from
MasterObjectProvider
.Processes the combination of
Inject
and Named
annotations.Allows a a page (really, the root component of the page) to be injected into another component as a read-only field.
Performs transformations that allow pages to be injected into components.
Deprecated.
Deprecated in Tapestry 5.3, to be removed in a later release.
Annotation used with parameters of service builder methods to identify the service to be injected into the service
builder method via the parameter.
Processes the
InjectService
annotation.Performs injection triggered by any field annotated with the
Inject
annotation or the Inject
annotation.Defines per-instance context values for a transformed PlasticClass.
An object that can instantiate a component.
Simplifies the generation of method instructions for a particular method (or constructor), allowing bytecode to be
created with a friendlier API that focuses on Java type names (names as they would appear in Java source) rather than
JVM descriptors or internal names.
Used in various places to allow some code to be constructed under controlled circumstances.
Stores information about the method whose instructions are being constructed, to make it easier
to share data across multiple instances.
Represents a sequence of integer values, either ascending or descending.
Responsible for constructing the interceptor stack, on demand, by invoking an ordered series of decorators (
DecoratorDef
(which are converted into ServiceDecorator
s).Used to guide Tapestry when coercing from a raw type to a field or parameter type, by forcing Tapestry to coerce to
the intermediate type.
Marker annotation for the internal
JavaScriptStack
.Utility methods class for the Commons package.
Split-out implementation of
InvalidationEventHub
that separates it from ComponentInstantiatorSource
.An extension of
ComponentResources
that represents additional
methods that are private
to the framework and not exposed in any public APIs.Operations shared by
InternalComponentResources
and ComponentPageElement
.The bridge between a component and its
ComponentPageElement
, that supplies all kinds of
resources to the
component, including access to its parameters, parameter bindings, and persistent field data.Additional methods for
FormSupport
used internally by Tapestry.A default layout for a number of internal pages in Tapestry, such as
ServiceStatus
and PageCatalog
.TapestryModule
has gotten too complicated and it is nice to demarkate public
(and stable) from internal (and volatile).Internal marker interface for PropBinding
Extension to
PropertyConduit2
that adds a method to determine the name of the property.Internal view of the module registry, adding additional methods needed by modules.
Stores global per-request data internal to the framework.
Provides the "t5internal" library, that provides common text utilities needed by some of the other
projects' integration tests.
Utilities used within various internal implementations of the tapestry-ioc module.
A very simple schedule, that simply executes the desired job at fixed intervals.
An object which manages a list of
InvalidationListener
s.Base implementation class for classes (especially services) that need to manage a list of
InvalidationListener
s.Deprecated.
In 5.4; use
InvalidationEventHub.addInvalidationCallback(Runnable)
insteadSpecial annotation that is applied to literal
PropertyConduit
s, to inform PropBinding
that the value is, in fact, invariant.Extends
AbstractBinding
with a description and a binding type, with
invariant forced to true.Similar to
Runnable
except that it returns a value.Configuration symbols used by the IoC container.
Deprecated.
In 5.4, with no replacement
A collection of utility methods for a couple of different areas, including creating the initial
Registry
.An operation that, when performed, returns a value (like
Invokable
, but may throw an IOException
.Handles mapped entity class instances using Jackson Databind
when they're returned by event handler methods.
OpenApiTypeDescriber
implementation using
Java JSONSchema Generator,
by default generating JSON Schema 2019-09.Used with
JavaScriptStack
to identify how libraries and modules
within the stack can be aggregated.A callback used with
AjaxResponseRenderer.addCallback(JavaScriptCallback)
.Defines the services related to JavaScript and
JavaScriptStack
s.Used to define a module shim, used to adapt non-AMD JavaScript libraries
to operate like proper modules.
A high level description of a group of related JavaScript libraries and stylesheets.
Assembles the individual assets of a
JavaScriptStack
into
a single resource; this is needed to generate a checksum for the aggregated assets, and also to service the
aggregated stack content.Attempts to match resources against a
JavaScriptStack
, and
possibly disabled minimization based on the stack.Used to generate a list of asset URL paths for the JavaScript libraries
of a JavaScript stack.
Manages the available
JavaScriptStack
s, each of which has a unique name.The JavaScriptSupport environmental is very stateful, accumulating JavaScript stacks, libraries and initialization
code until the end of the main page render; it then updates the rendered DOM (adding <script> tags to the
<head> and <body>) before the document is streamed to the client.
Tapestry-IoC module that
Deprecated.
please use
JettyRunner
insteadLaunches an instance of Jetty.
Module for JMX services.
Defines constants used inside the Tapestry JPA integration.
Contains a set of contributed package names from which to load entities.
A simple implementation of
GridDataSource
based on a
EntityManager and a known
entity class.Defines core services for JPA support.
Constants for persistent field strategies.
Configuration symbols, for use with contributions to
ApplicationDefaults
.Service that can create an interceptor that wraps around a service implementation.
A dense indexed sequence of values.
A callback used with
AjaxResponseRenderer.addCallback(JSONCallback)
.Base class for
JSONArray
and JSONObject
that exists to organize the code
for printing such objects (either compact or pretty).A way of including some text (often, text that violates the normal JSON specification) as part of a JSON object or
array.
A module that integrates JSON into Tapestry in terms of type coercions.
A modifiable set of name/value mappings.
Implementation of
ComponentEventResultProcessor
for JSONObject
, allowing a
component event handler to return a JSONObject that will be sent directly to the client as the reply.An interface that allows an object to be stored as a
JSONObject
or JSONArray
value.Represents the different data types supported by JSON.
Invoked from a fabricated service delegate to get or realize (instantiate and configure) the service implementation.
Used to explicitly select the kaptcha editor block for a property.
Page containing kaptcha edit blocks contributed into the
BeanBlockSource
service configuration.Field paired with a
KaptchaImage
to ensure that the user has provided
the correct value.Part of a Captcha based authentication scheme; a KaptchaImage generates a new
text image whenever it renders and can provide the previously
rendered text subsequently (it is stored persistently in the session).
Defines core services for Kaptcha support.
Extension of the
Producer
interface, adding property for getting the Kaptcha image
width and height (used when rendering the <img> element).Defines constants used by the
KaptchaModule
and related components.A key/value pair.
Generates a <label> element for a particular field.
An advisor that identifies methods which can be evaluated lazily and advises them.
The result of the evaluation of a
LazyFunction
.A lazy function is used to populate a
Flow
incrementally.A function that returns a value, allowing the computation of that value to be deferred as late as possible.
Used to configure the
ComponentClassResolver
, to allow it to map library names to library root packages (the
application namespace is a special case of this).Implementation of
ComponentCallback
used for lifecycle notifications
that do not have an event, and can therefore never be aborted.Wrapper around a lifecycle, a set of resources for a service, and an underlying
ObjectCreator
for a service
that allows the service lifecycle to alter the way that the service is created (this is needed for the more advanced,
non-singleton types of service lifecycles).A link is the Tapestry representation of a URL or URI that triggers dynamic behavior.
A service that allows listeners to be registered to learn about
Link
creation.Deprecated.
Use
LinkCreationListener2
insteadA default
LinkCreationListener2
that triggers the EventConstants.DECORATE_COMPONENT_EVENT_LINK
and
EventConstants.DECORATE_PAGE_RENDER_LINK
events as links are generated.Identifies how a
Link
should handle security.A source for
Link
objects.Generates a client-side hyperlink that submits the enclosing form.
A facade around
ComponentEventLinkTransformer
and PageRenderLinkTransformer
.Intercepts some methods of
ComponentEventLinkEncoder
, passing the returned Link
s
through methods ofLinkTransformer
.Renders a List, but rendering an unordered list.
Binding type for literal, immutable values.
Binding factory that treats the expression as a literal string.
A PropertyConduit for a literal value in an expression, such as a number, or "true", "false" or "null".
A special marker annotation which limits the search for possible services to just the same module containing
the service being injected.
Used to present a date, formatted in the time zone of the client browser.
Contains code borrowed from commons-lang.
Standard analyzer that places requests from the "localhost", "127.0.0.1", "0:0:0:0:0:0:0:1%0", or :"0:0:0:0:0:0:0:1" onto the white list.
Sets the thread's locale given a desired locale.
Given a set of supported locales, for a specified desired locale, sets the current thread's locale to a supported
locale that is closest to the desired.
Generates name variations for a given file name or path and a locale.
Variable available inside a
LocalVariableCallback
.A callback for generating code where a local variable is in effect.
Interface implemented by objects which carry a location tag.
A kind of tag applied to other objects to identify where they came from, in terms of a file (the resource), a line
number, and a column number.
Implementation class for
Location
.Responsible for rendering a
Location
.An object that can be locked, at which point most of its functionality is disabled.
Base class for classes that need to manage a ReadWriteLock.
Marker annotation for component methods to enable debug-level logging.
A wrapper around SLF4J's LoggerFactory that exists to allow particular projects to "hook" the creation of Logger
instances.
Simple wrapper around SLF4J's LoggerFactory.
A service used in conjunction with a service advisor method to add logging advice to a service.
Service that can create a logging interceptor that wraps around a service implementation (or interceptor).
Looks for the
Log
marker annotation and adds method advice to perform the
logging.A basic looping component; loops over a number of items (provided by its source parameter), rendering its body for each
one.
Identifies how a
LoopFormState
component stores state into the FormSupport
object.An output stream that wraps around a
Mac
(message authentication code algorithm).InjectionDefaultProvider that operates using a Map from type to value.
Implementation of
Messages
based on a simple Map (of string keys and values).Object passed into a service contributor method that allows the method provide contributed values to the service's
configuration.
Service which provides a list of mapped entities.
Default
MappedEntityManager
implementation.Interface for operation
Flow.map(Mapper)
to define how Flow elements are mapped from one type
to another (or otherwise transformed).A generalization of
Mapper
for a two-input function.Provides symbol values from a Map of symbol names and symbol values (typically provided by a Tapestry IOC service
configuration).
Interface implemented by objects which need to disambiguate services with marker annotations.
Used to define one or more
ServiceDef#getMarkers() marker annotations for a service implementation.
Constants used when rendering page markup.
Used by a the DOM to determine how to produce markup.
An object which will perform rendering of a page (or portion of a page).
Filter interface for
MarkupRenderer
, which allows for code to execute before
and/or after the main rendering process.Terminator for the [@link MarkupRenderer} pipeline, which exists to invoke
PageRenderQueue.render(org.apache.tapestry5.MarkupWriter)
.Utility methods related to generating markup.
An interface used by objects, such as Tapestry components, that need to render themselves as some form of XML markup.
Default, empty implementation of
MarkupWriterListener
.Source for
MarkupWriter
instances.An interface that allows objects to be alerted after an element is started, and after an element is ended.
A service that acts as a chain-of-command over a number of
ObjectProvider
, but
allows for the case where no object may be provided.Implementation that delegates, via its configuration, to a real implementation based on the content type of the
resource.
Optional, but typically used, annotation for service decorator methods, used to define which services the decorator
applies to.
ComponentLibraryInfoSource
implementation based on the pom.xml and pom.properties files
Maven places in the /META-INF/maven/[groupId]/[artifactId] folder.Enforces a maximum integer value.
Validates that a string value has not exceeded a maximum length.
Creates an MBean server and registers MBeans with the created server.
Implementation of the message: binding prefix -- we simply get the message key and store it inside at
LiteralBinding
.Obtained from a org.apache.tapestry5.ioc.Messages, used to format messages for a specific localized message
key.
The default message interpolation algorithm uses
Locale.getDefault()
.Provides access to a messages catalog, a set of properties files that provide localized messages for a particular
locale.
Represents a bundle of properties files that can be used to collect properties that are eventually used to form a
Messages
.Generates constraints from the containing component's property file.
Implementation of
Messages
based around a ResourceBundle
.A utility class that encapsulates all the logic for reading properties files and assembling
Messages
from
them, in accordance with extension rules and locale.Class that holds information about a messages properties file for tracking.
Allows for the specification of per-component meta-data.
Meta-data keys that are applied to components and pages.
Used to extract a meta data value from a component annotation.
Used to lookup meta data concerning a particular component.
Service that makes it easy to identify a class annotation and use its presence, or the value of an attribute,
to set a meta-data key.
MethodAdvice is a special callback that is threaded into the implementation of a method.
Interface used with service advisor methods to define advice.
Exception raised when there's an attempt to create a method which
already exists in a class.
Exception thrown when a method body fails to compile; this will allow the method body to be displayed to the user on
the request failure page.
Describes a
PlasticMethod
in terms of a method name, a set of modifiers
(public, private, static, final, etc.), a return type, types of method arguments,
and types of checked exceptions.Similiar to
Method
, this allows a method of a Plastic class to be invoked regardless of visibility.A representation of the invocation of a method that allows the behavior of the method to be advised: either by
changing parameter values, or by changing the return value, or by catch or throwing different exceptions.
Bundles together the fixed (same for all instances) information needed by a
MethodInvocationBundle
.Implementation of
MethodInvocationResult
for failed
invocations (where a checked exception was thrown).The result of a method invocation, which
encapsulates the actual return value (if any), as well as any checked exception.
Captures the result of invoking a method.
Implementation of
MethodInvocationResult
for successful
method invocations.Utility used to iterate over the publicly visible methods of a class or interface.
Used by
LoggingDecoratorImpl
to delegate out logging behavior to a
separate object.Access to the parameters of a method, in particular, any visible annotations
on that method.
Manages a cache value as the result of invoking a no-arguments method.
A representation of a
Method
, identifying the name, return type, parameter types and
exception types.Maps a method from a service interface to a fully-qualified Clojure function name, as a Clojure
Symbol
.Validates that a string value has a minimum length.
Defines an implementation mixin for a component.
A marker annotation applied to a mixin to indicate that the mixin's render state behavior is deferred until after the
the behavior of the component to which the mixin is attached.
Looks for the
MixinAfter
annotation and sets the mixinAfter flag
if present.Used to attach one or more instance mixins to an embedded component.
Used to attach one ore more instance mixin to an embedded component.
Supports the
Mixin
annotation, which allows a mixin to
be part of the
implementation of a component.Deprecated.
In 5.4, with no replacement
A module within the Tapestry IoC registry.
The source for the module instance needed by any service builders, service contributors and service decorators that
are mapped to instance methods.
Used to change the configuration object which will be used to
configure RequireJS; callbacks can modify
and override the configuration after it was created
by the
ModuleManager
service based on contributed JavaScriptModuleConfiguration
s.Defines the contents of a module.
Marker annotation for a method which creates a
ModuleDef
.Extended version of
ModuleDef
introduced in Tapestry 5.1 to allow for service
advisors (an improvement on service decorators).Handler contributed to
AssetDispatcher
with key "modules".Responsible for managing access to the JavaScript modules.
Default implementation for
MongoDB
Defines services which are responsible for MongoDB initializations and connections.
Default implementation for
MongoDBSource
Configuration symbols, for use with contributions to
ApplicationDefaults
.Combines multiple values to form a single composite key.
Responsible for detecting and processing file upload requests, using Jakarta Commons FileUpload.
Implementation of multipart decoder for servlets.
Filter that decodes an incoming multipart request.
Deprecated.
Deprecated in 5.3; use the
AjaxResponseRenderer
service instead of
returning an instance of MultiZoneUpdateDeprecated.
Deprecated in 5.3
Mutable version of
ComponentModel
used during the transformation phase.Internal implementation of
MutableComponentModel
.A mutable version of
EmbeddedComponentModel
that allows the parameters to be
incrementally stored.A cache of translations from type names to internal names and descriptors, as well as a cache from MethodDescription
to method descriptor.
Simple, thread-safe associative array that relates a name to a value.
Maps a service interface to a Clojure namespace.
Module which defines the options needed to run Tapestry without Bootstrap.
A node within the DOM.
The none validator is does nothing on either the client or the server; primarily it is employed
as the validate parameter, to override the validation specified in the
Validate
annotation of a property.Implementation of
ParallelExecutor
used when the thread pool is disabled.Marker annotation for properties which are non-visual, and so should not appear (by default) inside a
BeanModel.
A mixin that attaches to an element that renders an element.
A
ComponentEventCallback
used for notification events.Marks a method as specifically not-lazy, even if other methods in the same interface are being advised as lazy.
A null implementation of
AnnotationProvider
, used when there is not appropriate source of annotations.An implementation of
GridDataSource
used when the value null is provided as the
source.Treats the expression as the name of a
NullFieldStrategy
, accessed via the NullFieldStrategySource
service.A source for
NullFieldStrategy
instances based on a logical name.Interface for defining the basic parse and toClient operations.
A wrapper around NumberFormat.
Uses a
NumericTranslatorSupport
to provide proper locale-aware
support for all the built-in numeric types.Used to generate the client-side JSON specification for how a number-based validator operates.
Renders an Object[] array as an unordered list.
A catch-all for type Object that reports the return value as an error.
Interface used to encapsulate any strategy used defer the creation of some object until just as needed.
An object which can, when passed a
ServiceBuilderResources
, create a corresponding ObjectCreator
.Defines an object which can provide access to services defined within a
Registry
, or
to objects or object instances available by other means.Base service locator class used when only the module is known (i.e., when instantiating a module
class).
Service that provides
ObjectMapper
instances for specific mapped entity classes.Object providers represent an alternate way to locate an object provided somewhere in the
Registry
.A strategy interface used for converting an object into markup that describes that object.
Logic for handling one shot semantics for classes; classes that include a method (or methods) that "locks down" the
instance, to prevent it from being used again in the future.
Marks a method as a handler for a client side event.
Provides implementations of the
Component.dispatchComponentEvent(org.apache.tapestry5.runtime.ComponentEvent)
method, based on OnEvent
annotations and naming conventions.Used to document the
InstructionBuilder
and TryCatchBlock
Recognizes requests where the path matches the value of
SymbolConstants.OPENAPI_DESCRIPTION_PATH
(/openapi.json
by default).Service used to generate OpenAPI 3.0 description in JSON format for an application
REST endpoints (i.e.
Interface that describes the type of a REST endpoint parameter, return type or request body.
Describes a method as one that should be operation tracked.
Used from a service advice method to identify methods with the
Operation
annotation, and add advice for those methods.An exception caught and reported by an
OperationTracker
; the trace property
identifies what operations were active at the time of the exception.Used to track some set of operations in such a way that a failure (a thrown RuntimeException) will be logged along
with a trace of the stack of operations.
Annotation to be be used in exception classes whose instances are not meant to be
logged in OperationTracker.
Core implementation that manages a logger and catches and reports exception.
Makes sure the operations tracker is notified knows that a service is being realized.
Add support for the
Operation
annotation on component class methods.An optional interface implemented by objects that are persisted in the
Session
.Marks a service contribution method within a module as being optional: it is not an error if the contribution does not match against an actual service.
Defines a group of related options.
A single option within a
OptionGroupModel
.Used with a service decorator method to control the order in which decorations occur.
A wrapper that allows objects of a target type to be ordered.
Represents an order constraints for
OrderedConfiguration
.Constructs order constraints for
OrderedConfiguration
.Object passed into a service contributor method that allows the method provide contributed values to the service's
configuration.
Used to order objects into an "execution" order.
A wrapper around a collection of IdMatchers.
A component for formatting output.
Used to output raw markup to the client.
A mixin that let a
Field
gain focus.Parses lines like this, in which both artifact and package are changed:
{tapestry-ioc/src/main/java/org/apache/tapestry5/ioc => commons/src/main/java/org/apache/tapestry5/commons}/ObjectProvider.java
.Parses lines like this, in which just the package is changed:
commons/src/main/java/org/apache/tapestry5/{ioc => commons}/Messages.java (98%)
.Adds entity classes from a given set of packages to the configuration.
Represents a unique page within the application.
Page construction statistics for the page.
Annotation for a field for which the page activation context handlers (onActivate and onPassivate) should be created.
Fires the
EventConstants.PASSIVATE
event on a page, and collects the result, converting
it to an array of objects.Provides the page activation context handlers.
Responsible for firing the EventConstants.ACTIVATE event on the page.
Method annotation used for methods that should be invoked when the page is first attached to a request.
A service which defines whether cache page instances should have soft references pointing to
it (the default) or strong, non-garbage-collectable ones.
A way of capturing the name of a page and the page activation context so that, at a future date,
the page can be invoked with that data.
Lists out the currently loaded pages, using a
Grid
.Class that encapsulates a classloader context for Tapestry's live class reloading.
Service that creates PageClassLoaderContext instances (except the root one)
when a class in a controlled page is first used in the Tapestry page pool.
Default PageClassLoaderContextManager implementation.
Shows information about the page classloader contexts.
Shows graph showing the dependencies of all already loaded pages and its compnoents, mixins and base classes.
Method annotation used for methods that should be invoked when the page is detached at the end of a request, before
it is returned to the page pool for later reuse.
Interface used to programatically render a page, forming a
Document
which can then
be manipulated or streamed to a
PrintWriter.Used by the
PageLoader
to create partialar page elements.Deprecated.
in 5.3.4, as
PageLifecycleListener
has been deprecatedSimilar to
RenderPhaseMethodWorker
but applies to annotations/methods
related to the overall page lifecycle.Defines a way for different aspects of a page to add callbacks for important lifecycle events.
Deprecated.
in 5.3.4, replaced with
PageLifecycleCallbackHub
Generates a render request link to some other page in the application.
Method annotation used for methods that should be invoked once the page is fully loaded.
Instantiates a fully loaded, configured instance of a Tapestry page.
There's still a lot of room to beef up
ComponentAssembler
and
EmbeddedComponentAssembler
to perform more static analysis, but
that may no longer be necessary, given the switch to shared (non-pooled) pages in 5.2.Service used to render page markup using a MarkupWriter.
Used when a component event handler returns a string value.
Injects a
<meta/>
element into the <head/>
to identify the Tapestry page name.Used to perform a pre-load of pages, at startup time.
Dispatches incoming requests for render requests.
A service that allows other services to create page render links.
Allows the default
Link
for a page render request to be replaced.A wrapper around
RenderQueue
, but referencable as a (per-thread) service.This services keeps track of the page being rendered and the root command for the partial render, it is therefore
request/thread scoped.
Filter interface for
PageRenderRequestHandler
, which allows extra behaviors to be injected into the
processing of a page render request.Handles a invocation related to rendering out a pages complete content.
Handles a page render request by activating and then rendering the page.
Used with
PageRenderRequestHandler
and
PageRenderRequestFilter
to define the logical page name and
activation context for the request.Marker annotation for a method that should be invoked when a page is reset.
Implementation of the
PageReset
annotation.Deprecated.
in 5.3.4
Service responsible for writing a full page markup response.
Access to localized page instances (which are now shared singletons, starting in release 5.2).
The special case for pages, where the template is searched for in the web application context.
This class is used to run a Tapestry app in a single-threaded, in-process testing environment.
Used in conjunction with
PageTester
to mock up and/or stub out portions of Tapestry that
need to be handled differently when testing.Multiple selection component.
A service that allows work to occur in parallel using a thread pool.
Annotation placed on a field to indicate that it is, in fact, a component parameter.
A facade around
Binding
and InternalComponentResources
that is used to instrument
fields with the Parameter
annotation.Model for a formal parameter of a component.
Wrapper for HttpServletRequest that overrides the parameter methods of the wrapped request.
A parameter block to be passed to a component as a parameter.
Holds single or multivalued values.
Responsible for identifying parameters via the
Parameter
annotation on
component fields.Defines an Ajax-oriented partial page render, wherein a render of a portion of a page occurs, and the content is
stored into a key ("content") of a
JSONObject
, which is sent to the client side as
the final response.A filter (the main interface being
PartialMarkupRenderer
) applied when performing a partial page render as
part of an Ajax-oriented request.Terminator for the
PartialMarkupRenderer
pipeline, which ultimately invokes
PageRenderQueue.renderPartial(org.apache.tapestry5.MarkupWriter, org.apache.tapestry5.json.JSONObject)
.Service that provides methods that render
Block
s (<t:block>
in the template),
component instances and RenderCommand
s to a String
or
org.apache.tapestry5.dom.Document
in a programatic way.A version of
TextField
, but rendered out as an <input type="password"> element.Central location for logic related to building client-side paths, taking into account
the context path (if any), and the
SymbolConstants.APPLICATION_FOLDER
(if any).A service that executes a job at intervals specified by a
Schedule
.Identifies a field as persistent, meaning its value persists from one request to the next.
Encapsulates a Hibernate entity name with an entity id.
Encapsulates a JPA entity name with an entity id.
Constants for persistent field strategies.
Used to configure a PersistenceUnitInfo, which is used to
create an EntityManagerFactory.
Encapsulates persisted property information for an entire page.
Represents a previously stored change to a persistent field, within the context of a particular page of the
application.
Handle persistent property changes.
Defines how changes to fields (within components, within pages) may have their values persisted between requests.
Manages the persistent locale stored in the browser (inside the URL).
Converts fields with the
Persist
annotation into persistent fields.Manages per-thread data, and provides a way for listeners to know when such data should be cleaned up.
Manages a per-thread OperationTracker using a ThreadLocal.
Allows a service to exist "per thread" (in each thread).
Provides access to per-thread (and, by extension, per-request) data, managed by the
PerthreadManager
.Creates a pipeline from a service interface and an ordered list of filters.
The representation of a class while it is being instrumented and transformed.
Describes a transformed class about to be loaded.
The interface for a "shim" class that provides the necessary hooks needed
by
FieldHandle
and MethodHandle
implementations for a particular,
instantiated PlasticClass
.Allows a listener to be notified about classes about to be loaded by the manager's class loader.
Methods for adding and removing
PlasticClassListener
s .Responsible for managing a class loader that allows ASM
ClassNode
s
to be instantiated as runtime classes.A wrapper around a
PlasticClass
that allows the class to be converted into a concrete class, once all
transformations are complete.Interface for defining how a
PlasticClass
is transformed.Represents a field of a class being transformed.
Manages the internal class loaders and other logics necessary to load and transform existing classes,
or to create new classes dynamically at runtime.
A builder object for configuring the PlasticManager before instantiating it.
Delegate to the
PlasticManager
that performs the actual transformations of the class.A method of a transformed class.
A service used to create proxies of varying types.
Utilities for user code making use of Plastic.
Class used to represent a field name and its type for
PlasticUtils.implementFieldValueProvider(PlasticClass, Set).
Annotation for methods that should be invoked after injection.
Used when filtering a collection of objects of a given type; the predicate is passed
each object in turn, and returns true to include the object in the result collection.
Checks to see if a class has a given prefix to its class name.
Identifies when the
PagePreloader
should perform its loading.Marks a service as not eligible for decoration.
Marker annotation used to denote a service that is the primary instance of some common interface.
Adds a "required" constraint for any property of whose type is a primitive (not a wrapper or reference) type.
Collects together information needed to write code that involves primitive types, including
moving between wrapper types and primitive values, or extracting a primitive value from
the
StaticContext
.Utility for collecting the output of a
PrintWriter
.A filter, used only in production mode, that does a "pre-flight check" that the indicated component
actually exists.
A component used to implement the progressive
enhancement web design strategy; the component renders itself with a
simplified initial content (i.e., "loading
...") and an Ajax request then supplies the component's true body.
Base class for bindings created by the
PropBindingFactory
.Binding factory for reading and updating JavaBean properties.
Used when constructing a component's
Messages
object.Annotation for fields for which accessor methods (getters and setters) should be created.
A wrapper around the JavaBean Introspector that allows more manageable access to JavaBean properties of objects.
Used when converting a field into a property (that is, adding accessor methods for the field) to identify
which method(s) to create (a getter to access the value and/or a mutator to modify the value).
Provides access to a single property within a class.
Used to read or update the value associated with a property.
Extension to
PropertyConduit
that adds a method to access the generic property type.Companion class for
PropertyConduit
instances created by the
PropertyConduitSource
.A source for
PropertyConduit
s, which can be thought of as a compiled property path
expression.Outputs a single property value.
Contains blocks for displaying basic property types; the blocks are contributed to the
BeanBlockSource
service.A page that exists to contain blocks used to edit different types of properties.
Defines a context for editing a property of a bean via
BeanEditor
.Used to edit a single property of a bean.
Exception thrown when there is a problem parsing a property expression using the ANTLR property expression grammar.
Part of a
BeanModel
that defines the attributes of a single property of a
bean.Provides context information needed when displaying a value.
Provides access to blocks and messages used when overriding property labels, and property display or edit blocks.
Creates a "shadow" of a property of an object.
Provides a label from a property of the passed object.
Interface that can be implemented to provide access to field values based on their name.
Worker used to gather PlasticUtils.FieldInfo instances and implement
PropertyValueProvider for any class that has them.
Provides the getter and setter methods.
Identifies frames for various proxy classes (class name starts with a '$' and there's no line number.
Marks an event handler method to be published as an event to be called in JavaScript
through the
t5/core/ajax
function when the options
parameter has an element
attribute.Tapestry internal mixin used to implement the
PublishEvent
event logic.Defines constants for common query parameters passed in requests from the client.
Minimal implementation used for testing, that does no logging, tracking, or exception catching.
A radio button (i.e., <input type="radio">).
A container of
Radio
components, used to identify the element name used when rendering the individual radio
buttons.A wrapper component around some number of
Radio
components, used to organize the selection and define the
property to be edited.Provides access to random data that can be used when populating a test database with "reasonable" data.
A specialized node in the document tree that contains raw markup to be printed to the client exactly as-is.
An implementation of
FieldConduit
for a read-only component field.A utility class for managing a cacheable result that can be recomputed when needed.
Component that marks the place in the template the
recursion should happen.
Class that makes the link between
Recursive
and RecursiveBody
.Decorator for
ObjectCreator
that ensures the service is only created once.
Interface that represents a parent-children relationship.
Interface implemented by classes which converts objects to
RecursiveValue
instances.A reducer takes an accumulator value and a single value from a collection and computes a new
accumulator value.
Defines the types of reference the page cache can use.
Enforces that the input matches a provided regular expression.
Uses a regular expression to identify which CSS class to apply to a frame.
Used by the
TapestryIOCJUnit4ClassRunner
to configure a test Registry
Public access to the IoC service registry.
Used to construct the IoC
Registry
.Event hub for notifications when the IOC
Registry
shuts down.Deprecated.
In Tapestry 5.3, to be removed in a later release.
Used in conjunction with the
TapestryIOCJUnit4ClassRunner
to determine the registry lifecycleStartup service for Tapestry IoC: automatically invoked at registry
startup to execute a series of operations, via its ordered configuration of Runnable objects.
A wrapper around
InternalRegistry
that exists to expand symbols in a service id before
invoking ObjectLocator.getService(String, Class)
.Used by
HiddenFieldLocationRules
to identify where a hidden field may be placed
relative to a particular element.Controls the position of newly added PropertyModel inside a
BeanModel.
Reloadable object creator for non-service objects.
Responsible for creating a
ReloadableServiceImplementationObjectCreator
for a service implementation.Returns an
ObjectCreator
for lazily instantiating a given implementation class (with dependencies).Optional interface that may be implemented by a service implementation (or even
a proxy to give the service implementation
more control over its lifecyle.
Forces a reload of all caches and invalidates the component class cache.
Used inside a
AjaxFormLoop
to remove the current row from the loop.Base interface for objects that can render markup output using a
MarkupWriter
.Allows any
Renderable
object to act as a Block
.Forces a client element to render its client id by ensuring that
ClientElement#getClientId()
is called.A command used during rendering of a page.
Processor for objects that implement
RenderCommand
(such as
BlockImpl
), used with an Ajax component event.Ensures that all components implement
RenderCommand
by delegating to
RenderCommand.render(org.apache.tapestry5.MarkupWriter, org.apache.tapestry5.runtime.RenderQueue)
.Renders an "disabled" attribute if the containing component
is disabled
.Used to render out all informal parameters, at the end of the
BeginRender
phase.This mixin triggers component event notifications when the
attached component enters its
BeginRender
and AfterRender
render phases.Renders out an object using the @
Primary
ObjectRenderer
service.Converts one of the methods of
Component
into a chain of
command that, itself,
invokes certain methods (render phase methods) marked with an annotation, or named in a specific
way.A stateful object that manages the process of rendering a page.
Exception used when rendering, to capture the stack of active components (for propery reporting in the exception
page).
An annotation that may be placed on a JavaBean to re-order the properties.
Generic version of
HttpServletRequest
, used to encapsulate the Servlet API version, and to
help bridge the differences between Servlet API and Porlet API.Annotation that may be placed on parameters of event handler methods,
usually in page classes.
Constants used when processing requests from the client web browser.
Determines the reuest encoding for the given page and applies that to the request, so that parameters may be properly
decoded.
Filter for the
RequestHandler
pipeline used to intercept and report
exceptions.Service invoked when an uncaught exception occurs.
Filter interface for
RequestHandler
.Service used to store the current request objects, both the Servlet API versions, and the
Tapestry generic versions.
Dumb data holder for per-request data.
Service interface for the RequestHandler pipeline
service.
Basic implementation of
Request
that wraps around an
HttpServletRequest
.Uses
OperationTracker
to add an operation generally describing each request.Per-thread service that caches page instances for the duration of the request, and is also responsible for tracking
the active page (the page which will ultimately render the response).
In Tapestry 5.1, the implementation of this worked with the page pool (a pool of page instances, reserved
to individual requests/threads).
Annotation that may be placed on parameters of event handler methods.
Used to manage the relationship between the security of a request and the security of a page.
A validator that enforces that the value is not null and not the empty string.
Represents a resource on the server that may be used for server side processing, or may be exposed to the client
side.
Tracks resources (at least, resources that can change because they are on the file system) and
acts as an
UpdateListener
to check for changes and notify its listeners.Used by some
ResourceTransformer
implementations to track additional dependencies that can arise
when the underlying resource being transformed can be dependent on other resources (for instance, if it has the
notion of "including" or "importing" content).Deprecated.
Deprecated in 5.4 with no replacement; see release notes about classpath assets moving
to /META-INF/assets/, and content checksums inside asset URLs
Gutted implementation; will be removed in Tapestry 5.5.
Deprecated.
Deprecated in 5.4 with no replacement; see release notes about classpath assets moving to /META-INF/assets/.
Certain kinds of resources can be minimized: this primarily refers to JavaScript and CSS, both of which contain
whitespace, comments and other features that can be reduced.
Responsible for streaming the contents of a resource to the client.
Used to customize the behavior of
ResourceStreamer.streamResource(org.apache.tapestry5.commons.Resource, java.lang.String, java.util.Set)
.Makes a
Resource
available as a SymbolProvider
A transformer is used to read a
Resource
and pass it through a transformation stage, to get a
stream that can be used on the client side.API agnostic wrapper for generating a response.
Used to determine if the client supports GZip compression of the response.
Used to customize the response prior to streaming content to the client; typically this is used to
set special headers.
Implementation of
Response
that wraps around an underlying HttpServletResponse
.Public facade around internal services related to rendering a markup response.
Implementation of
Response
that delegates all method invocations to a delegate
instance.Exception used when a request is made to a page with REST endpoint event handlers
but doesn't match any of them.
Annotation that provides some information about REST event handler methods for OpenAPI
description generation.
Defines services and and contributions for the Tapestry integration with Jackson Databind.
A listener that invokes
Session.restoreDirtyObjects()
.Service which provides REST-related utilities.
Default RestSupport implementation.
Deprecated.
This rarely used annotation is likely to cause threading issues starting in Tapestry 5.2 (which no longer
pools pages
but uses shared instances with externalized mutable state)
Identifies fields with the
Retain
annotation, and "claims" them so that no
special work will occur on them.Recognizes a request for the application root (i.e., "/") and handles this the same as a render request for the
"Start" page.
SAX-based template parser logic, taking a
Resource
to a Tapestry
template file and returning
a ComponentTemplate
.Used with
PeriodicExecutor
to control the schedule for when jobs execute.An optional annotation that may be placed on a service building method of a module, or on the implementation class
(when using service binding).
Defines constants for built-in scopes (used with the
Scope
annotation.A marker annotation that indicates that the page in question may only be accessed via HTTPS.
Possible values of the "secure" parameter for components that use a
SelectModel
(such as Select
), to control whether the submitted
value must be one of the values in the SelectModel.Select an item from a list of values, using an [X]HTML <select> element on the client side.
Defines the possible options and option groups for a <select> [X]HTML element.
Used to create an
SelectModel
.Callback interface that allows for visiting the option groups and option models of a select model in correct order
order.
Base class for creating Selenium-based integration test cases.
Used in conjunction with the
Inject
annotation to identify a service by name and not by type.Provided by the
ServiceActivityScoreboard
to track a single service's state and activity.Provides access to the runtime details about services in the
Registry
.Used to update the status of services defined by the
ServiceActivityScoreboard
.Provided by a
AdvisorDef
to perform the advice (by invoking methods on a MethodAdviceReceiver
).Adds support for the
Service
annotation (which can be applied to fields or parameters), which is used to
disambiguate injection when multiple services implement the same service interface.Allows a module to bind service interfaces to service implementation classes in support of autobuilding services.
Allows additional options for a service to be specified, overriding hard coded defaults or defaults from annotations
on the service.
A callback used to create a service implementation.
Basic implementation of
ObjectCreator
that handles invoking a method on the module
builder, and figures out the correct parameters to pass into the annotated method.Extends
ServiceResources
with additional methods needed only by the service builder
method, related to accessing a service's configuration.Interface that defines listeners to services getting their distributed configuration.
Service that collects the
ServiceConfigurationListener
s.A service decorator is derived from a
DecoratorDef
and is responsible for
building an interceptor around an existing implementation (called the "delegate").A wrapper around a decorator method.
Service definition derived, by default, from a service builder method.
Extension to
ServiceDef
containing new methods added for Tapestry 5.1.Introduced for Tapestry 5.3, contains new methods to provide access to annotations on the class,
and on methods of the class.
Simple interface used when invoking a bind() method on a module class.
An optional annotation that may be placed on a service building method of a module, or on the implementation class
(when using service binding via the
ServiceBinder
).A very late worker related to the
Inject
annotation that, when all other forms of injection have failed,
matches the field type to a service interface.Allows certain types of lifecycles to control exactly how services are instantiated.
Extension to
ServiceLifecycle
that adds an additional method.Provides access to user defined lifecycles (beyond the two built-in lifecycles: "singleton" and "primitive").
Used to override built in services.
Used in concert with
SerializationSupport
to convert service tokens back
into service proxies.Token that replaces a service proxy when the proxy is serialized.
Contains resources that may be provided to a service when it initializes, which includes other services defined in
the registry.
Implementation of
ServiceBuilderResources
.Page used to see the status of all services defined by the
Registry
.Service interface for initializing a servlet application, as a pipeline.
Filter interface for
ServletApplicationInitializer
.Used as a wrapper around code that runs a web server, so that
the server may be shut down at the end of the test.
A wrapper around
ServletContext
that makes init-parameters accessible as symbols.Generic version of
HttpSession
, used to bridge the gaps between the Servlet API and the Portlet API.The type of lock used to access atttributes in the
Session
.Stores ASOs in the
Session
, which will be created as necessary.Used to map a property of a page or component to value stored in session.
Looks for the
SessionAttribute
annotation and converts read and write access on such
fields into calls to the Session.getAttribute(String)
and Session.setAttribute(String, Object)
.A thin wrapper around
HttpSession
.A wrapper around
ReentrantReadWriteLock
used to manage the lock for a session.Analyzes a session-persisted object, specifically to see if it is dirty or not.
A strategy for storing persistent page properties into the
session
.Interface for serializable objects stored in the HTTP Session that can be restored to active state via
the Hibernate Session.
Marker annotation for a property that is a session state object (SSO) as controlled by
the
ApplicationStateManager
.Marker annotation for methods that should be executed during the SetupRender phase.
The severity of an
Alert
, used primarily to control how it is decorated when presented to the user on the client side.Implementation of
SymbolProvider
that only supports a single key/value pair.The basic implementation of a service lifecycle, which simply uses the
ObjectCreator
to create an instance of the service when asked.Responsible for capturing the content for a single zone and storing it into the JSON reply object.
Used to explicitly define whether a property should be considerable sortable or not.
Identifies how a single column (identified as a
PropertyModel
) is sorted.Marker annotation for services that are specific to the Spock/Tapestry
integration module.
Constants used with the Spring integration library.
Module for Tapestry/Spring Integration.
A wrapper that converts a Spring
ApplicationContext
into a set of service definitions,
compatible with
Tapestry 5 IoC, for the beans defined in the context, as well as the context itself.An interceptor for the
StreamableResourceSource
service that handles caching of content.Specialization of
SRSCachingInterceptor
that only attempts to cache
compressed resources.Loops the result through the
ResourceMinimizer
service.A simple, streamlined implementation of
Stack
.A contribution to an extensible
JavaScriptStack
.Defines the types of extensions to a JavaScript stack that can be contributed to an extensible JavaScript stack.
Used by
ExceptionDisplay
to characterize each stack frame that is
presented.CSS classes, from the default CSS stylesheet, used with
StackTraceElementAnalyzer
.The start element of a component within the template.
The start of an ordinary element within the template (as opposed to
StartComponentToken
,
which represents an active Tapestry token.An annotation that may be placed on a startup method of a module.
Represents a public module method (static or instance) with a
Startup
annotation.Annotation that may be placed on parameters of event handler methods to define them
as having a static value.
Stores static context information needed by a transformed PlasticClass; this includes data such as
injections.
Identifies requests that are for actual resource files in the context.
An
ObjectCreator
for a statically identified object (typically, a bean from the
Spring application context).Provides a single object of a given type.
Used in
ServiceActivity
to identify the state of the service in terms of its overall lifecycle.A service implementation builder that operates around a
StrategyRegistry
, implementing a version of the Gang
of Four Strategy pattern.A key component in implementing the "Gang of Four" Strategy pattern.
An object, derived from a
Resource
, that can be streamed (ultimately, to a client web browser).Defines additional features desired when accessing the content of a
Resource
as
a StreamableResource
.Converts
Resource
s into StreamableResource
s, and may be responsible for
transforming resources based on file extension.An event handler method may return an instance of this class to trigger the rendering
of a particular page without causing a redirect to that page; the rendering takes place as part
of the original component event request, thus forming the opposite of Tapestry's normal
redirect-after-event behavior.
Used to trigger the rendering of a particular page without causing a redirect to that page.
An alternate response from a component event handler method used to directly provide a stream of data to be sent to
the client, rather than indicating what page to send a render redirect request to.
Creates "interned" strings that are unique for the same content.
Implementation of
Location
used when the underlying resource isn't really known.Interface used when assembling an attribute value that contains expansions.
Renders a string using
MarkupWriter.write(String)
.A
Coercion
for converting strings into an instance of a particular
enumerated type.Passes the string value from the server to the client and vice-versa without any translation.
Captures the information needed to create a stylesheet link in the final
Document
, or
as part of a JSON partial page render response.Provides options to describe options associated with importing a stylesheet onto a page.
Corresponds to <input type="submit"> or <input type="image">, a client-side element that can force the
enclosing form to submit.
Defines the client and server-side behavior of a
Submit
or LinkSubmit
component.A non visual component used to provide notifications to its container during a form submission.
Deprecated.
Deprecated in 5.4, use
ImportModule
instead.A successful method invocation; one that did not throw a checked exception.
Used to identify a component that can support informal parameters.
Checks for the
SupportsInformalParameters
annotation, settting the corresponding flag on the model if
present.Support for building the equivalent of a Java switch statement.
A callback used by a
SwitchBlock
to manage the generation of code.Used to inject a symbol value, via a symbol name.
Defines the names of symbols used to configure Tapestry.
Performs an injection based on a
Symbol
annotation.A provider of values for symbols, used by the
SymbolSource
service.Used to manage symbols, configuration properties whose value is evaluated at runtime.
A synthetic module definition, used to mix in some additional "pre-built" service configuration contributions.
Identifies any code associated with line 1 as omitted (i.e., it's a synthetic
method related to an inner class).
Makes a contribution to the SymbolSource service configuration.
Provides case insensitive access to environment variables.
Obtains symbol values from JVM System properties.
Encapsulates a number of tests for identifying stack frames that are a side-effect
of various Tapestry Aspect Oriented Programming and other code generation behaviors.
This class is used to build the
Registry
.Extension of Spring's
XmlWebApplicationContext
that includes hooks to
resolve some injections into Spring beans as Tapestry services.Identifies dependencies whose field or method parameter contains the
Inject
or InjectService
annotations and, if so, invokes ObjectLocator.getObject(Class, org.apache.tapestry5.commons.AnnotationProvider)
to provide the
value.Constants needed by end-user classes.
An inline tag allowed inside a type; it produces Tapestry component reference and other information.
Exception class used as a replacement for
RuntimeException
when the exception is related to a
particular location.The TapestryFilter is responsible for intercepting all requests into the web application.
The TapestryFilter is responsible for intercepting all requests into the web application.
Class defining constants for Tapestry HTTP.
The Tapestry module for HTTP handling classes.
Class defining constants for Tapestry HTTP symbols.
Controls creation, startup and shutdown of the Tapestry container,
and injects specifications with Tapestry-provided objects.
Shared utility methods used by various implementation classes.
Tapestry-IoC specific cache invocation context using
MethodInvocation
Tapestry-IoC specific cache key invocation context using
MethodInvocation
A JUnit4ClassRunner to help with Tapestry IOC integration tests.
Defines the base set of services for the Tapestry IOC container.
A set of markers used internally by Tapestry when logging in code related to paqes and components.
The root module for Tapestry.
Defines services and definitions for the Tapestry OpenAPI viewer.
Tapestry's mutable extension of
PersistenceUnitInfo
interface used for XML-less configuration
of persistence units.Encapsulates logic for accessing the Tapestry
Session
(a wrapper around the HttpSession
).Facilitates Spock-based integration testing
of Tapestry modules.
Add logic to setup for Spring integration at startup.
Base test case that adds a number of convenience factory and training methods for the public
interfaces of
Tapestry.
To be used on Selenium-based integration tests that extend
SeleniumTestCase
as an alternative to using a
TestNG XML configuration file.Defins
ITestContext
attributes meaninful to Tapestry for controlling application startup and shutdown.Represents a Tapestry version that needs a migration due to names that moved from
one package to another.
An output stream that acts like a "tee", copying all provided bytes to two output streams.
Parses a resource into a
ComponentTemplate
.Parses Tapestry XML template files into
ComponentTemplate
instances.Base class for tokens parsed out of a template.
Class that holds information about a template for tracking.
An extended version of
Request
that allows the PageTester
to control and override behavior,
effectively simulating the portions of Request
that are provided normally by a servlet container.Deprecated.
In 5.4, with no replacement
Helper class used by the
TapestryIOCJUnit4ClassRunner
to manage the test registryDeprecated.
In 5.4, with no replacement
A type of node that contains text.
TextArea component corresponds to a <textarea> element.
TextField component corresponds to
<input>
element.Outputs paragraph oriented text, typically collected via a
TextArea
component.Deprecated.
Deprecated in 5.4, use
PerthreadManager.addThreadCleanupCallback(Runnable)
instead.Stores the locale for the current thread.
A thunk is a delayed calculation.
Used to represent a period of time, specifically as a configuration value.
Used to present an interval value using Moment.js's from() or fromNow() functions.
Defines the different types of
TemplateToken
s.Deprecated.
Please use
TomcatRunner
insteadLaunches an instance of Tomcat.
Extends
ComponentEventCallback
with a way to determine if the underlying event has been aborted
due to a some event returning an acceptable, non-null value.Marker annotation for a service that should be used for traditional page oriented requests, as opposed to Ajax
requests (that send ad-hoc or partial page markup responses.
Defines different traits that may be enabled or disabled.
Options used when transforming classes.
Additional utilities, beyond
PlasticClass
, needed when transforming.Constants used by implementations
ComponentClassTransformWorker2
.Support code for generating code (used when transforming component classes).
Used to attach the name of a Translator used to convert the associated property between server-side and
client-side representations.
Interprets the binding expression as the name of a
Translator
provided by the TranslatorSource
.Translates between client-side and server-side values.
This service is used by
TranslatorSource
to specify Translator
alternates: translators that
are used when specified explicitly by name.A source for
Translator
s, either by name or by property type.A component used to render a recursive tree structure, with expandable/collapsable/selectable nodes.
Tracks which nodes of a
TreeModel
are currently expanded.A model for tree-oriented data used by the
Tree
component.Used with
DefaultTreeModel
to define how to extract labels and child nodes from a value.A node within a
TreeModel
.Tracks which leaf nodes of a
TreeModel
are currently selected.Triggers an arbitrary event during rendering.
A mixin that can be applied to a
Checkbox
or
Radio
component that will link the input field and a
FormFragment
, making the field control the client-side visibility of
the FormFragment.Allows a portion of a method to be marked so that exception and finally handlers can be provided.
A callback used with
InstructionBuilder.startTryCatch(TryCatchCallback)
.A Tuple holds two values of two different types.
Defines the two basic kinds of non-primitive, non-array Java types: interfaces and classes.
Provides
ValueEncoder
instances that are backed by the TypeCoercer
service.Makes use of
Coercion
s to convert between an input value (of some specific
type) and a desired output type.A simplified version of
TypeCoercer
used to defer the instantiation of the actual TypeCoercer
service until necessary.A proxy for the
TypeCoercer
A validator that enforces that the value is false.
Designed to be just about the last worker in the pipeline.
A marker annotation that indicates that the page in question may only be accessed with a exact activation context.
Responsible for handling the response for a page called with an unknown activation context when the check itself is
enabled.
Default implementation for
UnknownActivationContextHandler
which answer with a 404 NOT FOUND error.Special exception used when a value (typically from a map) is referenced that does not exist.
A close relative of the
If
component that inverts the meaning of its
test.Interface for objects which can periodically check for updates.
Manages a set of
UpdateListener
s.A component to upload a file.
Represents an uploaded file.
Implentation of
UploadedFile
for FileItems.Names of events that may be triggered on components due to file uploads.
Determines if there was an
FileUploadException
processing the request and, if
so, triggers an exception event on the page.Configuration symbols.
Given a (growing) set of URLs, can periodically check to see if any of the underlying resources has changed.
Service used to encode or decode strings that are placed into URLs.
Implementation based on values extracted from the URL (an event context, or a page activation
context) that uses a
ContextValueEncoder
to convert from
string values to the desired values.A documentation-only interface placed on service interfaces for services which have an
unordered configuration, to identify the type of contribution.
A documentation-only interface placed on service interfaces for services which have a
mapped configuration, to identify the type of key (often, a String),
and type of contribution.
A documentation-only interface placed on service interfaces for services which have an
ordered configuration, to identify the type of contribution.
Annotation documenting the context(s) in which tapestry-provided annotations may be used.
Adds ;charset=utf-8 for text/* resources with no specific character set.
Used to attach validation constraints directly to a property (either the getter or the setter method).
Checks for the
Validate
annotation, and extracts its value to form the result.Factory for bindings that provide a
FieldValidator
based on a validator specification.Wraps a
Collection
as a Configuration
and perform validation that
collected value are of the correct type.A wrapper around a Map that provides the
MappedConfiguration
interface, and provides
two forms of validation for mapped configurations:
If either key or value is null, then a warning is logged
If the key has previously been stored (by some other ContributionDef
, then a
warning is logged
When a warning is logged, the key/value pair is not added to the delegate.Wraps a
List
as a OrderedConfiguration
, implementing validation of
values provided to an OrderedConfiguration
.Invoked to generate a list of validation constraint strings for a property.
Deprecated.
Deprecated in 5.4 with no replacement.
Deprecated.
Deprecated in 5.4 with no replacement, as
ValidationDecorator
is being phased out.Implementation of
ValidationDecorator
that delegates all method invocations.An exception associated with parsing client input, or validating the input against a constraint.
Tracks information related to user input validations.
Standard implementation of
ValidationTracker
.Wrapper around a
ValidationTracker
that delegates all methods to the wrapped instance.Used by a
Field
to enforce a constraint related to a form submission.Allows support for "validator macros", a simple-minded way of combining several related valiations together under
a single name.
Validator type and constraint values parsed from a validator specification.
Used in conjunction with
Inject
to inject a literal value, rather than a
service.A ValueEncoder is used to convert server side objects to unique client-side
strings (typically IDs) and back.
A source for
ValueEncoder
instances of a given type.A source for value encoders based on a property type.
An object capable of providing a user-presentable label from a value.
Provides an object when the
Value
annotation is present.Utility methods related to managing framework version numbers.
Base class for virtual resources: resources that are not simply mapped to stored files, but are assembled, as necessary,
on the fly.
A callback interface used navigate the
Element
s of a document.Callback used with
InstructionBuilder.doWhile(Condition, WhileCallback)
.Identifies a page that should only be accessed from clients on the whitelist.
Given a request, determine if the request is from a client on the whitelist.
Defines the desired width of the field used to edit the property.
An operational function used with a
Flow
.Used when invoking a contribute method to guard against a request for the wrong type of configuration interface.
Reads an XDOC file using SAX and streams its content (with some modifications) to
an output stream.
Markup model used when generating any form of XML markup.
Parses a document as a stream of XML tokens.
Identifies type of
XMLToken
.Treats nulls to or from the client as if they were 0's.
The result of the
Flow.zipWith(Flow)
method (or created from a Map via F.zippedFlow(Map)
), a Flow of
combined Tuple
values (that can be deconstructed, eventually, using ZippedFlow.unzip()
).A Zone is portion of the output page designed for easy dynamic updating via Ajax or other client-side effects.
This mixin periodically refreshs a
zone
by triggering an event on the server using ajax requests.
ClasspathAssetAliasManager
).