All Classes and Interfaces
Class
Description
Abstract convenience class that provides a positive no-op implementation of
all the methods of the
Callbacks interface.This abstract class offers common implementations of several
ResourceFinder methods.This abstract class implements parts of the
Response interface to
provide behaviour that is specific to RIFE2.AbstractSessionValidator<C extends CredentialsManager,S extends SessionManager,R extends RememberManager>
Convenience superclass for
SessionValidator implementations.AbstractWhereDelegateQuery<QueryType extends AbstractWhereDelegateQuery,DelegateType extends AbstractWhereQuery>
AbstractWhereGroup<ParentType extends rife.database.queries.WhereQuery>
Declares a field for the active site
This exception will be thrown when an answer continuation is triggered.
General purpose class containing common array manipulation methods.
Configuration class that determines how the authentication element implementations
should behave.
Requires that the user has a valid authentication session before access
is allowed.
Classloader implementation that will transform bytecode for classes that
should receive the continuations functionalities.
Basic implementation of a 'continuable runner' that will execute the
continuable objects and correctly handle the continuations-related
exceptions that are triggered.
BasicSessionValidator<C extends CredentialsManager,S extends SessionManager,R extends RememberManager>
Non-optimized session validator.
This interface can be implemented to use with the
GenericQueryManager.restore(BeanFetcher) method.Handles the process of setting values in a template based on a Java bean
instance.
Utility class providing methods for working with Java beans.
Enum used to specify which accessors to consider when retrieving a bean's properties.
Declares a request body.
Callbacks are hooks that are being called when beans are manipulated
through the
GenericQueryManager or other
query managers that are based on it.Callbacks can either be implemented directly by implementing the
Callbacks interface, or they
can be provided by implementing this interface.This exception will be thrown when a call continuation is triggered.
Contains the state of a call continuation.
Thrown when a call target couldn't be resolved to a proper
ContinuableObject.Retrieves the target continuable for a call continuation.
Utility class to load the bytes of class files.
This exception is thrown and when the bytecode for a class couldn't be
found.
Retrieves the continuable for a call continuation where the call target is a
class.
Detects whether a class implements a particular interface by analyzing the
bytecode instead of loading the class and performing reflection calls.
The ClassUtils class provides useful utility methods for working with Java classes.
Interface that should be implemented by classes that support cloneable
continuations.
This abstract class extends the
PropertyValidationRule class
to provide common functionality that is useful for all concrete CMF
validation rules.The
Config class manages the configuration of parameters and lists.Declares a config parameter.
This is a class designed for database connection pooling.
This interface defines methods for bean-centric constraining of data
entities.
A
ConstrainedBean object makes it possible to define all
constraints for a bean instance that are not related to a single property.Detects whether a class implements the
Constrained interface or not,
by analyzing its bytecode.A
ConstrainedProperty object makes it possible to easily
define all constraints for a named property of a bean.Listeners that implement this interface will be notified when changes
occur to the
ConstrainedProperty instances that it has been
added to.Contains the information required to store new content data together with
additional meta-data.
By implementing this interface it's possible to provide the logic that should be
executed by methods that allow interaction with content data.
By implementing this interface it's possible to provide the logic that should be
executed by methods that allow interaction with content data.
This class represents all the information that is stored in the backend
about a certain
Content instance.This is an abstract class that needs to be extended by all the classes that
are able to load raw data and converted it to a common internal type.
This is an interface that should be implemented by all content loader
back-ends.
Contains the location of content in a repository
A
ContentManager manages content that is stored in a back-end
data store.The
ContentQueryManager simplifies working with content a lot.Contains the information that's required to describe a content repository.
A
ContentStore stores the actual content data and is
responsible for managing it.This interface defines the API that has to be implemented by classes that
are capable of transforming content data after it's initially loaded.
This class provides the context for the current HTTP request.
Detects whether a class implements the continuable marker interface that is
set up in the provided instrumentation config.
Thrown when a local variable in a
ContinuationStack
couldn't be cloned when a continuation is resumed.This interface needs to be implemented to configure the bytecode
instrumentation that enables the continuations functionalities.
Configures the runtime behavior of the continuations engine.
Contains all contextual data of one particular continuation.
Configures the debug output of the continuations engine.
Byte-code instrumentation configuration that is needed for continuations to
work for the workflow engine.
Manages a collection of
ContinuationContext instances.Provides a continuations instrumentation agent that will modify
the bytecode of the classes that are loaded.
Abstract class that transforms the bytecode of regular classes so that
they support continuations functionalities.
Thrown when a continuations method has not been instrumented.
[PRIVATE AND UNSUPPORTED] Contains the local state of a continuation.
A bytecode transformer that will modify classes so that they
receive the functionalities that are required to support the continuations
functionalities as they are provided by RIFE2's web engine.
This is a marker interface to make it possible to throw runtime exceptions
that have to be treated as expected and 'positive'.
General purpose class providing methods to convert between data types.
Declares a request cookie.
Helper class for building a
Cookie.Singleton class that provides access to the current core version as a string.
Object representation of a SQL "CREATE SEQUENCE" query.
Object representation of a SQL "CREATE TABLE" query.
This interface defines the methods that classes with
Credentials functionalities have to implement.This interface defines the methods that classes with
CredentialsManager functionalities have to implement.This class adds additional properties to the
ContentInfo class
to be able to store the data in a database.Factory for
DatabaseRemember manager instances that creates singletons
based on the Datasource.This class offers
ResourceFinder and ResourceWriter
capabilities for resources that are stored in a database.Factory for
DatabaseSessions manager instances that creates singletons
based on the Datasource.Factory for
DatabaseSessionValidator manager instances that creates singletons
based on the Datasource and an optional differentiating
identifier.Factory for
DatabaseUsers manager instances that creates singletons
based on the Datasource and an optional differentiating
identifier.Contains all the information required to connect to a database and
centralizes the creation of connections to a database.
Contains a collection of
Datasource instances.This class allows a
ResultSet to be easily processed into bean
instance.Represents one connection to a database.
Periodic probe job to keep connections non-idle and probe for dead ones.
Provides a wrapper around the regular JDBC
PreparedStatement
class.By extending this class it's possible to easily customize the behaviour of
a large number of methods in the
DbQueryManager class.This is a convenience class to make it easy to control the queries that
handle the retrieval, storage, update and removal of data in a database.
This class is a simple cache for
DbQueryManager objects.This class allows for
DbQueryManagers to be created more
dynamically and with more features than by direct instantiation.By extending this class it's possible to easily customize the behaviour of
some methods in the
DbQueryManager class.This abstract base class should be used to implement classes that process one
row in a database query result set.
Provides a wrapper around the regular JDBC
Statement class.By extending this class it's possible to provide the logic that should be
executed by the
inTransaction
method in the DbQueryManager class.Convenience class that offers the same facilities as the
DbTransactionUser class, but makes it easier to work with
transactions that don't return any results.Standard element that allows specific routes to always defer
execution to the servlet container.
Object representation of a SQL "DELETE" query.
Functional interface that captures an action to execute
on a
DirBuilder instance.Directory and file structure builder, using a fluent API and lambdas
to convey the hierarchical structure of on the filesystem in code.
Object representation of a SQL "DROP SEQUENCE" query.
Object representation of a SQL "DROP TABLE" query.
Java implementation of the Drupal 7 password hashing algorithm.
Interface describing the functionality of a RIFE2 element of execution.
Configures the continuations system for the web engine.
This is a bytecode transformer that will modify classes so that they
receive the functionalities that are required to support the continuations
functionalities as they are provided by RIFE2's web engine.
A bean representing an entry in a feed.
An
EntryProcessor is a class that knows how to create a section of a feed
for output.An
EntryProvider is a way to get entries for a feed.The purpose of this abstract base class is to allow the creation of
type-safe enumerations.
Events cause work to be resumed when they are waiting for the event type.
This interface allows classes to register themselves to receive
notifications when events are triggered in a
Workflow.Executor is an abstract class that can be extended to implement the logic
that happen when tasks of a particular type are executing through the
scheduler.
A bean representing a feed, or rather a feed's metadata.
An
Element that uses an EntryProvider to print
out a feed.Functional interface that captures an action to execute
on a
FileBuilder instance.Directory and file structure builder, using a fluent API and lambdas
to convey the hierarchical structure of on the filesystem in code.
Declares a file that was uploaded in this request.
A utility class for handling files.
This is a no-op transformer that is just used to output the instrumented
bytecode of classes when the "rife.instrumentation.dump"
system property is set.
The flow direction that will be used by a field annotation that supports it.
Formats raw data according to the information that's provided by a
Content instance.This interface defines the methods for bean-centric form generation.
Defines the frequency at which a task should execute.
Main entry class into the RIFE2 web engine, used both by the servlet engine and
the out of container testing API.
A
GenericQueryManager provides features that make it easy to
persist and retrieve beans in a database with single method calls.The methods of a
GenericQueryManagerListener will be executed
as the corresponding actions are successfully executed through the
GenericQueryManager that this listener is registered with.Utility class to provide many-to-many and many-to-one relational
capabilities to generic query manager implementations.
Declares a request header.
This class allows the creation of a hierarchical tree of named
PropertyValue instances.This interface defines the methods that are needed for the
Identified
element to be able to set up a RoleUserIdentity instance for each authenticated user for whom the
Identified element is executed.Tries to identify a user and store that as a request attribute.
Loads raw content as image data.
This is an abstract class that should be implemented by all image content
loader back-ends.
This interface defines the API that has to be implemented by classes that
are capable of transforming
image content data after
it's initially loaded.Formats raw
Content data as an image.This is an image loader back-end that uses ImageIO to load image files.
This is an image loader back-end that uses ImageJ to load TIFF files, if
its classes are present in the classpath.
This is a no-op transformer that is just used to output the initial
bytecode of classes that will be instrumented when the "rife.instrumentation.dump"
system property is set.
By extending this class it's possible to provide the logic that should be
executed by methods that allow interaction with an
InputStream.Object representation of a SQL "INSERT" query.
An anonymous value inside a template, which is not referenced anywhere in
the template, but can be used to produce intermediate strings using the
template engine.
Utility class to obtain information about the currently running Java
specification.
This utility class will modify property accessors of classes that implement
the
Constrained interface and add lazy loading for properties with
manyToOne constraints.This is a bytecode transformer that will modify classes so that they
receive the functionalities that are required to support lazy-loading
of relationships when the
GenericQueryManager is being used.An error that is intended to be as lightweight as possible.
This interface to be able to list all the active sessions in a
SessionManager without having to store them all in memory.This holds the content that was loaded by a content loader backend and
also tracks the original mime type of the provided data.
This class makes it possible to always keep a localized string up-to-date.
Provides a login form so that the user can start a valid authentication session.
Provides logout logic with an optional template that can be printed for
configuration.
This class offers
ResourceFinder and ResourceWriter
capabilities for resources that are stored in a memory.This abstract base class can be conveniently used to added
Constrained and Validated metadata to a POJO.This interface can optionally be implemented by a class implementing the
MetaDataMerged interface.This utility class provides an entrance method to modify the bytecode of a
class so that metadata from a sibling class is merged into the first class.
Declares which class should be used for meta-data merging.
Detects whether a class has the
MetaDataClass class annotation
by analyzing its byte code.This is a bytecode instrumenter that will modify classes so that they
receive the functionalities that are required to support meta-data
merging.
This interface is merely a marker interface to indicate to RIFE2 that it
should consider this class as a
MetaData class whose
interfaces will be automatically merged into the sibling class that it's
augmenting.This is a bytecode transformer that will modify classes so that they
receive the functionalities that are required to support meta-data
merging.
This is a typed enumeration of all the mime types that the content
management framework specifically knows about.
Returns appropriate formatter instances for supported CMF mime types.
Returns appropriate validation rules for supported CMF mime types.
Thrown when the active continuation runtime configuration isn't set.
Simulates a conversation between a web browser and a servlet container.
Wraps a
Cookie by tracking the creation time and allowing max-age
expiration to be evaluated.An instance of this class provides all the data that is needed to simulate
a file upload.
Corresponds to a form in an HTML document after it has been parsed with
ParsedHtml.parse(rife.test.MockResponse).Corresponds to a link in an HTML document after it has been parsed with
ParsedHtml.parse(rife.test.MockResponse).Provides a
Request implementation that is suitable for testing a
web application outside a servlet container.Provides a
Response implementation that is suitable for testing a
web application outside a servlet container.Selects a name according to the current hostname.
Selects a name according to the current operating system.
Selects a name according to the
rife.application
application property.Selects a name according to the current user.
Thrown when a continuable instance can't be found
ContinuableObject.General purpose class containing common
Object manipulation
methods.This class makes it possible to easily manage an integer ordinal column
that is typically used to determine the order of the rows in a specific
table.
This class provides utility methods to generate navigation for paged lists.
Declares a request parameter.
Declares a bean to be mapped from or to request parameters.
Retrieves the text content of a
MockResponse and parses it as HTML.Credentials managers that can encrypt passwords implement this interface.
Declares a path info segment.
Glue interface to help building the pathinfo mapping
structure
Provides the different pathinfo handling options for a
route definition.
Micro DSL to describe the format of how a pathinfo should
be structure and mapped to parameters.
This exception will be thrown when a pause continuation is triggered.
Formats plain test
Content data.By implementing this class it's possible to easily customize the behaviour of
a large number of methods in the
DbQueryManager class.Standard element that will print a template with particular name.
Declares a property.
This abstract class extends the
AbstractValidationRule class
to provide common functionality that is useful for all bean property
validation rules.This interface defines the methods that need to be implemented by classes
that are able to provide values to properties.
An ordered list of property values.
Holds a single static object property value that doesn't change at runtime.
Retrieves a property value as template instance of a particular type.
This interface defines the API that has to be implemented by classes that
are capable of transforming raw content data after it's initially loaded.
Formats raw
Content data.By extending this class it's possible to provide the logic that should be
executed by methods that allow interaction with a
Reader.An instance of
ReadQueryString can contain any kind of SQL
query for read purposes.An instance of
ReadQueryTemplate will obtain a SQL from a
Template block.This interface defines the methods that classes with
RememberManager functionalities have to implement.This interface needs to be implemented by all credentials classes that
are allowed to be remembered.
This interface contains all the methods that the web engine needs to be
able to correctly handle incoming requests.
Declares a request attribute.
The collection of HTTP methods as an enum.
This interface defines the methods that classes with
ResourceFinder functionalities have to implement.This class offers
ResourceFinder capabilities for resources that
are available through the classloader.This class offers
ResourceFinder capabilities for resources that
are available through a collection of directories.Allows a group of resource finders to acts as if they are one single
resource finders.
This interface defines the methods that classes with
ResourceWriter functionalities have to implement.This interface contains all the methods that the web engine needs to be
able to send a response to the client.
The RIFE2 instrumentation agent will modify the bytecode of the classes
that are loaded to provide new capabilities that are otherwise provided by
the class-loader.
Provides configuration over RIFE2 itself.
Servlet filter implementation that initializes a RIFE2 site and handles
servlet requests and responses.
An abstract base class that will only execute the bytecode transformation
when the class is considered to not be part of a core package, like for
example the JDK or the standard XML parsers.
Provides standard
RoleUserCredentials functionalities by
implementing the property accessors and setting up basic validation rules.This interface needs to be implemented by all credentials classes that
work with
RoleUsersManagers, which
is the default user management in RIFE.Interface describing a route that leads to a RIFE2 web execution
Element.Provides the routing features of the RIFE2 web engine.
This interface can be implemented to process one row in a database
query result set.
The
Scheduler class performs the actual task scheduling and dispatch to
the appropriate executors.Interface that scheduler factories should implement.
Object representation of a SQL "SELECT" query.
Standard formatter to convert serializable objects to and from strings.
Embedded Jetty server that can directly start from a RIFE2 site.
Convenience class that wraps around an
HttpSession.Declares a session attribute.
This interface defines the methods that classes with
SessionAttributes functionalities have to implement.This interface defines the methods that classes with
SessionManager functionalities have to implement.This interface defines the methods that classes with
SessionValidator functionalities have to implement.The main site of your web application, which is also the
top-level router.
Request parameters with a special meaning for RIFE2.
This exception will be thrown when a stepBack continuation is triggered.
General purpose class containing common
String manipulation
methods.A validation rule that checks if the data in a property can be
loaded as a supported image format without errors.
A validation rule that checks if the data in a property can be
loaded as supported and valid xhtml without errors.
A task contains all the information for the scheduler to plan its execution.
This interface defines the methods that classes with
TaskManager functionalities have to implement.A task option provides a way to configure an existing task.
This interface defines the methods that classes with
TaskOptionManager functionalities have to implement.A template is used to construct, manipulate and produce text content.
Encodes
Strings into a corresponding template output format,
so they will be displayed correctly in the resulting file.Factory for creating RIFE2 template instances.
This interface defines the API that has to be implemented by classes that
are capable of transforming
text content data
after it's initially loaded.Embedded Tomcat server that can directly start from a RIFE2 site.
Utility class providing the necessary functions to build 2FA using a time-based OTP algorithm
Standard element that can be placed
before
any other route to indicate to the clients that the content should not be cached.Generates a 216 bit unique ID that is more secure than the standard 128 bit UUID,
which has an effective 122 bits of entropy.
Object representation of a SQL "UPDATE" query.
An
UploadedFile instance is created by the web engine when
files are uploaded through a multipart request.UrlBuilder helps creating valid URLs that automatically
adapt based on the current execution Context and target Route.The segments that are generated by the URL builder.
This interface defines methods for bean-centric data validation.
This interface has to be implemented by all classes that provide a context
in which
Validated bean instances can be validated.Instances of this class detail subjects that were found invalid during
validation.
An object which can render content for a value in a template.
Singleton class that provides access to the current RIFE2 version as a string.
Internal class to handle virtual parameters of a
DbPreparedStatement.Internal interface that defines the methods that a
VirtualParameters handler has to support.This is an internal exception that is used whenever the bytecode of a
class is being visited and the analysis has to be interrupted in the
middle.
WhereGroup<ParentType extends rife.database.queries.WhereQuery>
WhereGroupAnd<ParentType extends rife.database.queries.WhereQuery>
WhereGroupOr<ParentType extends rife.database.queries.WhereQuery>
Work can be executed in a
Workflow.Runs work and dispatches events to work that is paused.
This is a bytecode transformer that will modify classes so that they
receive the functionalities that are required to support the continuations
functionalities as they are provided by RIFE2's workflow engine.
Loads raw content as xhtml data.
This is an abstract class that should be implemented by all xhtml content
loader back-ends.
Formats raw
Content data as valid Xhtml.