# All Classes and Interfaces

Class
Description
AbortException
AbortException is thrown internally when a response is aborted.
AbstractRepository
Provides common methods and fields for the default implementations of the repository interface
AbstractResource
Abstract resource base class that implents get/setOverloadedResource.
AbstractServletClient
This is an abstract Hop servlet adapter.
AppClassLoader
ClassLoader subclass with package accessible addURL method.
Application
The central class of a Helma application.
ApplicationBean
Application bean that provides a handle to the scripting environment to application specific functionality.
ApplicationManager
This class is responsible for starting and stopping Helma applications.
ApplicationStoppedException
This is thrown when a request is made to a stopped application
CacheMap
ColorQuantizer
CommandlineRunner
Helma command line runner class.
CompiledOrInterpretedModuleScriptProvider
Provides module scripts without compiling, should compiling not be possible for whatever reason.
ConcurrencyException
Thrown when more than one thrad tries to modify a Node.
ConfigurationException
CookieTrans
Cookie Transmitter.
CopyOnWriteMap
A Map that wraps another map and creates a new copy of the wrapped map if we try to modify it.
CronJob
A cron entry, derived from Protomatter's CronEntry class.
Crypt
CryptResource
This file authenticates against a passwd source
DatabaseException
Thrown on any kind of Database-Error
DatabaseObject
A Database object, representing a connection to a JDBC Driver
DatabaseObject.RowSet
A RowSet object
DbColumn
A class that encapsulates the Column name and data type of a column in a relational table.
DbKey
This is the internal representation of a database key.
DbMapping
A DbMapping describes how a certain type of Nodes is to mapped to a relational database table.
DbSource
This class describes a releational data source (URL, driver, user and password).
DemoExtension
a demo extension implementation, to activate this add `extensions = helma.extensions.demo.DemoExtensions` to your `server.properties`.
Diff
Compares two lists, returning a list of the additions, changes, and deletions between them.
Diff.Change
A legacy adapter that is compatible to the interface of the old GPL licenced Diff.
DiffusionFilterOp
EmbeddedServletClient
Servlet client that runs a Helma application for the embedded web server
EmptyEnumeration
Utility class for empty enum
FileLogger
An extended Logger that writes to a file and rotates files each midnight.
FileObject
An EcmaScript FileIO 'File' object
FileRepository
Repository implementation for directories providing file resources
FileResource
FrameworkException
The basic exception class used to tell when certain things go wrong in evaluation of requests.
FtpObject
A FTP-client object that allows to do some FTP from HOP applications.
FutureResult
A handle for an asynchronous request execution.
GIFEncoder
GIFImageWriteParam
GIFImageWriter
GIFImageWriterSpi
GlobalObject
Helma global object defines a number of custom global functions.
HacHspConverter
Support for .hac (action) and .hsp (template) files
HelmaDebugger
HelmaExtension
Helma extensions have to subclass this.
HelmaSecurityManager
Liberal security manager for Helma system that makes sure application code is not allowed to exit the VM and set a security manager.
HelmaShutdownHook
ShutdownHook that shuts down all running Helma applications on exit.
HopObject
HopObjectCtor
HtmlEncoder
This is a utility class to encode special characters and do formatting for HTML output.
IDatabase
Interface that is implemented by Database wrappers
IDGenerator
An interface for objects that generate IDs (Strings) that are unique for a specific type.
ImageFilterOp
ImageGenerator
Factory class for generating Image objects from various sources.
ImageInfo
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).
ImageIOGenerator
A wrapper for an image that uses the ImageIO Framework.
ImageObject
Extension to provide Helma with Image processing features.
ImageWaiter
The ImageWaiter will only be used like this: image = ImageWaiter.waitForImage(image);
ImageWrapper
Abstract base class for Image Wrappers.
InetAddressFilter
A class for paranoid servers to filter IP addresses.
INode
Interface that all Nodes implement.
INodeState
Interface that defines states of nodes
IPathElement
Interface that objects need to implement to build a Helma URL tree.
IProperty
Interface that is implemented by node properties.
IRemoteApp
RMI interface for an application.
ITransaction
This interface is kept for databases that are able to run transactions.
JavaObject
JettyServer
JSAdapter
JSAdapter is java.lang.reflect.Proxy equivalent for JavaScript.
JSONModuleSource
Key
This is the interface for the internal representation of an object key.
Logger
A simple logger that writes to a PrintStream such as System.out.
Logging
Implementation of Jakarta Commons LogFactory that supports both simple console logging and logging to files that are rotated and gzipped each night.
Logo
class with byte data of helma logo
MailObject
A JavaScript wrapper around a JavaMail message class to send mail via SMTP from Helma
MapWrapper
A class that wraps a Java Map as a native JavaScript object.
MarkdownProcessor
MimePart
This represents a MIME part of a HTTP file upload
MimePartDataSource
Makes MimeParts usable as Datasources in the Java Activation Framework (JAF)
MultiFileRepository
Repository implementation that provides all of its subdirectories as top-level FileRepositories
MultiKey
This is the internal representation of a database key with multiple columns.
Node
An implementation of INode that can be stored in the internal database or an external relational database.
NodeChangeListener
NodeEvent
This is passed to NodeListeners when a node is modified.
NodeHandle
This class is a handle or reference to a Node.
NodeManager
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.
NodeModulesProvider
Bridges the gap between CommonJS-style module loading and Node.js-style module loading.
NotFoundException
The basic exception class used to tell when certain things go wrong in evaluation of requests.
ObjectCache
Interface Helma object cache classes need to implement.
ObjectNotFoundException
Thrown when an object could not found in the database where it was expected.
ParanoidServerSocket
A server socket that can allow connections to only a few selected hosts.
ParentInfo
This class describes a parent relation between releational nodes.
PathWrapper
This class wraps around instances of helma.framework.core.RequestPath and exposes them in an array-like fashion to the JavaScript runtime.
Profiler
Property
A property implementation for Nodes stored inside a database.
PropertyRecorder
An interface that allows us to keep track of changed properties in JavaScript objects.
Prototype
The Prototype class represents Script prototypes/type defined in a Helma application.
RedirectException
RedirectException is thrown internally when a response is redirected to a new URL.
Relation
This describes how a property of a persistent Object is stored in a relational database table.
Repository
Repository represents an abstract container of resources (e.g.
RequestBean
RequestEvaluator
This class does the work for incoming requests.
RequestPath
Represents a URI request path that has been resolved to an object path.
RequestTrans
A Transmitter for a request from the servlet client.
Resource
Resource represents a pointer to some kind of information (code, skin, ...) from which the content can be fetched
ResourceComparator
Sorts resources according to the order of their repositories
ResourceProperties
A property dictionary that is updated from property resources
ResourceTracker
A utility class that allows Resource consumers to track changes on resources.
ResponseBean
ResponseTrans
A Transmitter for a response to the servlet client.
RhinoCore
This is the implementation of ScriptingEnvironment for the Mozilla Rhino EcmaScript interpreter.
RhinoEngine
This is the implementation of ScriptingEnvironment for the Mozilla Rhino EcmaScript interpreter.
ScriptingEngine
This is the interface that must be implemented to make a scripting environment usable by the Helma application server.
ScriptingException
The base class for wrapped exceptions thrown by invocation of the scripting engine.
SegmentedSubnodeList
SerializationProxy
Serialization proxy/placeholder interface.
Server
Helma server main class.
ServerConfig
Utility class for server config
Session
This represents a session currently using the Hop application.
SessionBean
The SessionBean wraps a `Session` object and exposes it to the scripting framework.
SessionManager
SimplePathElement
This is an example implementation for the helma.framework.IPathElement interface.
SingleFileRepository
Skin
This represents a Helma skin, i.e.
SkinManager
Manages skins for a Helma application
StandaloneServletClient
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.
StringUtils
Utility class for String manipulation.
SubnodeList
Container implementation for subnode collections.
SyntheticKey
This is the internal key for an object that is not - or not directly - fetched from a db, but derived from another object.
SystemMap
Map class used internally by Helma.
SystemProperties
A property dictionary that is updated from a property file each time the file is modified.
TimeoutException
TimeoutException is thrown by the request evaluator when a request could not be serviced within the timeout period specified for an application.
Timer
Utility class for timing a series of events
Tracer
Transactor
A subclass of thread that keeps track of changed nodes and triggers changes in the database when a transaction is commited.
TransientNode
A transient implementation of INode.
TransientProperty
A property implementation for Nodes stored inside a database.
TypeManager
The type manager periodically checks the prototype definitions for its applications and updates the evaluators if anything has changed.
UploadStatus
UrlEncoded
A proxy to java.net.URLEncoder which only encodes when there is actual work to do.
WeakCacheMap
A CacheMap subclass that uses WeakHashMaps internally for its rotating tables.
WrappedMap
A Map that wraps another map.
WrappedNodeManager
A wrapper around NodeManager that catches most Exceptions, or rethrows them as RuntimeExceptions.
XmlConstants
XmlConverter
XmlDatabase
A simple XML-database
XmlDatabaseReader
XmlIDGenerator
XmlObject
This class provides methods for converting HopObjects to XML and back.
XmlReader
XmlRpcObject
An extension to transparently call and serve XML-RPC from Rhino.
XmlUtil
XmlUtils
XmlWriter
ZipRepository
ZipResource