All Classes and Interfaces
Class
Description
AbortException is thrown internally when a response is aborted.
Provides common methods and fields for the default implementations of the
repository interface
Abstract resource base class that implents get/setOverloadedResource.
This is an abstract Hop servlet adapter.
ClassLoader subclass with package accessible addURL method.
The central class of a Helma application.
Application bean that provides a handle to the scripting environment to
application specific functionality.
This class is responsible for starting and stopping Helma applications.
This is thrown when a request is made to a stopped
application
Helma command line runner class.
Provides module scripts without compiling, should compiling not be possible for whatever reason.
Thrown when more than one thrad tries to modify a Node.
Cookie Transmitter.
A Map that wraps another map and creates a new copy of the
wrapped map if we try to modify it.
A cron entry, derived from Protomatter's CronEntry class.
This file authenticates against a passwd source
Thrown on any kind of Database-Error
A Database object, representing a connection to a JDBC Driver
A RowSet object
A class that encapsulates the Column name and data type of a column in a
relational table.
This is the internal representation of a database key.
A DbMapping describes how a certain type of Nodes is to mapped to a
relational database table.
This class describes a releational data source (URL, driver, user and password).
a demo extension implementation, to activate this add
extensions =
helma.extensions.demo.DemoExtensions
to your server.properties
.Compares two lists, returning a list of the additions, changes, and deletions
between them.
A legacy adapter that is compatible to the interface of the old GPL licenced Diff.
Servlet client that runs a Helma application for the embedded
web server
Utility class for empty enum
An extended Logger that writes to a file and rotates files each midnight.
An EcmaScript FileIO 'File' object
Repository implementation for directories providing file resources
The basic exception class used to tell when certain things go
wrong in evaluation of requests.
A FTP-client object that allows to do some FTP from HOP applications.
A handle for an asynchronous request execution.
Helma global object defines a number of custom global functions.
Support for .hac (action) and .hsp (template) files
Helma extensions have to subclass this.
Liberal security manager for Helma system that makes sure application code
is not allowed to exit the VM and set a security manager.
ShutdownHook that shuts down all running Helma applications on exit.
This is a utility class to encode special characters and do formatting
for HTML output.
Interface that is implemented by Database wrappers
An interface for objects that generate IDs (Strings) that are
unique for a specific type.
Factory class for generating Image objects from various sources.
Get file format, image resolution, number of bits per pixel and optionally
number of images, comments and physical resolution from
JPEG, GIF, BMP, PCX, PNG, IFF, RAS, PBM, PGM, PPM, PSD and SWF files
(or input streams).
A wrapper for an image that uses the ImageIO Framework.
Extension to provide Helma with Image processing features.
The ImageWaiter will only be used like this:
image = ImageWaiter.waitForImage(image);
Abstract base class for Image Wrappers.
A class for paranoid servers to filter IP addresses.
Interface that all Nodes implement.
Interface that defines states of nodes
Interface that objects need to implement to build a Helma URL tree.
Interface that is implemented by node properties.
RMI interface for an application.
This interface is kept for databases that are able
to run transactions.
JSAdapter is java.lang.reflect.Proxy equivalent for JavaScript.
This is the interface for the internal representation of an object key.
A simple logger that writes to a PrintStream such as System.out.
Implementation of Jakarta Commons LogFactory that supports both
simple console logging and logging to files that are rotated and
gzipped each night.
class with byte data of helma logo
A JavaScript wrapper around a JavaMail message class to send
mail via SMTP from Helma
A class that wraps a Java Map as a native JavaScript object.
This represents a MIME part of a HTTP file upload
Makes MimeParts usable as Datasources in the Java Activation Framework (JAF)
Repository implementation that provides all of its subdirectories
as top-level FileRepositories
This is the internal representation of a database key with multiple
columns.
An implementation of INode that can be stored in the internal database or
an external relational database.
This is passed to NodeListeners when a node is modified.
This class is a handle or reference to a Node.
The NodeManager is responsible for fetching Nodes from the internal or
external data sources, caching them in a least-recently-used Hashtable,
and writing changes back to the databases.
Bridges the gap between CommonJS-style module loading and Node.js-style module loading.
The basic exception class used to tell when certain things go
wrong in evaluation of requests.
Interface Helma object cache classes need to implement.
Thrown when an object could not found in the database where
it was expected.
A server socket that can allow connections to only a few selected hosts.
This class describes a parent relation between releational nodes.
This class wraps around instances of helma.framework.core.RequestPath and
exposes them in an array-like fashion to the JavaScript runtime.
A property implementation for Nodes stored inside a database.
An interface that allows us to keep track of changed properties in
JavaScript objects.
The Prototype class represents Script prototypes/type defined in a Helma
application.
RedirectException is thrown internally when a response is redirected to a
new URL.
This describes how a property of a persistent Object is stored in a
relational database table.
Repository represents an abstract container of resources (e.g.
This class does the work for incoming requests.
Represents a URI request path that has been resolved to an object path.
A Transmitter for a request from the servlet client.
Resource represents a pointer to some kind of information (code, skin, ...)
from which the content can be fetched
Sorts resources according to the order of their repositories
A property dictionary that is updated from property resources
A utility class that allows Resource consumers to track changes
on resources.
A Transmitter for a response to the servlet client.
This is the implementation of ScriptingEnvironment for the Mozilla Rhino EcmaScript interpreter.
This is the implementation of ScriptingEnvironment for the Mozilla Rhino EcmaScript interpreter.
This is the interface that must be implemented to make a scripting environment
usable by the Helma application server.
The base class for wrapped exceptions thrown by invocation of the scripting engine.
Serialization proxy/placeholder interface.
Helma server main class.
Utility class for server config
This represents a session currently using the Hop application.
The SessionBean wraps a
Session
object and
exposes it to the scripting framework.This is an example implementation for the helma.framework.IPathElement interface.
This represents a Helma skin, i.e.
Manages skins for a Helma application
Standalone servlet client that runs a Helma application all by itself
in embedded mode without relying on a central instance of helma.main.Server
to start and manage the application.
Utility class for String manipulation.
Container implementation for subnode collections.
This is the internal key for an object that is not - or not directly - fetched from a db,
but derived from another object.
Map class used internally by Helma.
A property dictionary that is updated from a property file each time the
file is modified.
TimeoutException is thrown by the request evaluator when a request could
not be serviced within the timeout period specified for an application.
Utility class for timing a series of events
A subclass of thread that keeps track of changed nodes and triggers
changes in the database when a transaction is commited.
A transient implementation of INode.
A property implementation for Nodes stored inside a database.
The type manager periodically checks the prototype definitions for its
applications and updates the evaluators if anything has changed.
A proxy to java.net.URLEncoder which only encodes when there is actual work
to do.
A CacheMap subclass that uses WeakHashMaps internally for its
rotating tables.
A Map that wraps another map.
A wrapper around NodeManager that catches most Exceptions, or rethrows them as RuntimeExceptions.
A simple XML-database
This class provides methods for converting HopObjects to XML and back.
An extension to transparently call and serve XML-RPC from Rhino.