# All Classes and Interfaces

Class
Description
AbstractAnnotationBuilder
AbstractAsset
Base class for assets.
AbstractAssetFactory
AbstractBinding
Abstract base class for bindings.
AbstractComponentCallback
Base class for most implementations of `ComponentCallback`, used when there is an underlying `Event`.
AbstractComponentEventLink
Base class for link-generating components that are based on a component event request.
AbstractConditional
Base class for `If` and `Unless`.
AbstractConfigurationImpl<T>
AbstractContributionDef
Partially implements `ContributionDef`, providing empty implementations of the three contribute() methods.
AbstractEventContext
AbstractField
Provides initialization of the clientId and elementName properties.
AbstractInternalPage
Base page for Tapestry internal pages, that should suppress any application changes to the core stack's CSS.
AbstractLink
Provides base utilities for classes that generate clickable links.
AbstractMarkupModel
AbstractMessages
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).
AbstractMethodInvocation
AbstractMethodInvokingInstrumenter
Base class for service decorators and service advisors that work by invoking a module method.
AbstractOptionModel
Base class for implementing `OptionModel`.
AbstractPropertyOutput
Base class for components that output a property value using a `PropertyModel`.
AbstractReloadableObjectCreator
AbstractResource
Abstract implementation of `Resource`.
AbstractSelectModel
Base class for `SelectModel` implementations, whose primary job is to provide the `AbstractSelectModel.visit(SelectModelVisitor)` method.
AbstractServiceCreator
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.
AbstractServiceInstrumenter
Abstract base class for implementations of `ServiceDecorator` (i.e., old school) and `ServiceAdvisor` (i.e., new school).
AbstractSessionPersistentFieldStrategy
Base class for strategies that store their values as keys in the session.
AbstractTextField
Abstract class for a variety of components that render some variation of a text field.
AbstractTranslator<T>
AbstractValidator<C,T>
Base class for constructing a `Validator`.
AbtractAspectInterceptorBuilder<T>
AccessableObjectAnnotationProvider
Provides access to annotations of an accessable object such as a `Method` or `Field`.
ActionLink
Component that triggers an action on the server with a subsequent full page refresh.
ActivationContextParameter
Annotation that may be placed on parameters of event handler methods to define their names in OpenAPI description.
ActivationRequestParameter
Marks a field of a page (not a component) as persistent within the URL, as with a page activation context.
ActivationRequestParameterWorker
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`.
AddBrowserCompatibilityStyles
Responsible for adding additional style tags that contain directives for non-standards compatible browsers
AddRowLink
Used inside an `AjaxFormLoop` component to spur the addition of a new row.
Advise
An annotation that may be placed on a advisor method of a module.
AdvisorDef
Definition of a service advisor, which (by default) is derived from a service advisor method.
AdvisorDef2
Extended version of `AdvisorDef` introduced to determine any module method annotated with `Advise` as an advisor method.
AdvisorDefImpl
AdvisorStackBuilder
Equivalent of `InterceptorStackBuilder`, but works using an `AspectInterceptorBuilder` that receives advice from `ServiceAdvisor`s.
AfterRender
Marker annotation for methods associated with the AfterRender phase.
AfterRenderBody
Corresponds to `BeforeRenderBody`, allowing additional markup after rendering the body of a component, but before rendering the rest of the component's template.
AfterRenderTemplate
Corresponds to `BeforeRenderTemplate`, allowing additional markup after rendering the component's template.
Ajax
Marker annotation for services related to processing an Ajax request (rather than a traditional request).
AjaxComponentEventRequestHandler
Similar to `ComponentEventRequestHandlerImpl`, but built around the Ajax request cycle, where the action request sends back an immediate JSON response containing the new content.
AjaxComponentInstanceEventResultProcessor
Performs a partial page render based on a root component.
AjaxFilter
A filter that intercepts Ajax-oriented requests, thos that originate on the client-side using XmlHttpRequest.
AjaxFormLoop
A special form of the `Loop` component that adds Ajax support to handle adding new rows and removing existing rows dynamically.
AjaxFormLoopContext
Interface that allows an enclosing `AjaxFormLoop` to work with enclosed components such as `AddRowLink` or `RemoveRowLink`.
AjaxFormUpdateController
Coordinates the rendering of page partials in the context of an Ajax update to an existing Form.
AjaxFormUpdateControllerImpl
AjaxFormUpdateFilter
Filter for the `Ajax` `ComponentEventRequestHandler` that informs the `AjaxFormUpdateController` about the form's client id and component id.
AjaxLinkComponentEventResultProcessor
Handles `Link` result types by building a JSON response with key "redirectURL".
AjaxPageClassComponentEventResultProcessor
Processes a Class result by converting the Class to a logical page name, then processing that.
AjaxPageNameComponentEventResultProcessor
A `ComponentEventResultProcessor`, used for Ajax requests, for a String value that is interpreted as a logical page name.
AjaxPartialResponseRenderer
Used to render portions of a page as part of an Ajax request.
AjaxPartialResponseRendererImpl
AjaxResponseRenderer
Manages the rendering of a partial page render as part of an Ajax response.
AjaxResponseRendererImpl
AjaxURLComponentEventResultProcessor
Handles `URL` result types by building a JSON response with key "redirectURL".
Alert
An Alert that may be presented to the user.
AlertManager
Manages `Alert`s (using the `AlertStorage` SSO.
AlertManagerImpl
Alerts
Renders out an empty `<div>` element and provides JavaScript initialization to make the element the container for alerts.
AlertStorage
A stateless session object used to store Alerts between requests.
AMDWrapper
Used to wrap plain JavaScript libraries as AMD modules.
AnnotationAccess
Introduced for Tapestry 5.3, contains new methods to provide access to annotations on the class, and on methods of the class.
AnnotationAccess
Interface implemented by members that may hold annotations.
AnnotationAccessImpl
Standard AnnotationAccess for a specific type.
AnnotationBuilder
AnnotationDataTypeAnalyzer
Checks for the `DataType` annotation, returning its value if present.
AnnotationMapper
AnnotationProvider
A source of annotations.
AnnotationProviderChain
Chain of command for `AnnotationProvider`.
AnnotationUseContext
Constants for documenting the context wherein the tapestry-provided annotations may be used, in conjunction with `UseWith`.
Any
Turns any arbitrary (X)HTML element into a component.
ApplicationContextCustomizer
A bridge from Spring's approach to customizing the application context, over to Tapestry's approach.
ApplicationDefaults
Used to disambiguate which version of `SymbolProvider` is being referenced.
ApplicationGlobals
Stores global information about the application and its environment.
ApplicationGlobalsImpl
ApplicationInitializer
Service interface for initializing Tapestry for the application.
ApplicationInitializerFilter
Filter interface for `ApplicationInitializer`.
ApplicationMessageCatalogObjectProvider
Allows for injection of the global application message catalog into services.
ApplicationStackTraceElementAnalyzer
Identifies frames for application classes.
ApplicationStateContribution
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.
ApplicationStateCreator<T>
Used by `ApplicationStateManager` and `ApplicationStatePersistenceStrategy` to create a Session State Object (SSO) on demand.
ApplicationStateManager
Responsible for managing Session State Objects (SSO), objects which persist between requests but are not tied to any individual page or component.
ApplicationStateManagerImpl
ApplicationStatePersistenceStrategy
Used by `ApplicationStateManager` to manage a specific kind of Session State Object (SSO) persistence.
ApplicationStatePersistenceStrategySource
Used to provide access to `ApplicationStatePersistenceStrategySource` instances via a logical name for the strategy, such as "session".
ApplicationStatePersistenceStrategySourceImpl
ApplicationStateWorker
Looks for the `SessionState` annotations and converts read and write access on such fields into calls to the `ApplicationStateManager`.
ArrayEventContext
Simple implementation of `EventContext`.
ArtifactChangeRefactorCommitParser
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%)`.
AspectDecorator
A decorator used to create an interceptor that delegates each method's invocation to an `MethodAdvice` for advice.
AspectDecoratorImpl
AspectInterceptorBuilder<T>
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).
AspectInterceptorBuilderImpl<T>
Asset
An Asset is any kind of resource that can be exposed to the client web browser.
AssetAlias
Deprecated.
Deprecated in 5.4 (see notes in `ClasspathAssetAliasManager`).
AssetBinding
AssetBindingFactory
Binding factory where the expression is a reference to an asset.
AssetChecksumGenerator
Generates a checksum of an arbitrary `Resource` or `StreamableResource` which can be incorporated into the client URL of an Asset.
AssetChecksumGeneratorImpl
AssetConstants
Defines constants for the two basic asset prefixes.
AssetDispatcher
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.
AssetFactory
Used by `AssetSource` to create new `Asset`s as needed.
AssetInjectionProvider
Performs injection of assets, based on the presence of the `Path` annotation.
AssetNotFoundException
Class that represents the exception of an asset not being found.
AssetObjectProvider
Exposes assets (in the current locale).
AssetPathConstructor
Encapsulates the logic or creating the path portion of an asset URL, including hooking the `AssetPathConverter` into the generation.
AssetPathConstructorImpl
AssetPathConverter
Converts the path (or URI) of an asset into a new format.
AssetRequestDispatcher
Marker annotation used to specifically identify the `Dispatcher` used to dispatch asset requests (so that `AssetRequestHandler`s can be contributed).
AssetRequestHandler
Handler for asset requests, which expose some kind of `Asset` to the user agent (i.e., the client web browser).
AssetsModule
AssetSource
Used to find or create an `Asset` with a given path.
AssetSourceImpl
AsyncRequestHandler
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.
AsyncRequestHandlerResponse
Class used by AsyncRequestHandler to return information on how to handle a request.
AsyncRequestService
Service that handles Tapestry's support for asynchronous Servlet API requests.
AsyncRequestServiceImpl
Service that handles Tapestry's support for asynchronous Servlet API requests.
Attribute
An attribute within an `Element`.
AttributeExpansionBinding
Wraps a `StringProvider` as a read-only `Binding`.
AttributeInfo
Tracks the qualified name and value of an attribute within a start element XMLToken.
AttributeToken
Stores an attribute/value pair (as part of an XML element).
Autobuild
Directs that the value to be built should be an autobuild instance of the type with injections performed, via ObjectLocator.html#autobuild(Class).
AutobuildObjectProvider
Checks for the `Autobuild` annotation and, if so invokes `ObjectLocator.autobuild(Class)` on it.
Autocomplete
A mixin for a text field that allows for autocompletion of text fields.
AutofocusValidationDecorator
Used by `Form` to determine which fields will be focused and a what priority.
AvailableValues
Used (as part of a `UnknownValueException` to identify what available values are present.
AvailableValuesRenderer
Renders out a `AvailableValues` instance as a <div> enclosing a <ul>.
Base64InputStream
An extension of `ByteArrayInputStream` that is initialized from a Base64 input stream (rather than from a byte array).
Base64OutputStream
An extension of `ByteArrayOutputStream` that allows the final byte array to be converted to a Base64 string.
BaseCCD
Describes a single client-side constraint.
BaseClientElement
Provides support for elements that will optionally render a unique `id` attribute, but only if it is requested.
BaseLexer
BaseLocatable
Base implementation of `Locatable`.
BaseOptimizedSessionPersistedObject
Base implementation of `OptimizedSessionPersistedObject`.
BaseParser
BaseURLSource
Used when switching between normal/insecure (HTTP) and secure (HTTPS) mode.
BaseURLSourceImpl
BaseValidationDecorator
Base implementation of `ValidationDecorator` that does nothing.
BasicDataTypeAnalyzers
Class that provides Tapestry's basic default data type analyzers.
BasicTypeCoercions
Class that provides Tapestry-IoC's basic type coercions.
BeanBlockContribution
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.
BeanBlockOverrideSource
Used to override the default `BeanBlockSource` for a particular data type.
BeanBlockOverrideSourceImpl
BeanBlockSource
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).
BeanBlockSourceImpl
BeanDisplay
A component that displays the properties of a bean (or POJO, or any object with properties) as a simple HTML definition list.
BeanEditContext
Defines a context for editing a bean via `BeanEditor`.
BeanEditContextImpl
BeanEditForm
A component that creates an entire form for editing the properties of a particular bean (or POJO, or any object with properties).
BeanEditor
A component that generates a user interface for editing the properties of a bean (or POJO, or any object with properties).
BeanEditor.Prepare
BeanFieldValidator
BeanFieldValidatorDefaultSource
BeanModel<T>
Provides the information necessary to build a user interface to view, create or edit an instance of a particular type.
BeanModelImpl<T>
BeanModelSource
Used by a component to create a default `BeanModel` for a particular bean class.
BeanModelSourceBuilder
Utility class for creating `BeanModelSource` instances without Tapestry-IoC.
BeanModelSourceImpl
BeanModelUtils
Utilities used in a few places to modify an existing `BeanModel`.
BeanValidationContext
Defines a context for validating beans.
BeanValidationContextImpl
BeanValidationGroupSourceImpl
BeanValidatorConfigurer
Defines the interface for a chain-of-command that updates JSR-303 configuration in some way before the `ValidatorFactory` is created.
BeanValidatorGroupSource
Provides list of groups targeted for validation.
BeanValidatorModule
Module for JSR-303 services.
BeanValidatorSource
Creates `ValidatorFactory`.
BeanValidatorSourceImpl
BeforeRenderBody
Marks methods to be invoked when the component rendering state machine hits the point in the component's template where the body element occurs.
BeforeRenderTemplate
Associated with components that have a template, this phase is invoked to allow the component to decorate its template with additional markup.
BeginRender
Marker annotation for methods that should be executed at the start of rendering the component.
BigDecimalNumericFormatter
BigIntegerNumericFormatter
BigTypesFormatter
Base class for parsing/formatting BigInteger and BigDecimal.
Binding
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.
Binding2
Extension to `Binding` that adds a method to access the generic property type.
BindingConstants
Constants for the built-in binding prefixes.
BindingFactory
Creates a binding of a particular type.
BindingSource
Used to acquire bindings for component parameters.
BindingSourceImpl
BindParameter
Designates a field in a mixin which is bound to the parameter of the containing component corresponding to the value of the annotation.
BindParameterWorker
Responsible for identifying, via the `BindParameter` annotation, mixin fields that should be bound to a core-component parameter value.
BlankOption
Used with the `Select` component to control whether an initial blank option is supplied.
Block
A block is a collection of static text and elements, and components, derived from a component template.
BlockBinding
BlockBindingFactory
Accesses a named block from the container.
BlockImpl
BlockInjectionProvider
Identifies fields of type `Block` that have the `Inject` annotation and converts them into read-only fields containing the injected Block from the template.
BlockNotFoundException
Exception thrown when a `Block` is requested but not found.
BlockToken
A block, used to enclose a chunk of template (including components) and control when or if the content is rendered.
BodyPageElement
A type of page element that has a body that can be added to.
BodyToken
Placeholder for a component's body (within the component's template).
BooleanHook
Encapsulates a bit of information that can be represented as a boolean.
Bootstrap4Module
Module which defines the options needed to run Tapestry using Bootstrap 4 instead of the default Bootstrap 3.
BridgeBuilder<S,F>
Used by the `PipelineBuilderImpl` to create bridge classes and to create instances of bridge classes.
BufferedGZipOutputStream
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)`
Builtin
Marks services provided by this module that may need to be unambiguously referenced.
BytestreamCache
A wrapper around a byte-stream, represented internally as a byte array.
Cache<S,T>
Quick and dirty key/value cache that is subclassed to provide the logic that generates the value for a missing key.
Cached
Indicates that a method should only be evaluated once per request and the result cached.
CachedWorker
Caches method return values for methods annotated with `Cached`.
CacheLookupUtil
Adapted to Tapestry-IoC from the Guice implementation in the reference implementation.
CacheMethodAdvice
Common subclass for all JCache interceptors
CachePutMethodAdvice
CacheRemoveAllMethodAdvice
CacheRemoveMethodAdvice
CacheResultMethodAdvice
CachingObjectCreator<T>
An `ObjectCreator` that delegates to another `ObjectCreator` and caches the result.
CaptureRenderedDocument
Used to capture the rendered document from a traditional page render.
CaptureResultCallback<T>
Implementation of `ComponentEventCallback` that simply captures the result value.
CaseInsensitiveMap<V>
An mapped collection where the keys are always strings and access to values is case-insensitive.
CData
A node that stores parsed character content (CDATA).
CDATAToken
Literal text that was enclosed within a !CDATA in the input template (so we should do the same during output).
ChainBuilder
A service which can assemble an implementation based on a command interface, and an ordered list of objects implementing that interface (the "commands").
ChainBuilderImpl
Checkbox
A Checkbox component is simply a <input type="checkbox">.
Checked
A validator that enforces that the value is true.
CheckForUpdatesFilter
Implements a barrier that periodically asks the `UpdateListenerHub` to check for updates to files.
Checklist
A list of checkboxes, allowing selection of multiple items in a list.
ChecksumPath
Utility used by `AssetRequestHandler` implementations where the first folder in the extra path is actually a computed checksum of the resource's content.
ClassDescription
ClassDescriptionSource
ClassInstantiator<T>
The end result of a class transformation is a ClassInstantiator that can be used to instantiate an instance of the transformed class.
ClassInstantiatorImpl<T>
ClassLoaderDelegate
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.
ClassNameHolder
Interface that defines types who provide a class name for URLChangeTracker purposes.
ClassNameLocator
Scans the classpath for top-level classes within particular packages.
ClassNameLocatorImpl
ClasspathAssetAliasManager
Deprecated.
Deprecated in 5.4, with no replacement.
ClasspathAssetAliasManagerImpl
ClasspathAssetFactory
Generates Assets for files on the classpath.
ClasspathAssetProtectionRule
Chain-of-responsibility service which defines rules for blocking access to classpath resources based on their paths.
ClasspathAssetRequestHandler
A handler for asset requests for classpath assets (within a specific folder).
ClasspathMatcher
Used to determine which files will be included in the set of matches paths within a particular package.
ClasspathProvider
A marker annotation used to select the correct `AssetFactory` for injection.
ClasspathResource
Implementation of `Resource` for files on the classpath (as defined by a `ClassLoader`).
ClasspathResourceSymbolProvider
Makes a `Resource` on the classpath available as a `SymbolProvider`
ClasspathScanner
Used to scan a portion of the classpath for files that match a particular pattern, defined by a `ClasspathMatcher`.
ClasspathScannerImpl
ClasspathURLConverter
Used by `ClassNameLocator` to convert URLs from one protocol to another.
ClasspathURLConverterImpl
Default implementation that returns the URLs unchanged.
ClassPropertyAdapter
Organizes all `PropertyAdapter`s for a particular class.
ClassPropertyAdapterImpl
ClassRefactor
Class that represents information about one class being renamed and/or moved between artifacts (JARs) and/or packages.
ClassResultProcessor
Used when a component event handler returns a class value.
ClassType
Identifies the type of class referenced in a `PlasticClassEvent`.
CleanupRender
Marker annotation for component methods associated with the terminal phase for the component rendering state machine.
ClientBehaviorSupport
Deprecated.
Deprecated in 5.4 with no replacement.
ClientBehaviorSupportImpl
ClientBodyElement
Extends `ClientElement` with the concept of a body, a Block that can be rendered to provide the content within.
ClientConstraintDescriptor
Applies client-side validation constraints based on a particular JSR 303 annotation.
ClientConstraintDescriptorImpl
ClientConstraintDescriptorSource
Source for `ClientConstraintDescriptor`.
ClientDataEncoder
A service used when a component or service needs to encode some amount of data on the client as a string.
ClientDataEncoderImpl
ClientDataSink
Allows binary object data to be encoded into a string.
ClientDataSinkImpl
ClientElement
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.
ClientLocalizationMessageResource
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).
ClientPersistentFieldStorage
Describes an object that can store `PersistentFieldChange`s, and manage a query parameter stored into a `Link` to maining this data across requests.
ClientPersistentFieldStorageImpl
Manages client-persistent values on behalf of a `ClientPersistentFieldStorageImpl`.
ClientPersistentFieldStrategy
Implements simple client-persistent properties.
ClientValidation
Controls if and how client-side form input validation occurs.
ClientWhitelist
Analyzes the current request to see if it is on the whitelist (of clients with access to certain key pages).
ClientWhitelistImpl
ClojureBuilder
Creates a proxy for the interface that delegates each method to a Clojure function.
ClojureBuilderImpl
ClojureModule
ClusteredSessionImpl
A thin wrapper around `HttpSession` that supports re-storing of mutable session attributes at the end of the request (see `ClusteredSessionImpl.restoreDirtyObjects()`).
CoercingPropertyConduitWrapper
Coercion<S,T>
Responsible for converting from one type to another.
CoercionFailedException
Exception used when a `Coercion` throws an exception while trying to coerce a value.
CoercionNotFoundException
Exception used when `TypeCoercer` doesn't find a coercion from a type to another.
CoercionTuple<S,T>
An immutable object that represents a mapping from one type to another.
CollectionFactory
Static factory methods to ease the creation of new collection types (when using generics).
CollectionGridDataSource
ColumnSort
Identifies how a column within a `GridSortModel` is sorted.
Comment
A node that represents a comment within the DOM.
CommentToken
A node representing a comment embedded in the source input.
CommitAfter
Marks a method of a service (or a component method) as transactional: the active transaction should commit after invoking the method.
CommitAfter
CommitAfterMethodAdvice
CommitAfterWorker
Searches for methods that have the `CommitAfter` annotation and adds logic around the method to commit or abort the transaction.
CommitAfterWorker
CommonResourcesInjectionProvider
Allows for a number of anonymous injections based on the type of field that is to be injected.
CommonsUtils
Some utility methods used in different Tapestry subprojects.
Compatibility
Used globally to track what compatibility traits are enabled.
CompatibilityImpl
CompatibilityModule
Defines services for managing compatibility across releases.
Component
Used to define an embedded component within another component.
Component
Interface that defines the lifecycle of a component, within a page, allowing for callbacks into the component for many different events.
ComponentAction<T>
An action that is associated with a component.
ComponentActionSink
Used to collection component actions, with the ultimate goal being the creation of a MIME-encoded string of the serialization of those actions.
ComponentAssemblerSource
Provides access to `ComponentAssembler`s (this is used by the assemblers to find related assemblers).
ComponentBinding
ComponentBindingFactory
The "component:" binding prefix, which allows access to a child component via its id.
ComponentCallback
Callback interface, used when invoking lifecycle methods on components.
ComponentClassCache
A cache for converting between class names and component (or other) classes.
ComponentClassCacheImpl
ComponentClasses
Marker annotation used to inject the correct InvalidationEventHub service responsible for invalidations when underlying component class files are changed.
ComponentClassResolver
Resolves page names and component types to fully qualified class names.
ComponentClassResolverImpl
ComponentClassTransformWorker2
Interface for a set of objects that can perform transformation of component classes.
ComponentDefaultProvider
A service that can be injected into a component to provide common defaults for various types of parameters.
ComponentDefaultProviderImpl
ComponentDependencyGraphvizGenerator
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.
ComponentDependencyGraphvizGeneratorImpl
ComponentDependencyRegistry
Internal service that registers direct dependencies between components (including components, pages and base classes).
ComponentDependencyRegistry.DependencyType
Enum class defining the types of dependency components, pages and mixins can have among them.
ComponentDependencyRegistryImpl
ComponentEvent
An event that may originate in application logic, or as a result of a client interaction (a GET or POST from the client).
ComponentEventCallback<T>
Callback interface for a render phase event or `ComponentEvent`, notified when a non-null value is returned from some event handler method.
ComponentEventDispatcher
Processes component action events sent as requests from the client.
ComponentEventException
A wrapper exception around any exception thrown when invoking a component event handler.
ComponentEventHandler
Interface used with `TransformationSupport.addEventHandler(String, int, String, ComponentEventHandler)`}.
ComponentEventImpl
ComponentEventLinkEncoder
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.
ComponentEventLinkEncoderImpl
ComponentEventLinkTransformer
Allows for selective replacement of the default `Link` used to represent a component event request.
ComponentEventRequestFilter
Filter interface for `ComponentEventRequestHandler`.
ComponentEventRequestHandler
Handler interface for component event requests.
ComponentEventRequestHandlerImpl
ComponentEventRequestParameters
Encapsulates all the information that may be provided in a component event request URL.
ComponentEventResultProcessor<T>
Responsible for handling the return value provided by a component event handler method.
ComponentInstanceProcessor
Marker for `ComponentEventResultProcessor` to identify the particular implementation used for handling `Component` instances (i.e., pages).
ComponentInstanceResultProcessor
ComponentInstantiatorSource
Creates `Instantiator`s for components, based on component class name.
ComponentInstantiatorSourceImpl
A wrapper around a `PlasticManager` that allows certain classes to be modified as they are loaded.
ComponentLayer
Marker annotation used to identify a service from the component layer that conflicts, in terms of service interface, with a service from elsewhere.
ComponentLibraries
Page used to describe the component libraries being used in the application.
ComponentLibraryInfo
Class that encapsulates information about a component library, going beyond what a library mapping provides.
ComponentLibraryInfo.DefaultSourceUrlResolver
Default `ComponentLibraryInfo.SourceUrlResolver` implementation.
ComponentLibraryInfo.SourceUrlResolver
Interface that provides the source URL for a given `ComponentLibraryInfo`.
ComponentLibraryInfoSource
Service that provides information about component libraries.
ComponentMessages
Marker annotation used to inject the correct `InvalidationEventHub` service responsible for validations when component message catalog (i.e., ".properties") files change.
ComponentMessagesSource
Used to connect a Tapestry component to its message catalog, or to obtain the application catalog (that all component message catalogs extend from).
ComponentMessagesSourceImpl
ComponentModel
Defines a component in terms of its capabilities, parameters, sub-components, etc.
ComponentModelSource
Access to component models (as provided via `ComponentInstantiatorSource`).
ComponentModelSourceImpl
ComponentName
Used to construct component names.
ComponentOverride
Service that allows replacing one component, page or mixin class by another without changing the sources.
ComponentOverrideImpl
ComponentPageElement
Defines an element of a `Page` that is a full `Component`, including the possibility of its own template and mixins.
ComponentPageElementImpl
Implements `RenderCommand` and represents a component within an overall page.
ComponentPageElementResources
Provides access to common methods of various services, needed by implementations of `ComponentPageElement` and `InternalComponentResources`.
ComponentPageElementResourcesImpl
ComponentPageElementResourcesSource
Provides access to the `ComponentPageElementResources` facade.
ComponentPageElementResourcesSourceImpl
ComponentParameterConstants
Constants for core component parameters defined by `Symbol`
ComponentRequestFilter
Filter interface for `ComponentRequestHandler`.
ComponentRequestHandler
A facade around `ComponentEventRequestHandler` and `PageRenderRequestHandler` that allows for simplified filters that cover both types of requests.
ComponentRequestHandlerTerminator
Terminator for the `ComponentRequestHandler` pipeline, that feeds out into the `ComponentEventRequestHandler` and `PageRenderRequestHandler` pipelines.
ComponentRequestSelectorAnalyzer
Determines the `ComponentResourceSelector` for the current request.
ComponentResourceLocator
A central service that encapsulates the rules for locating resources for components.
ComponentResources
Provides a component instance with the resources provided by the framework.
ComponentResourcesAware
Interface implemented by components (after they have been transformed at load time).
ComponentResourcesCommon
Operations shared by the public `ComponentResources` interface and `ComponentPageElement` interface (on the internal side).
ComponentResourceSelector
Encapsulates the information that is used when locating a template or message catalog associated with a component.
ComponentResourcesOperation
Deprecated.
In Tapestry 5.4; use `MethodAdvice` and other parts of the new (in 5.3) plastic library.
ComponentResourcesRenderer
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).
ComponentResultProcessorWrapper
A wrapper around `ComponentEventResultProcessor` that encapsulates capturing the exception.
ComponentSource
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.
ComponentSourceImpl
ComponentTemplate
A parsed component template, containing all the tokens parsed from the template.
ComponentTemplateImpl
ComponentTemplateLocator
Deprecated.
Deprecated in 5.3, override or decorate `ComponentResourceSelector` instead.
ComponentTemplates
Marker annotation used to inject the correct `InvalidationEventHub` service responsible for validations when component template files change.
ComponentTemplateSource
Provides access to cached `ComponentTemplate`s.
ComponentTemplateSourceImpl
Service implementation that manages a cache of parsed component templates.
ComponentWorker
Finds fields with the `Component` annotation and updates the model.
CompositeFieldValidator
Aggregates together a number of field validator instances as a single unit.
CompoundCoercion<S,I,T>
Combines two coercions to create a coercion through an intermediate type.
CompressedStreamableResource
GZip compressed representation of a `StreamableResource`.
CompressionAnalyzer
Identifies which content types are compressable.
CompressionAnalyzerImpl
CompressionStatus
Indicates how the content inside a `StreamableResource` is (potentially) compressed.
ComputedValue<T>
Provides an indirect, or computed, value.
ConcurrentBarrier
A barrier used to execute code in a context where it is guarded by read/write locks.
Condition
Condition used with `InstructionBuilder.when(Condition, WhenCallback)`.
Configuration<T>
Object passed into a service contributor method that allows the method provide contributed values to the service's configuration.
ConfigurationType
Defines the three types of configurations a service may request.
ConfigureHTMLElementFilter
Responsible for writing attributes needed to configure the client, into the HTML element.
Confirm
A mixin that can be placed on a clickable component, such as `LinkSubmit`, and will raise a confirmation dialog when the element is clicked.
ConstructionPlan<T>
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.
ConstructorCallback
Supplies construction-time logic for the class' constructor.
ConstructorInvoker<T>
Wraps the invocation of a constructor (with exception reporting) as an `Invokable`.
ConstructorServiceCreator
A service creator based on an implementation class' constructor, rather than a service builder method.
ContentType
An annotation on a page component used to identify the content type the page returns.
ContentType
Represents an HTTP content type.
ContentTypeAnalyzer
Used to determine the MIME content type for a resource.
ContentTypeAnalyzerImpl
ContentTypeExtractor
Context
An API agnostic version of `ServletContext`, used to bridge the gaps between the Servlet API and the Portlet API.
ContextAssetFactory
Implementation of `AssetFactory` for assets that are part of the web application context.
ContextAssetRequestHandler
Handles requests for context assets, screening out attempt to access anything under WEB-INF or META-INF.
ContextAwareException
An interface implemented by exceptions that get special handling in the default `RequestExceptionHandler` service.
ContextBindingFactory
Specialization of `AssetBindingFactory` that is explicitly limited to context assets.
ContextImpl
ContextPathEncoder
A service to provide utilities needed for event context encoding and decoding to and from (partial) URL paths.
ContextPathEncoderImpl
ContextProvider
Marker annotation to select the correct `AssetFactory` for injection.
ContextResource
A resource stored with in the web application context.
ContextResourceSymbolProvider
Makes a `Resource` in the `Context` available as a `SymbolProvider`
ContextValueEncoder
Used to convert values used in event contexts to client string representations and back.
ContextValueEncoderImpl
Contribute
An annotation that may be placed on a contributor method of a module.
ContributionDef
Contribution to a service configuration.
ContributionDef2
Extended version of `ContributionDef` introduced to determine any module method annotated with `Contribute` as a contributor method.
ContributionDef3
Starting in Tapestry 5.3, contributions could be optional.
ContributionDefImpl
ControlledPackageType
Defines how a particular controlled package is processed.
CookieBuilder
A fluent API to create and write cookies.
Cookies
Used by other services to obtain cookie values for the current request, or to write cookie values as part of the request.
CookiesImpl
Implementation of the `Cookies` service interface.
CookieSink
You can write cookies to it.
CookieSource
Provides the cookies from the browser.
Core
Marker annotation for services that are provided by the Tapestry core module.
CorsHandler
Interface implemented by classes handling CORS (Cross-Origin Resource Sharing) in requests.
CorsHandlerHelper
Service that provides useful methods for `CorsHandler` implementations.
CorsHandlerHelperImpl
Default `CorsHandlerHelper` implementation.
CorsHandlerResult
Enumeration that defines the possible outcomes of `CorsHandler.handle(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)`
CorsHttpServletRequestFilter
HttpServletRequestFilter that handles CORS.
CronExpression
Provides a parser and evaluator for unix-like cron expressions.
CronSchedule
CSSClassConstants
Deprecated.
Deprecated in 5.4 with no replacement.
CSSURLRewriter
Rewrites the `url()` attributes inside a CSS (MIME type "text/css")) resource.
CustomizingContextLoader
DashboardManager
Organizes the tabs on the `T5Dashboard` page.
DashboardManagerImpl
DashboardModule
DashboardTab
Identifies a tab that will be present on the Tapestry Dashboard page.
DataConstants
Constants related to client-side behaviors; generally, these are attributes added to elements on the server side to trigger behaviors on the client-side.
DataType
Used to explicitly set the data type used to select an editor (or display) block.
DataTypeAnalyzer
Used by `BeanModelSource` to identify the type of data associated with a particular property (represented as a `PropertyAdapter`).
DataTypeConstants
Defines the names of data types used to select an editor (or display) block for a property.
DateField
A component used to collect a provided date from the user using a client-side JavaScript calendar.
DateUtilities
Formatting utilities for dates; this is primarily used when communicating server-side dates to the clients in ISO-8601 format.
DateUtilitiesImpl
Decorate
An annotation that may be placed on a decorator method of a module.
DecoratorDef
Definition of a service decorator, which (by default) is derived from a service decorator method.
DecoratorDef2
Extended version of `DecoratorDef` introduced to determine any module method annotated with `Decorate` as a decorator method.
DecoratorDefImpl
DefaultComponentRequestSelectorAnalyzer
DefaultComponentResourceLocator
DefaultCorsHandler
Default `CorsHandler` implementation.
DefaultDataTypeAnalyzer
The default data type analyzer, which is based entirely on the type of the property (and not on annotations or naming conventions).
DefaultHibernateConfigurer
Simply calls configure() to do the default Hibernate configuration.
DefaultImplementationBuilder
Creates default implementations of a class.
DefaultImplementationBuilderImpl
DefaultInjectionProvider
Worker for the `Inject` annotation that delegates out to the master `MasterObjectProvider` to access the value.
DefaultMapper
Default implementation that transforms a camelCased method-name to a clojure-style function name.
DefaultMarkupModel
Default implementation of `MarkupModel` that is appropriate for traditional (X)HTML markup.
DefaultModuleDefImpl
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).
DefaultNullFieldStrategy
Default strategy, which is to do nothing: null values stay null.
DefaultObjectRenderer
Default object renderer as a catch all for class `Object`.
DefaultOpenApiDescriptionGenerator
OpenApiDescriptionGenerator that generates lots, if not most, of the application's OpenAPI 3.0 documentation.
DefaultOpenApiTypeDescriber
`OpenApiTypeDescriber` implementation that handles some basic types, mostly primitives and String.
DefaultRequestExceptionHandler
Default implementation of `RequestExceptionHandler` that displays the standard ExceptionReport page.
DefaultSessionPersistedObjectAnalyzer
Default catch-all implementation of `SessionPersistedObjectAnalyzer`.
DefaultTemplateLocator
DefaultTreeExpansionModel<T>
Manages a Set of String `TreeNode` ids.
DefaultTreeModel<T>
A default implementation of TreeModel that starts with a `ValueEncoder` (for the element to string conversion), a `TreeModelAdapter`, and a list of root nodes.
DefaultTreeSelectionModel<T>
Default implementation of `TreeSelectionModel`.
DefaultValueLabelProvider
Uses the `TypeCoercer` to convert an arbitrary value to a string.
DeferredResponseRenderer
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.
DefineNamespacePrefixToken
A token from a template that defines a namespace prefix.
Delegate
A component that does not do any rendering of its own, but will delegate to some other object that can do rendering.
DelegatingAnnotationAccess
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.
DelegatingInjectionResources
Chain of command for InjectionDefaultProvider.
DelegatingRequest
Class that wraps an Request, delegating all its methods.
DelegatingSRS
Base class for `StreamableResourceSource` implementations.
DelegatingSymbolProvider
Combines multiple symbol providers.
DeprecationWarning
Used to report deprecation warnings for components.
DeprecationWarningImpl
Description
Annotation used by Tapestry to describe the annotated class or package in runtime, specially in the T5Dashboard page.
DevTool
Renders a dropdown menu of useful options when developing.
DifferentClassVersionsException
Exception used when trying to assemble a page but different versions of the same class are found.
DisableStrictChecks
Disables strict checks Tapestry-IoC or Tapestry may perform on methods.
DiscardAfter
Marks a method of a page or a component to discard all persistent field changes.
DiscardAfterWorker
DiscardBody
Discards a component's body.
Dispatcher
A dispatcher is responsible for recognizing an incoming request.
DisplayBlockContribution
Contribution to `BeanBlockSource` identifying a block that is used to display a property.
DocCommentTreeProvider
Doctype
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.
Document
The root node of a DOM.
DocumentLinker
Responsible for injecting script and style links into the <head> and <body> element of the rendered HTML document.
DocumentLinkerImpl
DTD
Representation of a document type.
DTDData
A capturing of the data from `LexicalHandler.startDTD(String, String, String)`.
DTDToken
Represents the presence of a Document Type declaration within a template.
Duration
Controls how long an `Alert` is displayed to the end user.
Dynamic
The Dynamic component allows a component to render itself differently at different times, by making use of an external template file.
DynamicDelegate
Used by implementations of `DynamicTemplate` to obtain `Block`s as replacements for elements within the template.
DynamicTemplate
A dynamic template is used by the `Dynamic` component to allow a component to significantly alter its presentation at runtime.
DynamicTemplateElement
A close cousin to `RenderCommand` used inside a `DynamicTemplate`.
DynamicTemplateParser
Parses a dynamic template based on a resource or an input stream.
DynamicTemplateParserImpl
DynamicTemplateSaxParser
Does the heavy lifting for `DynamicTemplateParserImpl`.
EagerLoad
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.
EagerLoadServiceProxy
Interface implemented by all service proxies.
EditBlockContribution
Contribution to `BeanBlockSource` identifying a block that is used to edit a property.
Element
An element that will render with a begin tag and attributes, a body, and an end tag.
Email
A validator that checks if a given string is well-formed email address.
EmbeddedComponentAssemblerImpl
EmbeddedComponentModel
The model for a component embedded within another component, as defined by the `Component` annotation.
EmptyAnnotationAccess
EmptyEventContext
Placeholder used when no context is available.
EndElementToken
Ends a previously started element (including components, parameters, blocks, etc.).
EndOfRequestCleanupFilter
Makes sure that `PerthreadManager.cleanup()` is invoked at the end of each request (normally handled by `TapestryFilter`).
EndOfRequestEventHub
Manages request notifications for the `EndOfRequestListener` interface.
EndOfRequestEventHubImpl
EndOfRequestListener
Event listener interface for objects that need to know when the current request finishes.
EndTagStyle
Part of a `MarkupModel`, used to define how end tags are handled when the `Document` in rendered out as a text stream.
EntityApplicationStatePersistenceStrategy
Persists Hibernate entities as SSOs by storing their primary key in the `Session`.
EntityApplicationStatePersistenceStrategy
EntityManagerManager
Manages `EntityManager`s for the current thread.
EntityManagerManagerImpl
EntityManagerObjectProvider
EntityManagerSource
Responsible for creating an EntityManager as needed.
EntityManagerSourceImpl
EntityPersistentFieldStrategy
Persists Hibernate entities by storing their id in the session.
EntityPersistentFieldStrategy
Persists JPA entities by storing their id in the session.
EntityTransactionManager
EntityTransactionManager.VoidInvokable
EntityTransactionManagerImpl
EnumSelectModel
A basic select model for a particular Enum type.
EnumValueEncoder<E extends Enum<E>>
A value encoder that can be used for arbitrary Enum types.
EnumValueEncoderFactory<E extends Enum<E>>
Deprecated.
this class is superseded by `TypeCoercedValueEncoderFactory` and scheduled to be removed in Tapestry 5.5
EnumValueLabelProvider<T extends Enum>
Provides a label from enum.
Environment
Provides access to environment objects, which are almost always provided to enclosed components by enclosing components.
Environmental
Defines a field of a component class that is replaced at runtime with a read-only value obtained from the `Environment` service.
EnvironmentalShadowBuilder
Much like `PropertyShadowBuilder`, except that instead of accessing a property of some other service, it accesses a value from within the `Environment` service.
EnvironmentalShadowBuilderImpl
EnvironmentalWorker
Obtains a value from the `Environment` service based on the field type.
EnvironmentImpl
A non-threadsafe implementation (expects to use the "perthread" service lifecyle).
EnvironmentMessages
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.
Error
Provides a client-side element to contain validation errors; this renders as a `<p class="help-block">`.
ErrorReporter
Responsible for writing an error report for the current test, after an assertion fails.
ErrorReporterImpl
ErrorReportingCommandProcessor
A wrapper around a standard command processor that adds additional exception reporting when a failure occurs.
Errors
Standard validation error presenter.
Event
The core methods related to event handling.
EventConstants
Constant values for common event names fired by Tapestry components.
EventContext
A collection of parameters that may eventually be passed to an event handler method.
EventContextRenderer
Renders out the values stored inside a `EventContext`.
EventHandlerMethodParameterProvider
Supplies one parameter value when invoking a component event handler method.
EventHandlerMethodParameterSource
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.
EventImpl
EventLink
A close relative of `ActionLink` except in two ways.
Events
Annotation applied to components to document what events a component may trigger.
ExceptionAnalysis
An analysis of an exception (including nested exceptions).
ExceptionAnalysisImpl
ExceptionAnalyzer
Analyzes an exception, providing an analysis.
ExceptionAnalyzerImpl
ExceptionDisplay
Integral part of the default `ExceptionReport` page used to break apart and display the properties of the exception.
ExceptionHandlerAssistant
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.
ExceptionInfo
Contains information about an analyzed exception.
ExceptionInfoImpl
ExceptionReport
Responsible for reporting runtime exceptions.
ExceptionReport.ActionLink
A link the user may press to perform an action (e.g., "Reload page").
ExceptionReporter
Interface implemented by a page used for reporting exceptions.
ExceptionReporterImpl
ExceptionReportWriter
Used by the default `ExceptionReporter` implementation to convert an exception into a stream of text that can be stored to a file.
ExceptionReportWriterImpl
ExceptionTracker
Used by `LoggingDecorator` to track which exceptions have been logged during the current request (the ExceptionTracker is perthread).
ExceptionTrackerImpl
ExceptionUtils
Contains static methods useful for manipulating exceptions.
ExpansionPageElement
ExpansionToken
A token containing an expression expansion from the template.
ExtensibleJavaScriptStack
An extensible implementation of `JavaScriptStack` that can be used as the implementation of a service.
ExtensionModule
A Tapestry module that is started for every specification which uses Spock's Tapestry extension.
ExtensionPointToken
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.
ExternalUrlAssetFactory
F
Functional operations on collections with generics support.
FactoryDefaults
Used to disambiguate which version of `SymbolProvider` is being referenced.
FailureMethodInvocationResult
FallbackObjectMapperSource
`ObjectMapperSource` implementation that always returns the same object returned by instantiating `ObjectMapper`.
Field
Defines a field within a form.
FieldConduit<T>
A `FieldConduit` is an object that effectively replaces the field in the instantiated object.
FieldFocusPriority
Used to determine which field on a page should receive focus, based on its status.
FieldHandle
Allows read/write access directly to a field (bypassing accessors).
FieldHandleImpl
FieldState
FieldTranslator<T>
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).
FieldTranslatorImpl<T>
FieldTranslatorSource
For a particular field, generates the default `FieldTranslator` for the field.
FieldTranslatorSourceImpl
FieldValidationSupport
Services to help with field validation and translation.
FieldValidationSupportImpl
FieldValidator<T>
Responsible for validation of a single field.
FieldValidatorDefaultSource
For a particular field, generates the default validation for the field, in accordance with a number of factors and contributions.
FieldValidatorDefaultSourceImpl
FieldValidatorImpl
FieldValidatorSource
Used to create `FieldValidator`s for a particular `Field` component.
FieldValidatorSourceImpl
FieldValueProvider
Interface that can be implemented to provide access to field values based on their name.
FileRefactorCommitParser
Interface that defines a file refactor parser.
FilterMethodAnalyzer
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).
FixedExtractor<T extends Annotation>
Implementation of `MetaDataExtractor` that is used to set a fixed value for a fixed meta-data key, when a given annotation is present.
FlashPersistentFieldStrategy
The "flash" strategy stores data inside the `session`, just like `SessionPersistentFieldStrategy`, but also removes the values from the session on first use.
Flow<T>
A flow is a a functional interface for working with an ordered collection of elements.
FlowOperations<T,FT>
FontAwesomeIcon
Renders an `<i>` tag with the CSS class to select a FontAwesome 4.7.0 icon.
ForceReload
Forces a reload of all caches and invalidates the component class cache.
Form
An HTML form, which will enclose other components to render out the various types of fields.
FormControlNameManager
Service providing methods related to names that shouldn't be used as form control element names or ids.
FormControlNameManagerImpl
FormFieldFocus
Deprecated.
As of release 5.4, replaced by `OverrideFieldFocus`
FormFragment
A FormFragment is a portion of a Form that may be selectively displayed.
FormGroup
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.
FormsRequirePostException
Exception thrown by Tapestry's `Form` component when the request method is other than POST.
FormsRequirePostExceptionHandlerAssistant
Handles `FormsRequirePostException`s (thrown by the `Form` component when the request method was other than post) by redirecting to the page containing the form.
FormSupport
Services provided by an enclosing Form control component to the various form element components it encloses.
FormSupportAdapter
An implementation of `FormSupport` that delegates all behavior to another instance of FormSupport.
FormSupportImpl
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.
FormValidationControl
Allows control over the validation concerns of a Form component.
FunctionName
Overrides the default mapping from method name to Clojure function name.
GenericsResolver
Methods related to the use of Java 5+ generics.
GenericsResolver.Provider
Convenience class for getting a `GenericsResolver` instance.
GenericsResolverImpl
Implementation copied from Tapestry 5.4's GenericUtils (commons package).
GenericsUtils
Static methods related to the use of JDK 1.5 generics.
GenericValueEncoderFactory<V>
An implementation of `ValueEncoderFactory` that returns a pre-wired instance of `ValueEncoder`.
GlobPatternMatcher
Used when matching identifiers.
Glyphicon
Renders a `<span>` tag with the CSS class to select a Bootstrap Glyphicon.
GoogleClosureMinimizerOptionsProvider
Provide CompilerOptions for the GoogleClosureMinimizer.
Graphviz
Component that renders a Graphviz graph using @hpcc-js/wasm.
Grid
A grid presents tabular data.
GridCell
Part of `Grid` that renders the markup inside a single data cell.
GridColumns
Renders out the column headers for the grid, including links (where appropriate) to control column sorting.
GridConstants
GridDataSource
Defines how a `Grid` component (and its sub-components) gain access to the row data that is displayed on the page.
GridModel
A provider of model data to the sub-components of the `Grid` component.
GridPager
Generates a series of links used to jump to a particular page index within the overall data set.
GridPagerPosition
Used by the `Grid` component to control where the pager portion of the Grid should be displayed.
GridPaginationModel
Store pagination information, such as the current page, sort column, and sort ascending vs.
GridPaginationModelImpl
Standard implementation of `GridPaginationModel`.
GridRows
Renders out a series of rows within the table.
GridSortModel
Models the sorting applied to the a `GridDataSource`.
GuavaGenericsResolver
`GuavaGenericsResolver` implementation using Guava.
GZIPEnabledResponse
GZipFilter
Filter that adds GZIP compression to the response, if the client supports it.
Heartbeat
Allows for deferred execution of logic, useful when trying to get multiple components to coordinate behavior.
HeartbeatDeferred
Marks a component method as deferred until the end of the `Heartbeat`.
HeartbeatDeferredWorker
HeartbeatImpl
HibernateConfigurer
Defines the interface for a chain-of-command that updates Hibernate configuration in some way before the `SessionFactory` is created.
HibernateConstants
Defines constants used inside the Tapestry Hibernate intergration.
HibernateCore
Marker annotation used to identify services defined in the `HibernateCoreModule`.
HibernateCoreModule
Defines core services that support initialization of Hibernate and access to the Hibernate `Session`.
HibernateEntityPackageManager
Contains a set of contributed package names from which to load entities.
HibernateEntityValueEncoder<E>
HibernateGridDataSource
A simple implementation of `GridDataSource` based on a Hibernate Session and a known entity class.
HibernateModule
Supplements the services defined by `HibernateCoreModule` with additional services and configuration specific to Tapestry web application.
HibernatePersistenceConstants
Constants for persistent field strategies.
HibernateSessionManager
Manages the Hibernate session for the current thread.
HibernateSessionManagerImpl
HibernateSessionSource
Responsible for creating a Hibernate session as needed.
HibernateSessionSourceImpl
HibernateStatistics
Page used to see the Hibernate statistics.
HibernateSymbols
Configuration symbols, for use with contributions to `ApplicationDefaults`.
HibernateTransactionAdvisor
A replacement for `HibernateTransactionDecorator`.
HibernateTransactionAdvisorImpl
HibernateTransactionDecorator
Service that can create an interceptor that wraps around a service implementation.
HibernateTransactionDecoratorImpl
Hidden
Used to record a page property as a value into the form.
HiddenFieldLocationRules
Provides some assistance in determining where to place a hidden field based on standard (X)HTML elements.
HiddenFieldLocationRulesImpl
HiddenFieldPositioner
Used to position a hidden field (as part of a form-related component).
Holder<T>
An object that holds some type of other object.
Html5DateField
A component used to collect a provided date from the user using the native HTML5 date picker (<input type="date">)
Html5MarkupModel
Implementation of `MarkupModel` that correctly handles HTML5 void elements.
Html5Support
Service related to Tapestry's support of HTML5 features.
Html5SupportImpl
HttpError
An event handler method may return an instance of this class to send an error response to the client.
HttpErrorComponentEventResultProcessor
Handles `HttpError` by invoking `Response.sendError(int, String)`.
HttpRequestBodyConverter
Service that converts the body of an HTTP request to a given target class.
HttpServletRequestFilter
Filter interface for `HttpServletRequestHandler`.
HttpServletRequestHandler
The first step in handing an incoming request to the servlet filter, this constructed as a pipeline.
HttpStatus
An event handler method may return an instance of this class to send an specific HTTP status code to the client.
HttpStatusComponentEventResultProcessor
Handles `HttpStatus`.values returned by event handler methods.
Id
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).
IdAllocator
Used to "uniquify" names within a given context.
IdentityAssetPathConverter
Returns the default asset path unchanged.
IdMatcher
A matcher of fully qualified ids.
IdMatcherImpl
A wrapper around a `GlobPatternMatcher` used to glob-match service ids.
IdToDependencyNode<T>
Used to order objects into an "execution" order.
If
Conditionally renders its body.
IgnoredPathsFilter
ImmutableSessionPersistedObject
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.
Import
Annotations to control the importing of JavaScript stacks and libraries as well as stylesheets.
ImportModule
Attached to a module class, this annotation identifies other module classes that should also be added to the Registry.
ImportWorker
Implements the `Import` annotation, both at the class and at the method level.
IncompatibleChange
Index
Shows an OpenAPI definition viewer based on Swagger UI.
InheritanceData
Used to track which methods are implemented by a base class, which is often needed when transforming a subclass.
InheritanceSearch
Used to search from a particular class up the inheritance hierarchy of extended classes and implemented interfaces.
Initialization
Provided by `JavaScriptSupport.require(String)` to allow additional, optional, details of the module-based page initialization to be configured.
InitializationPlan<T>
Performs one initialization step on a newly created object.
InitializationPriority
Sets the priority for JavaScript initialization scripting.
InitializeActivePageName
Filter contributed into the `ComponentRequestHandler` pipeline to set the `activePageName property`.
Inject
This annotation serves is something of the Swiss Army knife for operations related to injection of dependencies into an arbitrary method of Java Bean.
InjectComponent
Allows components defined in the template to be injected as read-only properties.
InjectComponentWorker
Recognizes the `InjectComponent` annotation, and converts the field into a read-only field containing the component.
InjectContainer
Used to inject the component which contains this component.
InjectContainerWorker
Identifies the `InjectContainer` annotation and adds code to initialize it to the core component.
InjectionProvider2
Provides some form of injection when the value for an `Inject` annotation is present.
InjectionResources
Provides for the injection of specific types of values as resources as opposed to services or objects obtained from `MasterObjectProvider`.
InjectNamedProvider
Processes the combination of `Inject` and `Named` annotations.
InjectPage
Allows a a page (really, the root component of the page) to be injected into another component as a read-only field.
InjectPageWorker
Performs transformations that allow pages to be injected into components.
InjectResource
Deprecated.
Deprecated in Tapestry 5.3, to be removed in a later release.
InjectService
Annotation used with parameters of service builder methods to identify the service to be injected into the service builder method via the parameter.
InjectServiceWorker
Processes the `InjectService` annotation.
InjectWorker
Performs injection triggered by any field annotated with the `Inject` annotation or the `Inject` annotation.
InsertPosition
InstanceContext
Defines per-instance context values for a transformed PlasticClass.
Instantiator
An object that can instantiate a component.
InstructionBuilder
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.
InstructionBuilderCallback
Used in various places to allow some code to be constructed under controlled circumstances.
InstructionBuilderImpl
InstructionBuilderState
Stores information about the method whose instructions are being constructed, to make it easier to share data across multiple instances.
IntegerRange
Represents a sequence of integer values, either ascending or descending.
InterceptorStackBuilder
Responsible for constructing the interceptor stack, on demand, by invoking an ordered series of decorators ( `DecoratorDef` (which are converted into `ServiceDecorator`s).
IntermediateType
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.
Internal
Marker annotation for the internal `JavaScriptStack`.
InternalCommonsUtils
Utility methods class for the Commons package.
InternalComponentInvalidationEventHub
Split-out implementation of `InvalidationEventHub` that separates it from `ComponentInstantiatorSource`.
InternalComponentInvalidationEventHubImpl
InternalComponentResources
An extension of `ComponentResources` that represents additional methods that are private to the framework and not exposed in any public APIs.
InternalComponentResourcesCommon
Operations shared by `InternalComponentResources` and `ComponentPageElement`.
InternalComponentResourcesImpl
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.
InternalConstants
InternalFormSupport
Additional methods for `FormSupport` used internally by Tapestry.
InternalLayout
A default layout for a number of internal pages in Tapestry, such as `ServiceStatus` and `PageCatalog`.
InternalModule
`TapestryModule` has gotten too complicated and it is nice to demarkate public (and stable) from internal (and volatile).
InternalPlasticClassTransformation
InternalPropBinding
Internal marker interface for PropBinding
InternalPropertyConduit
Extension to `PropertyConduit2` that adds a method to determine the name of the property.
InternalRegistry
Internal view of the module registry, adding additional methods needed by modules.
InternalRequestGlobals
Stores global per-request data internal to the framework.
InternalRequestGlobalsImpl
InternalSymbols
InternalTestModule
Provides the "t5internal" library, that provides common text utilities needed by some of the other projects' integration tests.
InternalUtils
Utilities used within various internal implementations of the tapestry-ioc module.
IntervalSchedule
A very simple schedule, that simply executes the desired job at fixed intervals.
InvalidationEventHub
An object which manages a list of `InvalidationListener`s.
InvalidationEventHubImpl
Base implementation class for classes (especially services) that need to manage a list of `InvalidationListener`s.
InvalidationListener
Deprecated.
In 5.4; use `InvalidationEventHub.addInvalidationCallback(Runnable)` instead
Invariant
Special annotation that is applied to literal `PropertyConduit`s, to inform `PropBinding` that the value is, in fact, invariant.
InvariantBinding
Extends `AbstractBinding` with a description and a binding type, with invariant forced to true.
Invokable<T>
Similar to `Runnable` except that it returns a value.
IOCConstants
IOCSymbols
Configuration symbols used by the IoC container.
IOCTestCase
Deprecated.
In 5.4, with no replacement
IOCUtilities
A collection of utility methods for a couple of different areas, including creating the initial `Registry`.
IOOperation<T>
An operation that, when performed, returns a value (like `Invokable`, but may throw an `IOException`.
JacksonComponentEventResultProcessor<T>
Handles mapped entity class instances using Jackson Databind when they're returned by event handler methods.
JacksonHttpRequestBodyConverter
JacksonOpenApiTypeDescriber
`OpenApiTypeDescriber` implementation using Java JSONSchema Generator, by default generating JSON Schema 2019-09.
JavaScriptAggregationStrategy
Used with `JavaScriptStack` to identify how libraries and modules within the stack can be aggregated.
JavaScriptCallback
A callback used with `AjaxResponseRenderer.addCallback(JavaScriptCallback)`.
JavaScriptModule
Defines the services related to JavaScript and `JavaScriptStack`s.
JavaScriptModuleConfiguration
Used to define a module shim, used to adapt non-AMD JavaScript libraries to operate like proper modules.
JavaScriptStack
A high level description of a group of related JavaScript libraries and stylesheets.
JavaScriptStackAssembler
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.
JavaScriptStackAssemblerImpl
JavaScriptStackMinimizeDisabler
Attempts to match resources against a `JavaScriptStack`, and possibly disabled minimization based on the stack.
JavaScriptStackPathConstructor
Used to generate a list of asset URL paths for the JavaScript libraries of a JavaScript stack.
JavaScriptStackPathConstructorImpl
JavaScriptStackSource
Manages the available `JavaScriptStack`s, each of which has a unique name.
JavaScriptStackSourceImpl
JavaScriptSupport
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.
JavaScriptSupportImpl
JCacheModule
Tapestry-IoC module that
Jetty7Runner
Deprecated.
please use `JettyRunner` instead
JettyRunner
Launches an instance of Jetty.
JmxModule
Module for JMX services.
JpaConstants
Defines constants used inside the Tapestry JPA integration.
JpaEntityPackageManager
Contains a set of contributed package names from which to load entities.
JpaGridDataSource<E>
A simple implementation of `GridDataSource` based on a EntityManager and a known entity class.
JpaInternalUtils
JpaModule
Defines core services for JPA support.
JpaPersistenceConstants
Constants for persistent field strategies.
JpaSymbols
Configuration symbols, for use with contributions to `ApplicationDefaults`.
JpaTransactionAdvisor
Service that can create an interceptor that wraps around a service implementation.
JpaTransactionAdvisorImpl
JpaValueEncoder<E>
JSONArray
A dense indexed sequence of values.
JSONArrayIndexOutOfBoundsException
JSONCallback
A callback used with `AjaxResponseRenderer.addCallback(JSONCallback)`.
JSONCollection
Base class for `JSONArray` and `JSONObject` that exists to organize the code for printing such objects (either compact or pretty).
JSONCollectionEventResultProcessor
JSONCollectors
Implementations of `Collector` that implement reductions to `JSONArray` and to `JSONObject`.
JSONInvalidTypeException
JSONLiteral
A way of including some text (often, text that violates the normal JSON specification) as part of a JSON object or array.
JSONModule
A module that integrates JSON into Tapestry in terms of type coercions.
JSONObject
A modifiable set of name/value mappings.
JSONObjectEventResultProcessor
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.
JSONString
An interface that allows an object to be stored as a `JSONObject` or `JSONArray` value.
JSONSyntaxException
JSONType
Represents the different data types supported by JSON.
JSONTypeMismatchException
JSONValueNotFoundException
JustInTimeObjectCreator<T>
Invoked from a fabricated service delegate to get or realize (instantiate and configure) the service implementation.
Kaptcha
Used to explicitly select the kaptcha editor block for a property.
KaptchaDataTypeAnalyzer
KaptchaEditBlocks
Page containing kaptcha edit blocks contributed into the `BeanBlockSource` service configuration.
KaptchaField
Field paired with a `KaptchaImage` to ensure that the user has provided the correct value.
KaptchaImage
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).
KaptchaModule
Defines core services for Kaptcha support.
KaptchaProducer
Extension of the `Producer` interface, adding property for getting the Kaptcha image width and height (used when rendering the <img> element).
KaptchaProducerImpl
KaptchaSymbolConstants
Defines constants used by the `KaptchaModule` and related components.
KeyValue
A key/value pair.
Label
Generates a <label> element for a particular field.
LazyAdvisor
An advisor that identifies methods which can be evaluated lazily and advises them.
LazyAdvisorImpl
LazyContinuation<T>
The result of the evaluation of a `LazyFunction`.
LazyFunction<T>
A lazy function is used to populate a `Flow` incrementally.
LazyValue<T>
A function that returns a value, allowing the computation of that value to be deferred as late as possible.
LazyZipValue<A,B>
LibraryMapping
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).
LifecycleNotificationComponentCallback
Implementation of `ComponentCallback` used for lifecycle notifications that do not have an event, and can therefore never be aborted.
LifecycleWrappedServiceCreator
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).
Link
A link is the Tapestry representation of a URL or URI that triggers dynamic behavior.
LinkCreationHub
A service that allows listeners to be registered to learn about `Link` creation.
LinkCreationListener
Deprecated.
Use `LinkCreationListener2` instead
LinkCreationListener2
LinkDecorationListener
A default `LinkCreationListener2` that triggers the `EventConstants.DECORATE_COMPONENT_EVENT_LINK` and `EventConstants.DECORATE_PAGE_RENDER_LINK` events as links are generated.
LinkImpl
LinkSecurity
Identifies how a `Link` should handle security.
LinkSource
A source for `Link` objects.
LinkSourceImpl
LinkSubmit
Generates a client-side hyperlink that submits the enclosing form.
LinkTransformer
A facade around `ComponentEventLinkTransformer` and `PageRenderLinkTransformer`.
LinkTransformerImpl
LinkTransformerInterceptor
Intercepts some methods of `ComponentEventLinkEncoder`, passing the returned `Link`s through methods of`LinkTransformer`.
ListRenderer
Renders a List, but rendering an unordered list.
LiteralBinding
Binding type for literal, immutable values.
LiteralBindingFactory
Binding factory that treats the expression as a literal string.
LiteralPropertyConduit
A PropertyConduit for a literal value in an expression, such as a number, or "true", "false" or "null".
Local
A special marker annotation which limits the search for possible services to just the same module containing the service being injected.
LocalDate
Used to present a date, formatted in the time zone of the client browser.
LocaleUtils
Contains code borrowed from commons-lang.
LocalhostOnly
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.
LocalizationSetter
Sets the thread's locale given a desired locale.
LocalizationSetterImpl
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.
LocalizedNameGenerator
Generates name variations for a given file name or path and a locale.
LocalVariable
Variable available inside a `LocalVariableCallback`.
LocalVariableCallback
A callback for generating code where a local variable is in effect.
Locatable
Interface implemented by objects which carry a location tag.
Location
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.
LocationImpl
Implementation class for `Location`.
LocationRenderer
Responsible for rendering a `Location`.
Lockable
An object that can be locked, at which point most of its functionality is disabled.
LockSupport
Base class for classes that need to manage a ReadWriteLock.
Log
Marker annotation for component methods to enable debug-level logging.
LoggerSource
A wrapper around SLF4J's LoggerFactory that exists to allow particular projects to "hook" the creation of Logger instances.
LoggerSourceImpl
Simple wrapper around SLF4J's LoggerFactory.
LoggingAdvice
LoggingAdvisor
A service used in conjunction with a service advisor method to add logging advice to a service.
LoggingAdvisorImpl
LoggingDecorator
Service that can create a logging interceptor that wraps around a service implementation (or interceptor).
LoggingDecoratorImpl
LoggingInvokableWrapper<T>
LogWorker
Looks for the `Log` marker annotation and adds method advice to perform the logging.
Loop<T>
A basic looping component; loops over a number of items (provided by its source parameter), rendering its body for each one.
LoopFormState
Identifies how a `LoopFormState` component stores state into the `FormSupport` object.
MacOutputStream
An output stream that wraps around a `Mac` (message authentication code algorithm).
Main
MapInjectionResources
InjectionDefaultProvider that operates using a Map from type to value.
MapMessages
Implementation of `Messages` based on a simple Map (of string keys and values).
MappedConfiguration<K,V>
Object passed into a service contributor method that allows the method provide contributed values to the service's configuration.
MappedConfigurationOverride<K,V>
MappedEntityManager
Service which provides a list of mapped entities.
MappedEntityManagerImpl
Default `MappedEntityManager` implementation.
Mapper<S,T>
Interface for operation `Flow.map(Mapper)` to define how Flow elements are mapped from one type to another (or otherwise transformed).
Mapper2<A,B,C>
A generalization of `Mapper` for a two-input function.
MapSymbolProvider
Provides symbol values from a Map of symbol names and symbol values (typically provided by a Tapestry IOC service configuration).
Markable
Interface implemented by objects which need to disambiguate services with marker annotations.
Marker
Used to define one or more ServiceDef#getMarkers() marker annotations for a service implementation.
MarkupConstants
Constants used when rendering page markup.
MarkupModel
Used by a the DOM to determine how to produce markup.
MarkupRenderer
An object which will perform rendering of a page (or portion of a page).
MarkupRendererFilter
Filter interface for `MarkupRenderer`, which allows for code to execute before and/or after the main rendering process.
MarkupRendererTerminator
Terminator for the [@link MarkupRenderer} pipeline, which exists to invoke `PageRenderQueue.render(org.apache.tapestry5.MarkupWriter)`.
MarkupUtils
Utility methods related to generating markup.
MarkupWriter
An interface used by objects, such as Tapestry components, that need to render themselves as some form of XML markup.
MarkupWriterAdapter
Default, empty implementation of `MarkupWriterListener`.
MarkupWriterFactory
Source for `MarkupWriter` instances.
MarkupWriterFactoryImpl
MarkupWriterImpl
MarkupWriterListener
An interface that allows objects to be alerted after an element is started, and after an element is ended.
MasterObjectProvider
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.
MasterObjectProviderImpl
MasterResourceMinimizer
Implementation that delegates, via its configuration, to a real implementation based on the content type of the resource.
Match
Optional, but typically used, annotation for service decorator methods, used to define which services the decorator applies to.
MavenComponentLibraryInfoSource
`ComponentLibraryInfoSource` implementation based on the pom.xml and pom.properties files Maven places in the /META-INF/maven/[groupId]/[artifactId] folder.
Max
Enforces a maximum integer value.
MaxLength
Validates that a string value has not exceeded a maximum length.
MBeanSupport
Creates an MBean server and registers MBeans with the created server.
MBeanSupportImpl
MessageBindingFactory
Implementation of the message: binding prefix -- we simply get the message key and store it inside at `LiteralBinding`.
MessageCatalogResource
MessageFormatter
Obtained from a org.apache.tapestry5.ioc.Messages, used to format messages for a specific localized message key.
MessageFormatterImpl
MessageInterpolatorImpl
The default message interpolation algorithm uses `Locale.getDefault()`.
Messages
Provides access to a messages catalog, a set of properties files that provide localized messages for a particular locale.
MessagesBundle
Represents a bundle of properties files that can be used to collect properties that are eventually used to form a `Messages`.
MessagesConstraintGenerator
Generates constraints from the containing component's property file.
MessagesImpl
Implementation of `Messages` based around a `ResourceBundle`.
MessagesSource
MessagesSourceImpl
A utility class that encapsulates all the logic for reading properties files and assembling `Messages` from them, in accordance with extension rules and locale.
MessagesTrackingInfo
Class that holds information about a messages properties file for tracking.
Meta
Allows for the specification of per-component meta-data.
MetaAnnotationExtractor
MetaDataConstants
Meta-data keys that are applied to components and pages.
MetaDataExtractor<T extends Annotation>
Used to extract a meta data value from a component annotation.
MetaDataLocator
Used to lookup meta data concerning a particular component.
MetaDataLocatorImpl
MetaWorker
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.
MetaWorkerImpl
MethodAdvice
MethodAdvice is a special callback that is threaded into the implementation of a method.
MethodAdviceReceiver
Interface used with service advisor methods to define advice.
MethodAlreadyExistsException
Exception raised when there's an attempt to create a method which already exists in a class.
MethodCompileException
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.
MethodDescription
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.
MethodHandle
Similiar to `Method`, this allows a method of a Plastic class to be invoked regardless of visibility.
MethodHandleImpl
MethodInvocation
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.
MethodInvocationBundle
Bundles together the fixed (same for all instances) information needed by a `MethodInvocationBundle`.
MethodInvocationFailResult
Implementation of `MethodInvocationResult` for failed invocations (where a checked exception was thrown).
MethodInvocationResult
The result of a method invocation, which encapsulates the actual return value (if any), as well as any checked exception.
MethodInvocationResult
Captures the result of invoking a method.
MethodInvocationSuccessfulResult
Implementation of `MethodInvocationResult` for successful method invocations.
MethodInvoker<T>
MethodIterator
Utility used to iterate over the publicly visible methods of a class or interface.
MethodLogger
Used by `LoggingDecoratorImpl` to delegate out logging behavior to a separate object.
MethodParameter
Access to the parameters of a method, in particular, any visible annotations on that method.
MethodResultCache
Manages a cache value as the result of invoking a no-arguments method.
MethodSignature
A representation of a `Method`, identifying the name, return type, parameter types and exception types.
MethodToFunctionSymbolMapper
Maps a method from a service interface to a fully-qualified Clojure function name, as a Clojure `Symbol`.
Min
MinLength
Validates that a string value has a minimum length.
Mixin
Defines an implementation mixin for a component.
MixinAfter
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.
MixinAfterWorker
Looks for the `MixinAfter` annotation and sets the `mixinAfter flag` if present.
MixinClasses
Used to attach one or more instance mixins to an embedded component.
Mixins
Used to attach one ore more instance mixin to an embedded component.
MixinWorker
Supports the `Mixin` annotation, which allows a mixin to be part of the implementation of a component.
MockTester
Deprecated.
In 5.4, with no replacement
Module
A module within the Tapestry IoC registry.
ModuleBuilderSource
The source for the module instance needed by any service builders, service contributors and service decorators that are mapped to instance methods.
ModuleConfigurationCallback
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.
ModuleDef
Defines the contents of a module.
ModuleDef
Marker annotation for a method which creates a `ModuleDef`.
ModuleDef2
Extended version of `ModuleDef` introduced in Tapestry 5.1 to allow for service advisors (an improvement on service decorators).
ModuleDispatcher
Handler contributed to `AssetDispatcher` with key "modules".
ModuleImpl
ModuleInitsManager
ModuleManager
Responsible for managing access to the JavaScript modules.
ModuleManagerImpl
MongoDB
MongoDBImpl
Default implementation for `MongoDB`
MongodbModule
Defines services which are responsible for MongoDB initializations and connections.
MongoDBSource
MongoDBSourceImpl
Default implementation for `MongoDBSource`
MongoDBSymbols
Configuration symbols, for use with contributions to `ApplicationDefaults`.
MultiKey
Combines multiple values to form a single composite key.
MultipartDecoder
Responsible for detecting and processing file upload requests, using Jakarta Commons FileUpload.
MultipartDecoderImpl
Implementation of multipart decoder for servlets.
MultipartServletRequestFilter
Filter that decodes an incoming multipart request.
MultiZoneUpdate
Deprecated.
Deprecated in 5.3; use the `AjaxResponseRenderer` service instead of returning an instance of MultiZoneUpdate
MultiZoneUpdateEventResultProcessor
Deprecated.
Deprecated in 5.3
MutableComponentModel
Mutable version of `ComponentModel` used during the transformation phase.
MutableComponentModelImpl
Internal implementation of `MutableComponentModel`.
MutableEmbeddedComponentModel
A mutable version of `EmbeddedComponentModel` that allows the parameters to be incrementally stored.
MutableEmbeddedComponentModelImpl
NameCache
A cache of translations from type names to internal names and descriptors, as well as a cache from MethodDescription to method descriptor.
NamedSet<T>
Simple, thread-safe associative array that relates a name to a value.
Namespace
Maps a service interface to a Clojure namespace.
NoBootstrapModule
Module which defines the options needed to run Tapestry without Bootstrap.
Node
A node within the DOM.
None
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.
NonParallelExecutor
Implementation of `ParallelExecutor` used when the thread pool is disabled.
NonVisual
Marker annotation for properties which are non-visual, and so should not appear (by default) inside a BeanModel.
NoopAnnotatedType<X>
NoopBeanManager
NoopCreationalContext<T>
NoopDelegate
NoopInjectionTarget<T>
NotEmpty
A mixin that attaches to an element that renders an element.
NotificationEventCallback
A `ComponentEventCallback` used for notification events.
NotLazy
Marks a method as specifically not-lazy, even if other methods in the same interface are being advised as lazy.
NullAnnotationProvider
A null implementation of `AnnotationProvider`, used when there is not appropriate source of annotations.
NullDataSource
An implementation of `GridDataSource` used when the value null is provided as the source.
NullFieldStrategy
Defines a strategy, used by `Field` components such as `TextField`, to handle the case where either the server-side value to be sent (as a string) to the client, or the client-side string passed back up to the server, is null or blank.
NullFieldStrategyBindingFactory
Treats the expression as the name of a `NullFieldStrategy`, accessed via the `NullFieldStrategySource` service.
NullFieldStrategySource
A source for `NullFieldStrategy` instances based on a logical name.
NullFieldStrategySourceImpl
NumericFormatter
Interface for defining the basic parse and toClient operations.
NumericFormatterImpl
A wrapper around NumberFormat.
NumericTranslator<T extends Number>
Uses a `NumericTranslatorSupport` to provide proper locale-aware support for all the built-in numeric types.
NumericTranslatorSupport
Used to generate the client-side JSON specification for how a number-based validator operates.
NumericTranslatorSupportImpl
ObjectArrayRenderer
Renders an Object[] array as an unordered list.
ObjectComponentEventResultProcessor
A catch-all for type Object that reports the return value as an error.
ObjectCreator<T>
Interface used to encapsulate any strategy used defer the creation of some object until just as needed.
ObjectCreatorSource
An object which can, when passed a `ServiceBuilderResources`, create a corresponding `ObjectCreator`.
ObjectLocator
Defines an object which can provide access to services defined within a `Registry`, or to objects or object instances available by other means.
ObjectLocatorImpl
Base service locator class used when only the module is known (i.e., when instantiating a module class).
ObjectMapperSource
Service that provides `ObjectMapper` instances for specific mapped entity classes.
ObjectProvider
Object providers represent an alternate way to locate an object provided somewhere in the `Registry`.
ObjectRenderer<T>
A strategy interface used for converting an object into markup that describes that object.
OneShotLock
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.
OnEvent
Marks a method as a handler for a client side event.
OnEventWorker
Provides implementations of the `Component.dispatchComponentEvent(org.apache.tapestry5.runtime.ComponentEvent)` method, based on `OnEvent` annotations and naming conventions.
Opcodes
Used to document the `InstructionBuilder` and `TryCatchBlock`
OpenApiDescriptionDispatcher
Recognizes requests where the path matches the value of `SymbolConstants.OPENAPI_DESCRIPTION_PATH` (`/openapi.json` by default).
OpenApiDescriptionGenerator
Service used to generate OpenAPI 3.0 description in JSON format for an application REST endpoints (i.e.
OpenApiTypeDescriber
Interface that describes the type of a REST endpoint parameter, return type or request body.
Operation
Describes a method as one that should be operation tracked.
OperationAdvisor
Used from a service advice method to identify methods with the `Operation` annotation, and add advice for those methods.
OperationAdvisorImpl
OperationException
An exception caught and reported by an `OperationTracker`; the trace property identifies what operations were active at the time of the exception.
OperationTracker
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.
OperationTracker.NonLoggableException
Annotation to be be used in exception classes whose instances are not meant to be logged in OperationTracker.
OperationTrackerImpl
Core implementation that manages a logger and catches and reports exception.
OperationTrackingObjectCreator
Makes sure the operations tracker is notified knows that a service is being realized.
OperationWorker
Add support for the `Operation` annotation on component class methods.
OptimizedSessionPersistedObject
An optional interface implemented by objects that are persisted in the `Session`.
OptimizedSessionPersistedObjectAnalyzer
Optional
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.
OptionGroupModel
Defines a group of related options.
OptionGroupModelImpl
OptionModel
A single option within a `OptionGroupModel`.
OptionModelImpl
Order
Used with a service decorator method to control the order in which decorations occur.
Orderable<T>
A wrapper that allows objects of a target type to be ordered.
OrderConstraint
Represents an order constraints for `OrderedConfiguration`.
OrderConstraintBuilder
Constructs order constraints for `OrderedConfiguration`.
OrderedConfiguration<T>
Object passed into a service contributor method that allows the method provide contributed values to the service's configuration.
Orderer<T>
Used to order objects into an "execution" order.
OrIdMatcher
A wrapper around a collection of IdMatchers.
Output
A component for formatting output.
OutputRaw
Used to output raw markup to the client.
OverrideFieldFocus
A mixin that let a `Field` gain focus.
PackageAndArtifactChangeRefactorCommitParser
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`.
PackageChangeRefactorCommitParser
Parses lines like this, in which just the package is changed: `commons/src/main/java/org/apache/tapestry5/{ioc => commons}/Messages.java (98%)`.
PackageNameHibernateConfigurer
Adds entity classes from a given set of packages to the configuration.
PackageNamePersistenceUnitConfigurer
Page
Represents a unique page within the application.
Page.Stats
Page construction statistics for the page.
PageActivationContext
Annotation for a field for which the page activation context handlers (onActivate and onPassivate) should be created.
PageActivationContextCollector
Fires the `EventConstants.PASSIVATE` event on a page, and collects the result, converting it to an array of objects.
PageActivationContextCollectorImpl
PageActivationContextWorker
Provides the page activation context handlers.
PageActivator
Responsible for firing the EventConstants.ACTIVATE event on the page.
PageActivatorImpl
PageAttached
Method annotation used for methods that should be invoked when the page is first attached to a request.
PageCachingReferenceTypeService
A service which defines whether cache page instances should have soft references pointing to it (the default) or strong, non-garbage-collectable ones.
PageCallback
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.
PageCatalog
Lists out the currently loaded pages, using a `Grid`.
PageCatalogTotals
PageClassLoaderContext
Class that encapsulates a classloader context for Tapestry's live class reloading.
PageClassLoaderContextManager
Service that creates PageClassLoaderContext instances (except the root one) when a class in a controlled page is first used in the Tapestry page pool.
PageClassLoaderContextManagerImpl
Default PageClassLoaderContextManager implementation.
PageClassLoaderContexts
Shows information about the page classloader contexts.
PageContentTypeAnalyzer
PageContentTypeAnalyzerImpl
PageDependencyGraph
Shows graph showing the dependencies of all already loaded pages and its compnoents, mixins and base classes.
PageDetached
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.
PageDocumentGenerator
Interface used to programatically render a page, forming a `Document` which can then be manipulated or streamed to a PrintWriter.
PageDocumentGeneratorImpl
PageElementFactory
Used by the `PageLoader` to create partialar page elements.
PageElementFactoryImpl
PageImpl
PageLifecycleAdapter
Deprecated.
in 5.3.4, as `PageLifecycleListener` has been deprecated
PageLifecycleAnnotationWorker
Similar to `RenderPhaseMethodWorker` but applies to annotations/methods related to the overall page lifecycle.
PageLifecycleCallbackHub
Defines a way for different aspects of a page to add callbacks for important lifecycle events.
PageLifecycleListener
Deprecated.
in 5.3.4, replaced with `PageLifecycleCallbackHub`
PageLink
Generates a render request link to some other page in the application.
PageLoaded
Method annotation used for methods that should be invoked once the page is fully loaded.
PageLoader
Instantiates a fully loaded, configured instance of a Tapestry page.
PageLoaderImpl
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.
PageLoadModule
PageMarkupRenderer
Service used to render page markup using a MarkupWriter.
PageMarkupRendererImpl
PageNameComponentEventResultProcessor
Used when a component event handler returns a string value.
PageNameMetaInjector
Injects a `<meta/>` element into the `<head/>` to identify the Tapestry page name.
PagePreloader
Used to perform a pre-load of pages, at startup time.
PagePreloaderImpl
PageRenderDispatcher
Dispatches incoming requests for render requests.
PageRenderLinkSource
A service that allows other services to create page render links.
PageRenderLinkSourceImpl
PageRenderLinkTransformer
Allows the default `Link` for a page render request to be replaced.
PageRenderQueue
A wrapper around `RenderQueue`, but referencable as a (per-thread) service.
PageRenderQueueImpl
This services keeps track of the page being rendered and the root command for the partial render, it is therefore request/thread scoped.
PageRenderRequestFilter
Filter interface for `PageRenderRequestHandler`, which allows extra behaviors to be injected into the processing of a page render request.
PageRenderRequestHandler
Handles a invocation related to rendering out a pages complete content.
PageRenderRequestHandlerImpl
Handles a page render request by activating and then rendering the page.
PageRenderRequestParameters
Used with `PageRenderRequestHandler` and `PageRenderRequestFilter` to define the logical page name and activation context for the request.
PageReset
Marker annotation for a method that should be invoked when a page is reset.
PageResetAnnotationWorker
Implementation of the `PageReset` annotation.
PageResetListener
Deprecated.
in 5.3.4
PageResponseRenderer
Service responsible for writing a full page markup response.
PageResponseRendererImpl
PageSource
Access to localized page instances (which are now shared singletons, starting in release 5.2).
PageSourceImpl
PageTemplateLocator
The special case for pages, where the template is searched for in the web application context.
PageTester
This class is used to run a Tapestry app in a single-threaded, in-process testing environment.
PageTesterContext
PageTesterModule
Used in conjunction with `PageTester` to mock up and/or stub out portions of Tapestry that need to be handled differently when testing.
PageTesterSession
Palette
Multiple selection component.
ParallelExecutor
A service that allows work to occur in parallel using a thread pool.
ParallelExecutorImpl
Parameter
Annotation placed on a field to indicate that it is, in fact, a component parameter.
ParameterConduit
A facade around `Binding` and `InternalComponentResources` that is used to instrument fields with the `Parameter` annotation.
ParameterDescription
ParameterModel
Model for a formal parameter of a component.
ParameterModelImpl
ParametersServletRequestWrapper
Wrapper for HttpServletRequest that overrides the parameter methods of the wrapped request.
ParameterToken
A parameter block to be passed to a component as a parameter.
ParameterValue
Holds single or multivalued values.
ParameterWorker
Responsible for identifying parameters via the `Parameter` annotation on component fields.
PartialMarkupDocumentLinker
PartialMarkupRenderer
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.
PartialMarkupRendererFilter
A filter (the main interface being `PartialMarkupRenderer`) applied when performing a partial page render as part of an Ajax-oriented request.
PartialMarkupRendererTerminator
Terminator for the `PartialMarkupRenderer` pipeline, which ultimately invokes `PageRenderQueue.renderPartial(org.apache.tapestry5.MarkupWriter, org.apache.tapestry5.json.JSONObject)` .
PartialTemplateRenderer
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.
PartialTemplateRendererImpl
PasswordField
A version of `TextField`, but rendered out as an <input type="password"> element.
Path
Used in conjunction with the `Inject` annotation to inject an `Asset` based on a path.
PathConstructor
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).
PathConstructorImpl
PeriodicExecutor
A service that executes a job at intervals specified by a `Schedule`.
PeriodicExecutorImpl
PeriodicJob
Persist
Identifies a field as persistent, meaning its value persists from one request to the next.
PersistedEntity
Encapsulates a Hibernate entity name with an entity id.
PersistedEntity
Encapsulates a JPA entity name with an entity id.
PersistedTransientEntity
PersistenceConstants
Constants for persistent field strategies.
PersistenceContentHandler
PersistenceContextSpecificEntityTransactionManager
PersistenceContextWorker
PersistenceParser
PersistenceUnitConfigurer
Used to configure a PersistenceUnitInfo, which is used to create an EntityManagerFactory.
PersistenceUnitInfoImpl
PersistentFieldBundle
Encapsulates persisted property information for an entire page.
PersistentFieldBundleImpl
PersistentFieldChange
Represents a previously stored change to a persistent field, within the context of a particular page of the application.
PersistentFieldChangeImpl
PersistentFieldManager
Handle persistent property changes.
PersistentFieldManagerImpl
PersistentFieldStrategy
Defines how changes to fields (within components, within pages) may have their values persisted between requests.
PersistentLocale
Manages the persistent locale stored in the browser (inside the URL).
PersistentLocaleImpl
PersistWorker
Converts fields with the `Persist` annotation into persistent fields.
PerthreadManager
Manages per-thread data, and provides a way for listeners to know when such data should be cleaned up.
PerthreadManagerImpl
PerThreadOperationTracker
Manages a per-thread OperationTracker using a ThreadLocal.
PerThreadServiceLifecycle
Allows a service to exist "per thread" (in each thread).
PerThreadValue<T>
Provides access to per-thread (and, by extension, per-request) data, managed by the `PerthreadManager`.
PipelineBuilder
Creates a pipeline from a service interface and an ordered list of filters.
PipelineBuilderImpl
PlasticClass
The representation of a class while it is being instrumented and transformed.
PlasticClassEvent
Describes a transformed class about to be loaded.
PlasticClassHandleShim
The interface for a "shim" class that provides the necessary hooks needed by `FieldHandle` and `MethodHandle` implementations for a particular, instantiated `PlasticClass`.
PlasticClassImpl
PlasticClassListener
Allows a listener to be notified about classes about to be loaded by the manager's class loader.
PlasticClassListenerHub
Methods for adding and removing `PlasticClassListener`s .
PlasticClassListenerLogger
PlasticClassLoader
PlasticClassPool
Responsible for managing a class loader that allows ASM `ClassNode`s to be instantiated as runtime classes.
PlasticClassTransformation<T>
A wrapper around a `PlasticClass` that allows the class to be converted into a concrete class, once all transformations are complete.
PlasticClassTransformer
Interface for defining how a `PlasticClass` is transformed.
PlasticConstants
PlasticField
Represents a field of a class being transformed.
PlasticInternalUtils
PlasticManager
Manages the internal class loaders and other logics necessary to load and transform existing classes, or to create new classes dynamically at runtime.
PlasticManager.PlasticManagerBuilder
A builder object for configuring the PlasticManager before instantiating it.
PlasticManagerDelegate
Delegate to the `PlasticManager` that performs the actual transformations of the class.
PlasticMethod
A method of a transformed class.
PlasticProxyFactory
A service used to create proxies of varying types.
PlasticProxyFactoryImpl
PlasticUtils
Utilities for user code making use of Plastic.
PlasticUtils.FieldInfo
Class used to represent a field name and its type for PlasticUtils.implementFieldValueProvider(PlasticClass, Set).
PostInjection
Annotation for methods that should be invoked after injection.
Predicate<T>
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.
PrefixCheckStackTraceElementAnalyzer
Checks to see if a class has a given prefix to its class name.
PreloaderMode
Identifies when the `PagePreloader` should perform its loading.
PreventServiceDecoration
Marks a service as not eligible for decoration.
Primary
Marker annotation used to denote a service that is the primary instance of some common interface.
PrimitiveFieldConstraintGenerator
Adds a "required" constraint for any property of whose type is a primitive (not a wrapper or reference) type.
PrimitiveType
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`.
PrintOutCollector
Utility for collecting the output of a `PrintWriter`.
ProductionModeUnknownComponentFilter
A filter, used only in production mode, that does a "pre-flight check" that the indicated component actually exists.
ProgressiveDisplay
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.
PropBinding
Base class for bindings created by the `PropBindingFactory`.
PropBindingFactory
Binding factory for reading and updating JavaBean properties.
PropertiesFileParser
Used when constructing a component's `Messages` object.
PropertiesFileParserImpl
Property
Annotation for fields for which accessor methods (getters and setters) should be created.
PropertyAccess
A wrapper around the JavaBean Introspector that allows more manageable access to JavaBean properties of objects.
PropertyAccessImpl
PropertyAccessType
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).
PropertyAdapter
Provides access to a single property within a class.
PropertyAdapterImpl
PropertyConduit
Used to read or update the value associated with a property.
PropertyConduit2
Extension to `PropertyConduit` that adds a method to access the generic property type.
PropertyConduitDelegate
Companion class for `PropertyConduit` instances created by the `PropertyConduitSource`.
PropertyConduitSource
A source for `PropertyConduit`s, which can be thought of as a compiled property path expression.
PropertyConduitSourceImpl
PropertyDisplay
Outputs a single property value.
PropertyDisplayBlocks
Contains blocks for displaying basic property types; the blocks are contributed to the `BeanBlockSource` service.
PropertyEditBlocks
A page that exists to contain blocks used to edit different types of properties.
PropertyEditContext
Defines a context for editing a property of a bean via `BeanEditor`.
PropertyEditor
Used to edit a single property of a bean.
PropertyExpressionException
Exception thrown when there is a problem parsing a property expression using the ANTLR property expression grammar.
PropertyExpressionLexer
PropertyExpressionParser
PropertyExpressionParser.constant_return
PropertyExpressionParser.expression_return
PropertyExpressionParser.expressionList_return
PropertyExpressionParser.keyword_return
PropertyExpressionParser.list_return
PropertyExpressionParser.map_return
PropertyExpressionParser.mapEntry_return
PropertyExpressionParser.mapEntryList_return
PropertyExpressionParser.mapKey_return
PropertyExpressionParser.methodInvocation_return
PropertyExpressionParser.notOp_return
PropertyExpressionParser.propertyChain_return
PropertyExpressionParser.rangeOp_return
PropertyExpressionParser.rangeopArg_return
PropertyExpressionParser.start_return
PropertyExpressionParser.term_return
PropertyModel
Part of a `BeanModel` that defines the attributes of a single property of a bean.
PropertyModelImpl
PropertyOutputContext
Provides context information needed when displaying a value.
PropertyOverrides
Provides access to blocks and messages used when overriding property labels, and property display or edit blocks.
PropertyOverridesImpl
PropertyShadowBuilder
Creates a "shadow" of a property of an object.
PropertyShadowBuilderImpl
PropertyValueLabelProvider
Provides a label from a property of the passed object.
PropertyValueProvider
Interface that can be implemented to provide access to field values based on their name.
PropertyValueProviderWorker
Worker used to gather PlasticUtils.FieldInfo instances and implement PropertyValueProvider for any class that has them.
PropertyWorker
Provides the getter and setter methods.
ProxiesStackTraceElementAnalyzer
Identifies frames for various proxy classes (class name starts with a '$' and there's no line number.
PublishEvent
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.
PublishServerSideEvents
Tapestry internal mixin used to implement the `PublishEvent` event logic.
QueryParameterConstants
Defines constants for common query parameters passed in requests from the client.
QuietOperationTracker
Minimal implementation used for testing, that does no logging, tracking, or exception catching.
Radio
A radio button (i.e., <input type="radio">).
RadioContainer
A container of `Radio` components, used to identify the element name used when rendering the individual radio buttons.
RadioGroup
A wrapper component around some number of `Radio` components, used to organize the selection and define the property to be edited.
RandomDataSource
Provides access to random data that can be used when populating a test database with "reasonable" data.
Raw
A specialized node in the document tree that contains raw markup to be printed to the client exactly as-is.
ReadOnlyComponentFieldConduit
An implementation of `FieldConduit` for a read-only component field.
RecomputableSupport
A utility class for managing a cacheable result that can be recomputed when needed.
Recursive
`Loop`-like component that renders its templates recursively based on `Recursive` parent-child relationships.
RecursiveBody
Component that marks the place in the template the recursion should happen.
RecursiveContext
Class that makes the link between `Recursive` and `RecursiveBody`.
RecursiveContext.Provider
RecursiveServiceCreationCheckWrapper
Decorator for `ObjectCreator` that ensures the service is only created once.
RecursiveValue<T>
Interface that represents a parent-children relationship.
RecursiveValueProvider
Interface implemented by classes which converts objects to `RecursiveValue` instances.
Reducer<A,T>
A reducer takes an accumulator value and a single value from a collection and computes a new accumulator value.
ReferenceType
Defines the types of reference the page cache can use.
Regexp
Enforces that the input matches a provided regular expression.
RegexpStackTraceElementAnalyzer
Uses a regular expression to identify which CSS class to apply to a frame.
Registry
Used by the `TapestryIOCJUnit4ClassRunner` to configure a test `Registry`
Registry
Public access to the IoC service registry.
RegistryBuilder
Used to construct the IoC `Registry`.
RegistryImpl
RegistryShutdownHub
Event hub for notifications when the IOC `Registry` shuts down.
RegistryShutdownHubImpl
RegistryShutdownListener
Deprecated.
In Tapestry 5.3, to be removed in a later release.
RegistryShutdownType
Used in conjunction with the `TapestryIOCJUnit4ClassRunner` to determine the registry lifecycle
RegistryStartup
Startup service for Tapestry IoC: automatically invoked at registry startup to execute a series of operations, via its ordered configuration of Runnable objects.
RegistryWrapper
A wrapper around `InternalRegistry` that exists to expand symbols in a service id before invoking `ObjectLocator.getService(String, Class)`.
RelativeElementPosition
Used by `HiddenFieldLocationRules` to identify where a hidden field may be placed relative to a particular element.
RelativePosition
Controls the position of newly added PropertyModel inside a BeanModel.
ReloadableObjectCreator
Reloadable object creator for non-service objects.
ReloadableObjectCreatorSource
Responsible for creating a `ReloadableServiceImplementationObjectCreator` for a service implementation.
ReloadableServiceImplementationObjectCreator
Returns an `ObjectCreator` for lazily instantiating a given implementation class (with dependencies).
ReloadAware
Optional interface that may be implemented by a service implementation (or even a proxy to give the service implementation more control over its lifecyle.
ReloadHelper
Forces a reload of all caches and invalidates the component class cache.
ReloadHelperImpl
RemoveRowLink
Used inside a `AjaxFormLoop` to remove the current row from the loop.
Renderable
Base interface for objects that can render markup output using a `MarkupWriter`.
RenderableAsBlock
Allows any `Renderable` object to act as a `Block`.
RenderClientId
Forces a client element to render its client id by ensuring that `ClientElement#getClientId()` is called.
RenderCommand
A command used during rendering of a page.
RenderCommandComponentEventResultProcessor
Processor for objects that implement `RenderCommand` (such as `BlockImpl`), used with an Ajax component event.
RenderCommandWorker
Ensures that all components implement `RenderCommand` by delegating to `RenderCommand.render(org.apache.tapestry5.MarkupWriter, org.apache.tapestry5.runtime.RenderQueue)`.
RenderDisabled
Renders an "disabled" attribute if the containing component `is disabled`.
RenderInformals
Used to render out all informal parameters, at the end of the `BeginRender` phase.
RenderNotification
This mixin triggers component event notifications when the attached component enters its `BeginRender` and `AfterRender` render phases.
RenderObject
Renders out an object using the @`Primary` `ObjectRenderer` service.
RenderPhaseEvent
RenderPhaseMethodWorker
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.
RenderQueue
A stateful object that manages the process of rendering a page.
RenderQueueException
Exception used when rendering, to capture the stack of active components (for propery reporting in the exception page).
RenderQueueImpl
RenderVariableBinding
RenderVariableBindingFactory
ReorderProperties
An annotation that may be placed on a JavaBean to re-order the properties.
Request
Generic version of `HttpServletRequest`, used to encapsulate the Servlet API version, and to help bridge the differences between Servlet API and Porlet API.
RequestBody
Annotation that may be placed on parameters of event handler methods, usually in page classes.
RequestConstants
Constants used when processing requests from the client web browser.
RequestEncodingInitializer
Determines the reuest encoding for the given page and applies that to the request, so that parameters may be properly decoded.
RequestErrorFilter
Filter for the `RequestHandler` pipeline used to intercept and report exceptions.
RequestExceptionHandler
Service invoked when an uncaught exception occurs.
RequestFilter
Filter interface for `RequestHandler`.
RequestGlobals
Service used to store the current request objects, both the Servlet API versions, and the Tapestry generic versions.
RequestGlobalsImpl
Dumb data holder for per-request data.
RequestHandler
Service interface for the RequestHandler pipeline service.
RequestImpl
Basic implementation of `Request` that wraps around an `HttpServletRequest`.
RequestOperationTracker
Uses `OperationTracker` to add an operation generally describing each request.
RequestPageCache
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).
RequestPageCacheImpl
In Tapestry 5.1, the implementation of this worked with the page pool (a pool of page instances, reserved to individual requests/threads).
RequestParameter
Annotation that may be placed on parameters of event handler methods.
RequestRenderer
RequestSecurityManager
Used to manage the relationship between the security of a request and the security of a page.
RequestSecurityManagerImpl
Required
A validator that enforces that the value is not null and not the empty string.
Resource
Represents a resource on the server that may be used for server side processing, or may be exposed to the client side.
ResourceChangeTracker
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.
ResourceChangeTrackerImpl
ResourceDependencies
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).
ResourceDigestGenerator
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
ResourceDigestGeneratorImpl
Gutted implementation; will be removed in Tapestry 5.5.
ResourceDigestManager
Deprecated.
Deprecated in 5.4 with no replacement; see release notes about classpath assets moving to /META-INF/assets/.
ResourceDigestManagerImpl
ResourceMinimizer
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.
ResourceStreamer
Responsible for streaming the contents of a resource to the client.
ResourceStreamer.Options
Used to customize the behavior of `ResourceStreamer.streamResource(org.apache.tapestry5.commons.Resource, java.lang.String, java.util.Set)`.
ResourceStreamerImpl
ResourceSymbolProvider
Makes a `Resource` available as a `SymbolProvider`
ResourceTransformer
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.
Response
API agnostic wrapper for generating a response.
ResponseCompressionAnalyzer
Used to determine if the client supports GZip compression of the response.
ResponseCompressionAnalyzerImpl
ResponseCustomizer
Used to customize the response prior to streaming content to the client; typically this is used to set special headers.
ResponseImpl
Implementation of `Response` that wraps around an underlying `HttpServletResponse`.
ResponseRenderer
Public facade around internal services related to rendering a markup response.
ResponseRendererImpl
ResponseWrapper
Implementation of `Response` that delegates all method invocations to a delegate instance.
RestEndpointNotFoundException
Exception used when a request is made to a page with REST endpoint event handlers but doesn't match any of them.
RestInfo
Annotation that provides some information about REST event handler methods for OpenAPI description generation.
RestJacksonModule
Defines services and and contributions for the Tapestry integration with Jackson Databind.
RestoreDirtySessionObjects
A listener that invokes `Session.restoreDirtyObjects()`.
RestSupport
Service which provides REST-related utilities.
RestSupportImpl
Default RestSupport implementation.
Retain
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)
RetainWorker
Identifies fields with the `Retain` annotation, and "claims" them so that no special work will occur on them.
RootPathDispatcher
Recognizes a request for the application root (i.e., "/") and handles this the same as a render request for the "Start" page.
SaxTemplateParser
SAX-based template parser logic, taking a `Resource` to a Tapestry template file and returning a `ComponentTemplate`.
Schedule
Used with `PeriodicExecutor` to control the schedule for when jobs execute.
Scope
An optional annotation that may be placed on a service building method of a module, or on the implementation class (when using service binding).
ScopeConstants
Defines constants for built-in scopes (used with the `Scope` annotation.
Secure
A marker annotation that indicates that the page in question may only be accessed via HTTPS.
SecureOption
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
Select an item from a list of values, using an [X]HTML <select> element on the client side.
SelectModel
Defines the possible options and option groups for a <select> [X]HTML element.
SelectModelFactory
Used to create an `SelectModel`.
SelectModelFactoryImpl
SelectModelImpl
SelectModelRenderer
SelectModelVisitor
Callback interface that allows for visiting the option groups and option models of a select model in correct order order.
SeleniumTestCase
Base class for creating Selenium-based integration test cases.
Service
Used in conjunction with the `Inject` annotation to identify a service by name and not by type.
ServiceActivity
Provided by the `ServiceActivityScoreboard` to track a single service's state and activity.
ServiceActivityScoreboard
Provides access to the runtime details about services in the `Registry`.
ServiceActivityTracker
Used to update the status of services defined by the `ServiceActivityScoreboard`.
ServiceActivityTrackerImpl
ServiceActivityTrackerImpl.MutableServiceActivity
ServiceAdvisor
Provided by a `AdvisorDef` to perform the advice (by invoking methods on a `MethodAdviceReceiver`).
ServiceAdvisorImpl
ServiceAnnotationObjectProvider
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.
ServiceBinder
Allows a module to bind service interfaces to service implementation classes in support of autobuilding services.
ServiceBinderImpl
ServiceBindingOptions
Allows additional options for a service to be specified, overriding hard coded defaults or defaults from annotations on the service.
ServiceBuilder<T>
A callback used to create a service implementation.
ServiceBuilderMethodInvoker
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.
ServiceBuilderResources
Extends `ServiceResources` with additional methods needed only by the service builder method, related to accessing a service's configuration.
ServiceConfigurationListener
Interface that defines listeners to services getting their distributed configuration.
ServiceConfigurationListenerHub
Service that collects the `ServiceConfigurationListener`s.
ServiceDecorator
A service decorator is derived from a `DecoratorDef` and is responsible for building an interceptor around an existing implementation (called the "delegate").
ServiceDecoratorImpl
A wrapper around a decorator method.
ServiceDef
Service definition derived, by default, from a service builder method.
ServiceDef2
Extension to `ServiceDef` containing new methods added for Tapestry 5.1.
ServiceDef3
Introduced for Tapestry 5.3, contains new methods to provide access to annotations on the class, and on methods of the class.
ServiceDefAccumulator
Simple interface used when invoking a bind() method on a module class.
ServiceDefImpl
ServiceId
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`).
ServiceInjectionProvider
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.
ServiceLifecycle
Allows certain types of lifecycles to control exactly how services are instantiated.
ServiceLifecycle2
Extension to `ServiceLifecycle` that adds an additional method.
ServiceLifecycleSource
Provides access to user defined lifecycles (beyond the two built-in lifecycles: "singleton" and "primitive").
ServiceMessages
ServiceOverride
Used to override built in services.
ServiceOverrideImpl
ServiceProxyProvider
Used in concert with `SerializationSupport` to convert service tokens back into service proxies.
ServiceProxyToken
Token that replaces a service proxy when the proxy is serialized.
ServiceResources
Contains resources that may be provided to a service when it initializes, which includes other services defined in the registry.
ServiceResourcesImpl
Implementation of `ServiceBuilderResources`.
ServiceStatus
Page used to see the status of all services defined by the `Registry`.
ServletApplicationInitializer
Service interface for initializing a servlet application, as a pipeline.
ServletApplicationInitializerFilter
Filter interface for `ServletApplicationInitializer`.
ServletContainerRunner
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.
ServletContextSymbolProvider
A wrapper around `ServletContext` that makes init-parameters accessible as symbols.
Session
Generic version of `HttpSession`, used to bridge the gaps between the Servlet API and the Portlet API.
Session.LockMode
The type of lock used to access atttributes in the `Session`.
SessionApplicationStatePersistenceStrategy
Stores ASOs in the `Session`, which will be created as necessary.
SessionAttribute
Used to map a property of a page or component to value stored in session.
SessionAttributeWorker
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)`.
SessionImpl
A thin wrapper around `HttpSession`.
SessionLock
A wrapper around `ReentrantReadWriteLock` used to manage the lock for a session.
SessionPersistedObjectAnalyzer<T>
Analyzes a session-persisted object, specifically to see if it is dirty or not.
SessionPersistentFieldStrategy
A strategy for storing persistent page properties into the `session`.
SessionRestorable
Interface for serializable objects stored in the HTTP Session that can be restored to active state via the Hibernate Session.
SessionState
Marker annotation for a property that is a session state object (SSO) as controlled by the `ApplicationStateManager`.
SetupRender
Marker annotation for methods that should be executed during the SetupRender phase.
Severity
The severity of an `Alert`, used primarily to control how it is decorated when presented to the user on the client side.
SingleKeySymbolProvider
Implementation of `SymbolProvider` that only supports a single key/value pair.
SingletonServiceLifecycle
The basic implementation of a service lifecycle, which simply uses the `ObjectCreator` to create an instance of the service when asked.
SingleZonePartialRendererFilter
Responsible for capturing the content for a single zone and storing it into the JSON reply object.
Sortable
Used to explicitly define whether a property should be considerable sortable or not.
SortConstraint
Identifies how a single column (identified as a `PropertyModel`) is sorted.
SpockTapestry
Marker annotation for services that are specific to the Spock/Tapestry integration module.
SpringBeanServiceDef
SpringConstants
Constants used with the Spring integration library.
SpringModule
Module for Tapestry/Spring Integration.
SpringModuleDef
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.
SRSCachingInterceptor
An interceptor for the `StreamableResourceSource` service that handles caching of content.
SRSCompressedCachingInterceptor
Specialization of `SRSCachingInterceptor` that only attempts to cache compressed resources.
SRSCompressingInterceptor
SRSMinimizingInterceptor
Loops the result through the `ResourceMinimizer` service.
Stack<E>
A simple, streamlined implementation of `Stack`.
StackAssetRequestHandler
StackExtension
A contribution to an extensible `JavaScriptStack`.
StackExtensionType
Defines the types of extensions to a JavaScript stack that can be contributed to an extensible JavaScript stack.
StackTraceElementAnalyzer
Used by `ExceptionDisplay` to characterize each stack frame that is presented.
StackTraceElementClassConstants
CSS classes, from the default CSS stylesheet, used with `StackTraceElementAnalyzer`.
StandardDelegate
StartComponentToken
The start element of a component within the template.
StartElementToken
The start of an ordinary element within the template (as opposed to `StartComponentToken`, which represents an active Tapestry token.
Startup
An annotation that may be placed on a startup method of a module.
StartupDef
Represents a public module method (static or instance) with a `Startup` annotation.
StartupDefImpl
StaticActivationContextValue
Annotation that may be placed on parameters of event handler methods to define them as having a static value.
StaticContext
Stores static context information needed by a transformed PlasticClass; this includes data such as injections.
StaticFilesFilter
Identifies requests that are for actual resource files in the context.
StaticObjectCreator
An `ObjectCreator` for a statically identified object (typically, a bean from the Spring application context).
StaticObjectProvider<S>
Provides a single object of a given type.
Status
Used in `ServiceActivity` to identify the state of the service in terms of its overall lifecycle.
StrategyBuilder
A service implementation builder that operates around a `StrategyRegistry`, implementing a version of the Gang of Four Strategy pattern.
StrategyBuilderImpl
StrategyRegistry<A>
A key component in implementing the "Gang of Four" Strategy pattern.
StreamableResource
An object, derived from a `Resource`, that can be streamed (ultimately, to a client web browser).
StreamableResourceImpl
StreamableResourceProcessing
Defines additional features desired when accessing the content of a `Resource` as a `StreamableResource`.
StreamableResourceSource
Converts `Resource`s into `StreamableResource`s, and may be responsible for transforming resources based on file extension.
StreamableResourceSourceImpl
StreamPageContent
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.
StreamPageContentResultProcessor
Used to trigger the rendering of a particular page without causing a redirect to that page.
StreamResponse
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.
StreamResponseResultProcessor
StringInterner
Creates "interned" strings that are unique for the same content.
StringInternerImpl
StringLocation
Implementation of `Location` used when the underlying resource isn't really known.
StringProvider
Interface used when assembling an attribute value that contains expansions.
StringRenderable
Renders a string using `MarkupWriter.write(String)`.
StringToEnumCoercion<T extends Enum>
A `Coercion` for converting strings into an instance of a particular enumerated type.
StringToJSONArray
StringToJSONObject
StringTranslator
StringValueEncoder
Passes the string value from the server to the client and vice-versa without any translation.
StylesheetLink
Captures the information needed to create a stylesheet link in the final `Document`, or as part of a JSON partial page render response.
StylesheetOptions
Provides options to describe options associated with importing a stylesheet onto a page.
Submit
Corresponds to <input type="submit"> or <input type="image">, a client-side element that can force the enclosing form to submit.
SubmitMode
Defines the client and server-side behavior of a `Submit` or `LinkSubmit` component.
SubmitNotifier
A non visual component used to provide notifications to its container during a form submission.
SubModule
Deprecated.
Deprecated in 5.4, use `ImportModule` instead.
SuccessMethodInvocationResult
A successful method invocation; one that did not throw a checked exception.
SupportsInformalParameters
Used to identify a component that can support informal parameters.
SupportsInformalParametersWorker
Checks for the `SupportsInformalParameters` annotation, settting the corresponding flag on the model if present.
SwitchBlock
Support for building the equivalent of a Java switch statement.
SwitchBlockImpl
SwitchCallback
A callback used by a `SwitchBlock` to manage the generation of code.
Symbol
Used to inject a symbol value, via a symbol name.
SymbolBeanFactoryPostProcessor
SymbolBindingFactory
SymbolConstants
Defines the names of symbols used to configure Tapestry.
SymbolObjectProvider
Performs an injection based on a `Symbol` annotation.
SymbolProvider
A provider of values for symbols, used by the `SymbolSource` service.
SymbolSource
Used to manage symbols, configuration properties whose value is evaluated at runtime.
SymbolSourceImpl
SyntheticModuleDef
A synthetic module definition, used to mix in some additional "pre-built" service configuration contributions.
SyntheticStackTraceElementAnalyzer
Identifies any code associated with line 1 as omitted (i.e., it's a synthetic method related to an inner class).
SyntheticSymbolSourceContributionDef
Makes a contribution to the SymbolSource service configuration.
SystemEnvSymbolProvider
Provides case insensitive access to environment variables.
SystemPropertiesSymbolProvider
Obtains symbol values from JVM System properties.
T5Dashboard
TapestryAOPStackFrameAnalyzer
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.
TapestryAppInitializer
This class is used to build the `Registry`.
TapestryApplicationContext
Extension of Spring's `XmlWebApplicationContext` that includes hooks to resolve some injections into Spring beans as Tapestry services.
TapestryBeanFactory
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.
TapestryCDIBeanManagerForJPAEntityListeners
TapestryConstants
Constants needed by end-user classes.
TapestryDocTaglet
An inline tag allowed inside a type; it produces Tapestry component reference and other information.
TapestryException
Exception class used as a replacement for `RuntimeException` when the exception is related to a particular location.
TapestryFilter
The TapestryFilter is responsible for intercepting all requests into the web application.
TapestryFilter
The TapestryFilter is responsible for intercepting all requests into the web application.
TapestryHttpConstants
Class defining constants for Tapestry HTTP.
TapestryHttpInternalConstants
TapestryHttpInternalSymbols
TapestryHttpModule
The Tapestry module for HTTP handling classes.
TapestryHttpSymbolConstants
Class defining constants for Tapestry HTTP symbols.
TapestryInterceptor
Controls creation, startup and shutdown of the Tapestry container, and injects specifications with Tapestry-provided objects.
TapestryInternalUtils
Shared utility methods used by various implementation classes.
TapestryIoCInternalCacheInvocationContext<A extends Annotation>
Tapestry-IoC specific cache invocation context using `MethodInvocation`
TapestryIoCInternalCacheKeyInvocationContext<A extends Annotation>
Tapestry-IoC specific cache key invocation context using `MethodInvocation`
TapestryIOCJUnit4ClassRunner
A JUnit4ClassRunner to help with Tapestry IOC integration tests.
TapestryIOCJUnit4ClassRunner.RegistryManagerRunNotifier
TapestryIOCModule
Defines the base set of services for the Tapestry IOC container.
TapestryMarkers
A set of markers used internally by Tapestry when logging in code related to paqes and components.
TapestryModule
The root module for Tapestry.
TapestryOpenApiViewerModule
Defines services and definitions for the Tapestry OpenAPI viewer.
TapestryPersistenceUnitInfo
Tapestry's mutable extension of `PersistenceUnitInfo` interface used for XML-less configuration of persistence units.
TapestryRunnerConstants
TapestrySessionFactory
Encapsulates logic for accessing the Tapestry `Session` (a wrapper around the `HttpSession`).
TapestrySessionFactoryImpl
TapestrySpockExtension
Facilitates Spock-based integration testing of Tapestry modules.
TapestrySpringFilter
Add logic to setup for Spring integration at startup.
TapestryTestCase
Base test case that adds a number of convenience factory and training methods for the public interfaces of Tapestry.
TapestryTestConfiguration
To be used on Selenium-based integration tests that extend `SeleniumTestCase` as an alternative to using a TestNG XML configuration file.
TapestryTestConstants
Defins `ITestContext` attributes meaninful to Tapestry for controlling application startup and shutdown.
TapestryVersion
Represents a Tapestry version that needs a migration due to names that moved from one package to another.
TeeOutputStream
An output stream that acts like a "tee", copying all provided bytes to two output streams.
TemplateParser
Parses a resource into a `ComponentTemplate`.
TemplateParserImpl
Parses Tapestry XML template files into `ComponentTemplate` instances.
TemplateToken
Base class for tokens parsed out of a template.
TemplateTrackingInfo
Class that holds information about a template for tracking.
TestableCookieSinkSource
TestableRequest
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.
TestableRequestImpl
TestableResponse
TestableResponseImpl
TestBase
Deprecated.
In 5.4, with no replacement
TestRegistryManager
Helper class used by the `TapestryIOCJUnit4ClassRunner` to manage the test registry
TestUtils
Deprecated.
In 5.4, with no replacement
Text
A type of node that contains text.
TextArea
TextArea component corresponds to a <textarea> element.
TextField
TextField component corresponds to `<input>` element.
TextOutput
Outputs paragraph oriented text, typically collected via a `TextArea` component.
TextStreamResponse
TextToken
ThreadCleanupListener
Deprecated.
Deprecated in 5.4, use `PerthreadManager.addThreadCleanupCallback(Runnable)` instead.
ThreadLocale
Stores the locale for the current thread.
ThreadLocaleImpl
ThrowawayClassLoader
ThunkCreator
A thunk is a delayed calculation.
ThunkCreatorImpl
TimeInterval
Used to represent a period of time, specifically as a configuration value.
TimeInterval
Used to present an interval value using Moment.js's from() or fromNow() functions.
TokenType
Defines the different types of `TemplateToken`s.
Tomcat6Runner
Deprecated.
Please use `TomcatRunner` instead
TomcatRunner
Launches an instance of Tomcat.
TrackableComponentEventCallback<T>
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.
Traditional
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.
Trait
Defines different traits that may be enabled or disabled.
TransformationOption
Options used when transforming classes.
TransformationSupport
Additional utilities, beyond `PlasticClass`, needed when transforming.
TransformConstants
Constants used by implementations `ComponentClassTransformWorker2`.
TransformUtils
Support code for generating code (used when transforming component classes).
Translate
Used to attach the name of a Translator used to convert the associated property between server-side and client-side representations.
TranslateBindingFactory
Interprets the binding expression as the name of a `Translator` provided by the `TranslatorSource`.
Translator<T>
Translates between client-side and server-side values.
TranslatorAlternatesSource
This service is used by `TranslatorSource` to specify `Translator` alternates: translators that are used when specified explicitly by name.
TranslatorAlternatesSourceImpl
TranslatorSource
A source for `Translator`s, either by name or by property type.
TranslatorSourceImpl
Tree
A component used to render a recursive tree structure, with expandable/collapsable/selectable nodes.
TreeExpansionModel<T>
Tracks which nodes of a `TreeModel` are currently expanded.
TreeModel<T>
A model for tree-oriented data used by the `Tree` component.
TreeModelAdapter<T>
Used with `DefaultTreeModel` to define how to extract labels and child nodes from a value.
TreeNode<T>
A node within a `TreeModel`.
TreeSelectionModel<T>
Tracks which leaf nodes of a `TreeModel` are currently selected.
Trigger
Triggers an arbitrary event during rendering.
TriggerFragment
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.
TryCatchBlock
Allows a portion of a method to be marked so that exception and finally handlers can be provided.
TryCatchBlockImpl
TryCatchCallback
A callback used with `InstructionBuilder.startTryCatch(TryCatchCallback)`.
Tuple<A,B>
A Tuple holds two values of two different types.
TypeCategory
Defines the two basic kinds of non-primitive, non-array Java types: interfaces and classes.
TypeCoercedValueEncoderFactory
Provides `ValueEncoder` instances that are backed by the `TypeCoercer` service.
TypeCoercer
Makes use of `Coercion`s to convert between an input value (of some specific type) and a desired output type.
TypeCoercerHttpRequestBodyConverter
TypeCoercerImpl
TypeCoercerProxy
A simplified version of `TypeCoercer` used to defer the instantiation of the actual TypeCoercer service until necessary.
TypeCoercerProxyImpl
A proxy for the `TypeCoercer`
Unchecked
A validator that enforces that the value is false.
UnclaimedFieldWorker
Designed to be just about the last worker in the pipeline.
UnknownActivationContextCheck
A marker annotation that indicates that the page in question may only be accessed with a exact activation context.
UnknownActivationContextExtractor
UnknownActivationContextHandler
Responsible for handling the response for a page called with an unknown activation context when the check itself is enabled.
UnknownActivationContextHandlerImpl
Default implementation for `UnknownActivationContextHandler` which answer with a 404 NOT FOUND error.
UnknownValueException
Special exception used when a value (typically from a map) is referenced that does not exist.
Unless
A close relative of the `If` component that inverts the meaning of its test.
UpdateListener
Interface for objects which can periodically check for updates.
UpdateListenerHub
Manages a set of `UpdateListener`s.
UpdateListenerHubImpl
Upload
A component to upload a file.
UploadedFile
Represents an uploaded file.
UploadedFileItem
Implentation of `UploadedFile` for FileItems.
UploadEvents
Names of events that may be triggered on components due to file uploads.
UploadExceptionFilter
Determines if there was an `FileUploadException` processing the request and, if so, triggers an exception event on the page.
UploadModule
UploadSymbols
Configuration symbols.
UrlAsset
URLChangeTracker<T>
Given a (growing) set of URLs, can periodically check to see if any of the underlying resources has changed.
URLEncoder
Service used to encode or decode strings that are placed into URLs.
URLEncoderImpl
URLEventContext
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.
UrlResource
UsesConfiguration
A documentation-only interface placed on service interfaces for services which have an unordered configuration, to identify the type of contribution.
UsesMappedConfiguration
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.
UsesOrderedConfiguration
A documentation-only interface placed on service interfaces for services which have an ordered configuration, to identify the type of contribution.
UseWith
Annotation documenting the context(s) in which tapestry-provided annotations may be used.
UTF8ForTextAssets
Adds ;charset=utf-8 for text/* resources with no specific character set.
Validate
Used to attach validation constraints directly to a property (either the getter or the setter method).
ValidateAnnotationConstraintGenerator
Checks for the `Validate` annotation, and extracts its value to form the result.
ValidateBindingFactory
Factory for bindings that provide a `FieldValidator` based on a validator specification.
ValidatingConfigurationWrapper<T>
Wraps a `Collection` as a `Configuration` and perform validation that collected value are of the correct type.
ValidatingMappedConfigurationWrapper<K,V>
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.
ValidatingOrderedConfigurationWrapper<T>
Wraps a `List` as a `OrderedConfiguration`, implementing validation of values provided to an `OrderedConfiguration`.
ValidationConstraintGenerator
Invoked to generate a list of validation constraint strings for a property.
ValidationConstraintGeneratorImpl
ValidationDecorator
Deprecated.
Deprecated in 5.4 with no replacement.
ValidationDecoratorFactory
Deprecated.
Deprecated in 5.4 with no replacement, as `ValidationDecorator` is being phased out.
ValidationDecoratorFactoryImpl
ValidationDecoratorWrapper
Implementation of `ValidationDecorator` that delegates all method invocations.
ValidationException
An exception associated with parsing client input, or validating the input against a constraint.
ValidationTracker
Tracks information related to user input validations.
ValidationTrackerImpl
Standard implementation of `ValidationTracker`.
ValidationTrackerWrapper
Wrapper around a `ValidationTracker` that delegates all methods to the wrapped instance.
Validator<C,T>
Used by a `Field` to enforce a constraint related to a form submission.
ValidatorMacro
Allows support for "validator macros", a simple-minded way of combining several related valiations together under a single name.
ValidatorMacroImpl
ValidatorSpecification
Validator type and constraint values parsed from a validator specification.
Value
Used in conjunction with `Inject` to inject a literal value, rather than a service.
ValueEncoder<V>
A ValueEncoder is used to convert server side objects to unique client-side strings (typically IDs) and back.
ValueEncoderFactory<V>
A source for `ValueEncoder` instances of a given type.
ValueEncoderSource
A source for value encoders based on a property type.
ValueEncoderSourceImpl
ValueLabelProvider<V>
An object capable of providing a user-presentable label from a value.
ValueObjectProvider
Provides an object when the `Value` annotation is present.
VersionUtils
Utility methods related to managing framework version numbers.
VirtualResource
Base class for virtual resources: resources that are not simply mapped to stored files, but are assembled, as necessary, on the fly.
Visitor
A callback interface used navigate the `Element`s of a document.
WebResourcesSymbols
WhenCallback
Used with `InstructionBuilder.when(Condition, WhenCallback)`.
WhileCallback
Callback used with `InstructionBuilder.doWhile(Condition, WhileCallback)`.
WhitelistAccessOnly
Identifies a page that should only be accessed from clients on the whitelist.
WhitelistAnalyzer
Given a request, determine if the request is from a client on the whitelist.
Width
Defines the desired width of the field used to edit the property.
Worker<T>
An operational function used with a `Flow`.
WrongConfigurationTypeGuard
Used when invoking a contribute method to guard against a request for the wrong type of configuration interface.
XDocStreamer
Reads an XDOC file using SAX and streams its content (with some modifications) to an output stream.
XMLMarkupModel
Markup model used when generating any form of XML markup.
XMLTokenStream
Parses a document as a stream of XML tokens.
XMLTokenType
Identifies type of `XMLToken`.
ZeroNullFieldStrategy
Treats nulls to or from the client as if they were 0's.
ZippedFlow<A,B>
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()`).
Zone
A Zone is portion of the output page designed for easy dynamic updating via Ajax or other client-side effects.
ZoneRefresh
This mixin periodically refreshs a `zone` by triggering an event on the server using ajax requests.