All Classes and Interfaces
Class
Description
TODO lukaszlenart: write a JavaDoc
Provides default implementations of optional lifecycle methods
Matches patterns against pre-compiled wildcard expressions pulled from
target objects.
Abstract class with some helper methods, it should be used
when starting development of another implementation of
MultiPartRequestAbstract base class for all UI tags.
Describes properties supported by the AbstractUITag - base class for all UI tags
This bases on HtmlTagSupportBeanInfo class from StripesFramework - thanks!
FIXME: is it used?
Used across different interceptors to check if given string matches one of the accepted patterns.
All actions may implement this interface, which exposes the
execute() method.This result invokes an entire other action, complete with it's own interceptor stack and result.
Contains everything needed to configure and execute an action:
methodName - the method name to execute on the action.
The builder for this object.
Matches paths against pre-compiled wildcard expressions pulled from
action configs.
The ActionContext is the context in which an
Action is executed.Render action errors if they exists the specific layout of the rendering depends on
the theme itself.
ActionError Tag.
Provides hooks for handling key action events
Used by
ObjectFactory to build actions
Interceptor that is based off of
MultiPartRequestWrapper, which is automatically applied for any request that
includes a file when the support for multi-part request is enabled,
see Disabling file upload.An
ActionInvocation represents the execution state of an Action.Simple class that holds the action mapping information used to invoke a
Struts action.
Render action messages if they exists, specific rendering layout depends on the
theme itself.
ActionMessage Tag.
ActionProxy is an extra layer between XWork and the action so that different proxies are possible.
The
ActionProxyFactory is used to create ActionProxys to be executed.Provides a default implementation for the most common actions.
ActionValidatorManager is the main interface for validation managers (regular and annotation based).
Marks a action method that needs to be called after the main action method and the result was
executed.
The aim of this Interceptor is to alias a named parameter to a different named parameter.
Use this annotation to limit with what http method action or action's method can be called
AnnotationActionValidatorManager is the entry point into XWork's annotations-based validator framework.
AnnotationUtilsAnnotationValidationConfigurationBuilderExtends the xwork validation interceptor to also check for a @SkipValidation
annotation, and if found, don't validate this action method
A bean that takes several iterators and outputs them in sequence
Append a list of iterators.
Actions that want to be aware of the application Map object should implement this interface.
A simple implementation of the
Map interface to handle a collection of attributes and
init parameters in a ServletContext object.Adds support for invoke async actions.
A Map that holds 4 levels of scope.
Interface used to create a background process which will be executed by
ExecuteAndWaitInterceptorBase class for template engines.
A proxy interface to be used with Struts DI mechanism
When implemented allows to alias already existing beans
Marks a action method that needs to be executed before the main action method.
Marks a action method that needs to be executed before the result.
Renders an HTML input element of type checkbox, populated by the specified property from the ValueStack.
Creates a series of checkboxes from a list.
ClassFinder searches the classpath of the specified ClassLoaderInterface for
packages, classes, constructors, methods, or fields with specific annotations.
Allows create different ClassFinders which should help support different Java versions
Classes implementing this interface can find resources and load classes, usually delegating to a class
loader
Default implementation of ClassLoaderInterface, which delegates to an actual ClassLoader
This class is extremely useful for loading resources and classes in a fault tolerant manner
that works across different applications servers.
This class is an utility class that will search through the classpath
for files whose names match the given pattern.
ValueStacks implementing this interface provide a way to remove values from
their contexts.
ClosingUIBean is the standard superclass for UI components such as div etc.
Interceptor that implements Cross-Origin Embedder Policy on incoming requests used to protect a
document from loading any non-same-origin resources which don't explicitly grant the document
permission to be loaded.
Base class to extend for UI components.
Default implementation of UrlProvider
Various static methods used with components
A composite action mapper that is capable of delegating to a series of
ActionMapper if the former
failed to obtained a valid ActionMapping or uri.This is a composite
TextProvider that takes in an array or List of TextProviders, it will
consult each of them in order to get a composite result.A Stack that is implemented using a List.
A stack that is able to call methods on objects in the stack.
A marking interface, when implemented allows to conditionally execute a given interceptor
within the current action invocation.
The ConditionalVisitorFieldValidator will forward validation to the VisitorFieldValidator
only if the expression will evaluate to true.
XWork configuration.
ConfigurationException
ConfigurationManager - central for XWork Configuration management, including
its ConfigurationProvider.
Interface to be implemented by all forms of XWork configuration classes.
ConfigurationUtil
Injects dependencies into constructors, methods and fields annotated with
Inject.Builds a dependency injection
Container.Implemented by classes which participate in building a container.
Provides beans and constants/properties for the Container
ContainUtil will check if object 1 contains object 2.Matches content type of uploaded files, similar to
PatternMatcherContext of the current injection.
Base class for control and data tags
Value Stack's Context related Utilities.
A marker annotation for type conversions at Type level.
Used to process
TypeConversion
annotation to read defined ConvertersThis validator checks if there are any conversion errors for a field and applies them if they exist.
Field Validator that checks if a conversion error occurred for this field.
ConversionErrorInterceptor adds conversion errors from the ActionContext to the Action's field errors.
Used to process <clazz>-conversion.properties file to read defined Converters
Used to read converters from Properties file
ConversionRuleConversionTypeDedicated interface used by
ObjectFactory to build TypeConverterAction can create cookies which will be stored in response
Allows actions to send cookies to client, action must implement
CookieProvider
You must reference this interceptor in your default stack or in action's stack, see example below.Actions implementing the CookiesAware interface will receive
a Map of filtered cookies via the setCookiesMap method.
Interceptor that implements Cross-Origin Opener Policy on incoming requests.
A bean that can be used to keep track of a counter.
This validator checks that a field is a valid credit card.
CreditCardFieldValidator checks that a given String/Array/Collection field,
if not empty, is a valid credit card number.
Interceptor that implements Content Security Policy on incoming requests used to protect against
common XSS and data injection attacks.
An abstract Action that can be extended to process the incoming CSP violation reports.
CspSettings interface used by the
CspInterceptor to add the CSP header to the response.Implement this interface by an action to provide a custom
CspSettings,
see CspInterceptor for more detailsThis annotation can be used for custom validators.
Allows defines a wrapper around different formatting APIs, like old SimpleDateFormat
and new DateTimeFormatter introduced in Java 8 Date/Time API
DateModelThis validator checks that a date field has a value within a specified range.
Field Validator that checks if the date supplied is within a specific range.
Default implementation
The Default ActionInvocation implementation
The Default ActionProxy implementation
Default factory for
ActionProxyFactory.A simple action support class that sets properties to be able to serve
This is the entry point into XWork's rule-based validation framework.
DefaultConfiguration
Default implementation of
ConversionAnnotationProcessorDefault implementation of
ConversionFileProcessorThe default implementation of
CspReportAction that simply logs the JSON object
that contains the details of the CSP violation.Default implementation of
CspSettings.Default implementation of
DispatcherErrorHandler
which sends Error Report in devMode or HttpServletResponse.sendError(int, java.lang.String) otherwise.Default implementation of
FileManagerDefault implementation
Default implementation
Default implementation of
LocaleProviderThis
ObjectTypeDeterminer looks at the Class-conversion.properties for entries that indicated what
objects are contained within Maps and Collections.Default OGNL Cache factory implementation.
Default OGNL Cache factory implementation.
Default OGNL Expression Cache factory implementation.
Loads the default properties, separate from the usual struts.properties loading
DefaultSettings implements optional methods of Settings.
Default implementation to server static content
The default Struts tag library
DefaultTextProvider gets texts from only the default resource bundles associated with the default bundles.
Default type conversion.
Default implementation
Default implementation of UnknownHandlerManager
Default implementation of UrlHelper
Default implementation
Default validator factory
Parse the validation file.
A default implementation of the
ValidatorContext interface.Thrown when a dependency is misconfigured.
A utility class the actual dispatcher delegates most of its tasks to.
Provide an accessor class for static XWork utility.
Implementation of this interface is used to handle internal errors or missing resources.
A interface to tag those that want to execute code on the init and
destory of a Dispatcher.
Helper class to create and retrieve information from location-enabled
DOM-trees.
The
DOMBuilder is a utility class that will generate a W3C
DOM Document from SAX events.
DoubleListUIBean is the standard superclass of all Struts double list handling components.
This validator checks that a double field has a value within a specified range.
Field Validator that checks if the double specified is within a certain range.
Renders two HTML select elements with second one changing displayed values depending on selected entry of first one.
A marking interface that will tell CI to initialise the bean when instating the whole objects' graph
This validator checks that a field is a valid e-mail address if it contains a non-empty String.
EmailValidator checks that a given String field, if not empty, is a valid email address.
Helper class to build error messages.
A simple wrapper around an exception, providing an easy way to print out the stack trace of the exception as well as
a way to get a handle on the exception itself.
Configuration for exception mapping.
The builder for this object.
Used across different interceptors to check if given string matches one of the excluded patterns.
Contains execution operations for filters
Interface mimics
ExecutorService to be used with
ExecuteAndWaitInterceptor
to execute BackgroundProcessA proxy interface to be used with Struts DI mechanism
This non-field level validator validates a supplied regular expression.
A Non-Field Level validator that validates based on regular expression supplied.
A custom factory.
A speedy implementation of ByteArrayOutputStream.
Interceptor that implements Fetch Metadata policy on incoming requests used to protect against
CSRF, XSSI, and cross-origin information leaks.
Render field errors if they exists.
FieldError Tag.
This validator uses an OGNL expression to perform its validator.
Validates a field using an OGNL expression.
The FieldValidator interface defines the methods to be implemented by FieldValidators.
Base class for field validators.
Renders an HTML file input element.
Basic interface to access file on the File System and to monitor changes
Factory that creates FileManager, default to
DefaultFileManagerAllows to specify custom
FileManagerFactoryAllows to specify custom
FileManager by userReads a class from disk
class taken from Apache JCI
Represents file resource revision, used for file://* resources
Host configuration that wraps FilterConfig
Phantom reference with a
finalizeReferent() method which a
background thread invokes after the garbage collector reclaims the
referent.Soft reference with a
finalizeReferent() method which a background
thread invokes after the garbage collector reclaims the referent.Weak reference with a
finalizeReferent() method which a background
thread invokes after the garbage collector reclaims the referent.Wrap field validator, add visitor's field prefix to the field name.
FormButton.
Static Configuration Manager for the FreemarkerResult's configuration
Renders a view using the Freemarker template engine.
Freemarker based template engine.
When loading a template, if sees theme token in path, does a template search through
theme hierarchy for template, starting at the theme name after the token.
A Function provides a transformation on an object and returns the resulting
object.
Provides support for localization in the framework, it can be used to read only default bundles.
Renders parts of the HEAD section for an HTML file.
Renders an HTML input element of type hidden, populated by the specified property from the ValueStack.
Abstraction for host configuration information such as init params or the servlet context.
Use this annotation to allow call action or action's method via DELETE request only
Use this annotation to allow call action or action's method via GET request only
Use this annotation to allow call action or action's method via GET or POST request only
Enum represents possible http request types
Action when implements this interface is notified about what method was used to perform request,
it works in connection with
HttpMethodInterceptor
Another function of this interface is to return result, which should be returned when action
was called with wrong http methodInterceptor is used to control with what http methods action can be called,
if request with not allowed method was performed,
HttpMethodInterceptor.badRequestResultName
will be returned or if action implements HttpMethodAware
and HttpMethodAware.getBadRequestResultName() returns non-null result name,
thus value will be used instead.Use this annotation to allow call action or action's method via POST request only
Use this annotation to allow call action or action's method via PUT request only
Gets a resource bundle and place it on the value stack.
An interceptor that handles setting the locale specified in a session as the locale for the current action request.
Uses to handle reading/storing Locale from/in different locations
Beans marked with this interface will be always initialised
after the internal DI mechanism will be created.
Contains initialization operations
Annotates members and parameters which should have their value[s]
injected.
Marks a action method that if it's not validated by ValidationInterceptor then execute input method or input result.
InputTransferSelect jsp tag.
Builds a list of interceptors referenced by the refName in the supplied PackageConfig.
Configuration for Interceptors.
The builder for this object.
Dedicated interface used by
ObjectFactory to build InterceptorInterceptorListHolder
Defines an object that can be used to retrieve interceptor configuration
InterceptorMappingConfiguration for InterceptorStack.
The builder for this object.
This validator checks that a numeric field has a value within a specified range.
Field Validator that checks if the integer specified is within a certain range.
InvocationSessionStore
A base class for iterator filters
A bean that generates an iterator filled with a given object depending on the count,
separator and converter defined.
Interface for converting each separated token into an Object of choice.
NOTE: JSP-TAG
The iterator tag can export an IteratorStatus object so that
one can get information about the status of the iteration, such as:
index: current iteration index, starts on 0 and increments in one on every iteration
count: iterations so far, starts on 1.
Multipart form data request adapter for Jakarta Commons FileUpload package.
Multi-part form data request adapter for Jakarta Commons FileUpload package that
leverages the streaming API rather than the traditional non-streaming API.
Represents jar resource revision, used for jar://* resource
Read resources from a jar file
FileManager implementation used with JBoss AS
JSP based template engine.
Add nonce propagation feature to implement CSP in link tags
Host configuration that just holds a ServletContext
Entry in a list.
DoubleListUIBean is the standard superclass of all Struts list handling components.
Indicates that the implementing class can provide its own
Locale.Allows delegate creation of
LocaleProvider to another implementation provided
by a user.A interface that should be implemented by objects knowning their location (i.e.
Factory that remembers where a constant came from
Attaches location information to the factory.
Properties implementation that remembers the location of each property.
Base class for location aware objects
A location in a resource.
A class to handle location information stored in attributes.
A SAX filter that adds the information available from the
Locator as attributes.A simple immutable and serializable implementation of
Location.Location-related utility methods.
An finder or object locations
This validator checks that a numeric field has a value within a specified range.
Field Validator that checks if the long specified is within a certain range.
MakeIterator.
ValueStacks implementing this interface provide a way to remove block or allow access
to properties using regular expressions
A bean that takes several iterators and outputs the merge of them.
Append a list of iterators.
This listener is used by
MessageStoreInterceptor to store messages in HttpSession
just before result will be executed.Utility class contains common methods used by
MethodFilterInterceptor.Mock for an
ActionInvocation.Mock for an
ActionProxy.Simple configuration used for unit testing
Mock implementation to be used in unittests
Mock for an
Interceptor.Mocks the function of an ObjectTypeDeterminer for testing purposes.
Mock for a
Result.ModelDriven Actions provide a model object to be pushed onto the ValueStack
in addition to the Action itself, allowing a FormBean type approach like Struts.
Watches for
ModelDriven actions and adds the action's model on to the value stack.Refreshes the model instance on the value stack, if it has changed
Abstract wrapper class HTTP requests to handle multi-part data.
Parse a multipart request and provide a wrapper around the request.
Just as the CheckboxInterceptor checks that if only the hidden field is present, so too does this interceptor.
An implementation of a pattern matcher that uses simple named wildcards.
Stores the compiled pattern and the variable names matches will correspond to.
Represents a match from a namespace pattern matching.
Matches namespace strings against a wildcard pattern matcher
Interceptor that does nothing, used in the "empty" stack
This marker interface should be implemented by actions that do not want any parameters set on
them automatically.
Used across different places to check if given string is not excluded and is accepted
Interface for handling null results from Chains.
Null result to get around annotation defaults that can't be null
FIXME: ???? is it usable? doesn't it make sense to have such result?
ObjectFactory is responsible for building the core framework objects.
An interface to be implemented by any ObjectFactory implementation
if it requires shutdown hook whenever an ObjectFactory is to be
destroyed.
An Object to use within OGNL to proxy other Objects
usually Collections that you set in a different place
on the ValueStack but want to retain the context information
about where they previously were.
Is able to access (set/get) properties on a given object.
Determines what the key and and element class of a Map or Collection should be.
A basic cache interface for use with OGNL processing (such as Expression, BeanInfo).
Used by
OgnlUtil to create appropriate OGNL
caches based on configuration.This OGNL Cache implementation is backed by
Caffeine which uses the Window TinyLfu algorithm.Basic OGNL cache implementation.
Guards all expressions parsed by Struts Core.
A basic OGNL LRU cache implementation.
OGNL implementation of
TextParserWraps an XWork type conversion class for as an OGNL TypeConverter
Utility class that provides common access to the Ognl APIs for
setting and getting properties from objects (usually Actions).
Ognl implementation of a value stack that allows for dynamic Ognl expressions to be evaluated against it.
Creates an Ognl value stack
Freemarker's TransformModel for OptGroup component.
OptionTransferSelect jsp tag.
Configuration for Package.
The builder for this object.
Provides configuration packages.
Tags can implement this to support nested param tags without the name attribute.
Defines a parameter action prefix.
This interface is implemented by actions that want to declare acceptable parameters.
This is a simple XWork interceptor that allows parameters (matching
one of the paramNames attribute csv value) to be
removed from the parameter map if they match a certain value
(matching one of the paramValues attribute csv value), before they
are set on the action.
This interface gives actions an alternative way of receiving input parameters.
This interceptor sets all parameters on the value stack.
This interface is implemented by actions that want to declare acceptable parameter values.
Accept parameter name/value to be set on
ResultCompiles and matches a pattern against a value
This result can only be used in code, as a result of action's method, eg.:
A result that send the content out as plain text.
A utility class for invoking prefixed methods in action class.
Quickly matches a prefix to an object.
Preparable Actions will have their
prepare() method called if the
PrepareInterceptor is applied to the ActionConfig.This interceptor calls
prepare() on actions which implement
Preparable.Contains preparation operations for a request before execution
PreResultListeners may be registered with an
ActionInvocation to get a callback after the
Action has been executed but before the Result
is executed.Actions that want access to the Principal information from HttpServletRequest object
should implement this interface.
Proxy interface used together with PrincipalAware interface.
This class is used to read properties lines.
Allows registration of classes that should be allowed to be used in OGNL expressions, using a key to identify the
source of the allowlist.
ProxyUtilA builder used to create a proper Query String out of a set of parameters
Used to parse Http Query String into a map of parameters with support for fragment
Represents result of parsing query string by implementation of
QueryStringParserBase class for range based validators.
Marking interface for results which perform browser redirection
Extends
ReferenceMap to support lazy loading values by overriding
ReferenceCache.create(Object).Concurrent hash map that wraps keys and/or values in soft or weak
references.
Reference type.
Manages variables in the reflection context and returns values
to be used by the application.
Declares a class that wants to handle its own reflection exceptions
Validates a string field using a regular expression.
Validates a string field using a regular expression.
Allows regular expressions to be used in action names.
Holds a compiled expression to match URLs
The ReloadingClassLoader uses a delegation mechanism to allow
classes to be reloaded.
An abstract base class that adds in the capability to populate the stack with
a fake parameter map when a conversion error has occurred and the 'repopulateField'
property is set to "true".
A simple implementation of the
Map interface to handle a collection of request attributes.Request handling utility class.
This validator checks that a field is non-null.
RequiredFieldValidator checks if the specified field is not null.
This validator checks that a String field is not empty (i.e.
RequiredStringValidator checks that a String field is non-null and has a length > 0.
Render a reset button.
ResolverUtil is used to locate classes that are available in the/a class path and meet
arbitrary conditions.
A Test that checks to see if each class is annotated with a specific annotation.
A Test that checks to see if each class is assignable to the provided class.
A Test that checks to see if each class name ends with the provided suffix.
A simple interface that specifies how to test classes to determine if they
are to be included in the results produced by the ResolverUtil.
Extension Interface for TextProvider to help supporting ResourceBundles.
Interface for the resource isolation policies to be used for fetch metadata checks.
*interface taken from Apache JCI
class taken from Apache JCI
Extended version of
RestfulActionMapper, see documentation for more details
Restful2ActionMapperSimple Restfull Action Mapper to support REST application
See docs for more information
RestfulActionMapper
All results (except for
Action.NONE) of an Action are mapped to a View implementation.Configuration for Result.
The builder for this object.
Used by
ObjectFactory to build ResultConfiguration class for result types.
The builder for this object.
Class represents common revision resource, should be used as default class when no other option exists
RuntimeConfiguration
Scope of an injected objects.
Pluggable scoping strategy.
Annotates a scoped implementation class.
Adds the ability to set a model, probably retrieved from a given state.
An interceptor that enables scoped model-driven actions.
Simple Hash model that also searches other scopes.
Add nonce propagation feature to implement CSP in script tags
Allows access decisions to be made on the basis of whether a member is static or not.
Render an HTML input tag of type select.
Web-specific context information for actions.
For components that have a dependence on the Servlet context.
Dedicated interface to allow inject
ServletContext and perform initialisation based in itHost configuration that wraps a ServletConfig
PrincipalProxy implementation for using HttpServletRequest Principal related methods.
Calls the
sendRedirect
method to the location specified.All Actions that want to have access to the servlet request object must implement this interface.
All Actions that want to have access to the servlet response object must implement this interface.
Implementation of the
UrlRenderer interface that creates URLs suitable in a servlet environment.Actions that want access to the user's HTTP session attributes should implement this interface.
A simple implementation of the
Map interface to handle a collection of HTTP session
attributes.This interface should be implemented by validators that can short-circuit the validator queue
that it is in.
This validator checks that a numeric field has a value within a specified range.
Field Validator that checks if the short specified is within a certain range.
Marks an Action method to not be validated
A bean that takes a source and comparator then attempt to sort the source
utilizing the comparator.
NOTE: JSP-TAG
Interface for loading static resources, based on a path.
This interceptor populates the action with the static parameters defined in the action configuration.
A custom Result type for sending raw data (via an InputStream) directly to the
HttpServletResponse.
This validator checks that a String field is of the right length.
StringLengthFieldValidator checks that a String field is of a certain length.
Background thread to be executed by the ExecuteAndWaitInterceptor.
Selects the implementations of key framework extension points, using the loaded
property constants.
Contains common functionalities for Struts JSP Tags.
This class provides a central location for framework configuration keys
used to retrieve and store Struts configuration settings.
Default implementation
A generic runtime exception that optionally contains Location information
Executes the discovered request information.
Servlet listener for Struts.
Provides support for localization in the framework, it can be used to read only default bundles,
or it can search the class hierarchy to find proper bundles.
Provides @s.tag access for various tags.
The default implementation of
OgnlGuard.Used to annotate public getter/setter methods or fields on
Action classes that are
intended for parameter injection by the ParametersInterceptor.Handles both the preparation and execution phases of the Struts dispatching process.
Prepares the request for execution by a later
StrutsExecuteFilter filter instance.All Struts requests are wrapped with this class, which provides simple JSTL accessibility.
Default resource isolation policy used in
FetchMetadataInterceptor that
implements the ResourceIsolationPolicy interface.Default implementation which uses
ParamNameAwareResult to accept or throw away parametersServlet dispatcher for Struts.
Constants used internally by Struts.
An annotation to document a Struts jsp/freemarker/velocity tag
Documents an attribute to a Struts tag
Marks a class as the top class in the class hierarchy scanned for tag annotations
FIXME: use it or remove
Generic test setup methods to be used with any unit testing framework.
This factory enables users to provide and correctly initialize a custom TextProvider.
Default implementation of
TypeConverterCreatorDefault implementation of
TypeConverterHolderStruts base utility class, for use in Velocity and Freemarker templates
Override Xwork class so we can use an arbitrary config file
Render a submit button.
A bean that takes an iterator and outputs a subset of it.
A decider determines if the given element should be added to the list or not.
NOTE: JSP-TAG
A bean that helps implement a tabbed pane
FIXME: use it remove
Provides Velocity implementation classes for a tag library
Provides Freemarker implementation classes for a tag library
A template is used as a model for rendering output.
Any template language which wants to support UI tag templating needs to provide an implementation of this interface
to handle rendering the template
The TemplateEngineManager will return a template engine for the template
Context used when rendering templates.
This is the testing interface that is used to accept or reject resources.
Used to parse expressions like ${foo.bar} or %{bar.foo} but it is up tp the TextParser's
implementation what kind of opening char to use (#, $, %, etc)
Utility class for text parsing.
A parsed value evaluator for
TextParseUtil.Provides access to
ResourceBundles and their underlying text messages.Helper methods to access text from TextProviders
Default TextProvider implementation.
Allows any bean to allowlist a class for use in OGNL expressions, for the current thread only.
A bean that can be used to time execution of pages
FIXME: remove?
TokenHelper
TypeConversionException should be thrown by any TypeConverters which fail to convert values
Interface for accessing the type conversion facilities within a context.
Instantiate converter classes, if cannot create TypeConverter throws exception
Holds all mappings related to
TypeConverters
UIBean is the standard superclass of all Struts UI components.
Simple marker interface to indicate an object should not have its properties copied during chaining.
Handles cases when the result or action is unknown.
Dedicated interface used by
ObjectFactory to build UnknownHandlerAn unknown handler manager contains a list of UnknownHandler and iterates on them by order
Virtual representation of an uploaded file used by
MultiPartRequestActions that want to be aware of all the uploaded file should implement this interface.
A bean that can generate a URL.
URL Decoder used internally by Struts
URL Encoder used internally by Struts
Helper class used to build Urls or parse request params
Implementations of this interface can be used to build a URL
Implementations of this interface are responsible for rendering/creating URLs for a specific
environment (e.g.
Use with ClassFinder to filter the Urls to be scanned, example:
This validator checks that a field is a valid URL.
URLValidator checks that a given field is a String and a valid URL
Provides an interface in which a call for a validation check can be done.
ValidationAware classes can accept Action (class level) or field level error messages.
Provides a default implementation of ValidationAware.
ValidationErrorAware classes can be notified about validation errors
before
DefaultWorkflowInterceptor will return 'inputResultName' result
to allow change or not the result name
This interface can be only applied to action which already implements ValidationAware interface!ValidationException.
The ValidationParameter annotation is used as a parameter for CustomValidators.
ValidationWorkflowAware classes can programmatically change result name when errors occurred
This interface can be only applied to action which already implements
ValidationAware interface!Holds the necessary information for configuring an instance of a Validator.
Builds a ValidatorConfig
The context for validation.
Dedicated interface used by
ObjectFactory to build ValidatorValidatorFactory
This class serves 2 purpose :
Parse the validation config file.
Abstract implementation of the Validator interface suitable for subclassing.
ValidatorTypeValueStack allows multiple beans to be pushed in and dynamic EL expressions to be evaluated against it.
Factory that creates a value stack, defaulting to the OgnlValueStackFactory
The validator allows you to forward validator to object properties of your action
using the objects own validator files.
This class is an utility class that perform wilcard-patterns matching and
isolation taken from Apache Cocoon.
Helper class to convert wildcard expression to regular expression
Interceptors marked with this interface won't be fully initialised during initialisation.
Looks in the classpath for an XML file, "struts.xml" by default,
and uses it for the XWork configuration.
This is a base Struts
ConfigurationProvider for loading configuration from a parsed
XML document.XML utilities.
XWorkConverter is a singleton used by many of the Struts 2's Ognl extension points,
such as InstantiatingNullHandler, XWorkListPropertyAccessor etc to do object
conversion.
A simple list that guarantees that inserting and retrieving objects will always work regardless
of the current size of the list.
Overrides the list property accessor so in the case of trying
to add properties of a given bean and the JavaBean is not present,
this class will create the necessary blank JavaBeans.
Implementation of PropertyAccessor that sets and gets properties by storing and looking
up values in Maps.
Allows methods to be executed under normal cirumstances, except when
ReflectionContextState.DENY_METHOD_EXECUTION
is in the action context with a value of true.Base JUnit TestCase to extend for XWork specific JUnit tests.
Generic test setup methods to be used with any unit testing framework.
Wraps an OGNL TypeConverter as an XWork TypeConverter