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