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.