All Classes

Class	Description
About	Get information, such as the name, version and authors, about a plugin.
AboutBean	An implementation of the About interface, which complements all getter methods with setter methods.
AboutImpl	A simple implementation of the About interface.
AbsConverter	Convert Abs function to a Query API Expression.
AbsExpression	Calculate the absolute value of an expression: abs(e).
AbsoluteProgressReporter	This is interface is an extension to the ProgressReporter interface.
AbstractAnalysisPlugin	This is a base class that is useful for all analysis type plugins.
AbstractBatcher	This is an abstract class for batchers that are connected to a single DbControl object.
AbstractBioAssaySetExporter	An abstract superclass for all exporters that exports spot data from a bioassay set.
AbstractCustomRequestHandler	Abstract base class for custom request handler implementations.
AbstractDataWriterFactory<T>	Abstract implementation of a data writer factory.
AbstractDbEngine	An abstract superclass with default implementations for most DbEngine methods.
AbstractEntityQuery	An abstract implementation of the EntityQuery interface.
AbstractExporterPlugin	An abstract base class for all exporter plugins that wish to implement the ImmediateDownloadExporter interface.
AbstractFieldConverter	Abstract helper class for implementing ExportableFieldConverter.
AbstractFilenameGenerator<T>	Abstract superclass for file names generator implementions that will help with ensuring that a generator creates unique file names.
AbstractFileUnpacker	This is a base class for all plugins that wants to implement the FileUnpacker interface.
AbstractFlatFileImporter	An abstract base class for all importers that imports data from one or more flat files.
AbstractHqlQuery	An abstract implementation of the HqlQuery interface.
AbstractIOSupport	Abstract base class that is useful for plug-ins that need to implement the IOSupport interface and don't want to be visible as standalone plug-ins.
AbstractItemImporter<I extends BasicItem>	An abstract base class for plug-ins that import items in batch.
AbstractJepConversionFunction<T>	Abstract superclass implementing the JepConversionFunction interface.
AbstractJspActionFactory<A extends Action>	An abstract base class for action factories that may need to support adding scripts and stylesheets to the rendered JSP page.
AbstractJspFactory	An abstract BASE class for action and renderer factories.
AbstractJspRendererFactory<A extends Action>	An abstract base class for action factories that may need to support adding scripts and stylesheets to the rendered JSP page.
AbstractListColumnBean<I,V>	A simple bean-like implementation of the ListColumn interface.
AbstractNodeLoader<I>	Abstract node loader implementation that does nothing/throws an exception.
AbstractOnSaveAction	Abstract base implementation of the OnSaveAction interface.
AbstractPlugin	This is an abstract base class useful for developing plugins.
AbstractQuery	An abstract implementation of the Query interface.
AbstractQueryCache	Abstract base class used to cache queries for a session.
AbstractRenderer<A extends Action>	Abstract class that provides a default implementation of the deprecated AbstractRenderer.render(Action) method.
AbstractResultList<I>	This is a list of the result from a query.
AbstractResultWriter	Abstract base implementation of a result writer that simply store the result set, writer, etc. that are needed later.
AbstractSignalHandler	An abstract base class for signal handler implementations.
AbstractSignalReceiver	Abstract base class that is useful when implementing signal receivers.
AbstractSignalTransporter	Abstract base class that is useful when implementing signal transporters.
AbstractSourceItemTransformer	Abstract base class for source item transformers that can be useful for implementing some common functionality.
AbstractSourceItemTransformerFactory	Abstract base class for source item transformer factories that can be useful for implementing some common functionality.
AbstractSqlQuery	An abstract implementation of the SqlQuery interface.
Accept	Return result from the ValidationAction.acceptFile(net.sf.basedb.core.FileSetMember) method.
AccessControlled	This interface should be implemented by a class representing items which requires the logged in user to have permission to access them.
AccountExpiredException	This exception is thrown if you try to log in with an account that has expired.
Action	An action is an object that is added to an ExtensionPoint by an Extension.
ActionClassEventFilter	Event filter that only passes on events to extension points with a given action class.
ActionFactory<A extends Action>	An action factory is an object which knows how to create Action:s.
ActionIterator<A extends Action>	Iterator for iterating over all actions that will be created by extensions after a call to Registry.useExtensions(ClientContext, ExtensionsFilter, String...).
AdaptiveNumberFormatter	Formats a number for output on a web page adapting thwe number of decimals depending on the order of magnitude of the value.
AddAllTransformer<I>	Collection transformer implementation that adds all elements in the source collection to the destination collection.
AddConverter	Convert Add function to a Query API Expression.
AddExpression	Add two expressions: e1 + e2.
AdvancedFieldConverter	Field converter implementation that gives more detailed control how fields are converted and used in the export.
AffymetrixUtil	Utility class with Affymetrix-related functionality.
Agent	This is the actual job agent application.
AgentController	This is the command line controller class for the job agent application.
AgentSignalReceiver	Signal receiver implementation for job agents that is compatible with the SocketSignalReceiver.
Aggregations	A factory class to create aggregate expressions.
AllEventsFilter	Event filter that passes all events.
AllOfFilter<T>	A filter implementation that accpets an object if all parent filters accepts it.
AllowAnyHostNameVerifyer	A simple implementation of a host name verifyer that allows all hosts.
AlreadyLoggedInException	This exception is thrown if you try to log in but are already logged in.
AnalysisFilterPlugin	This is a tagging interface that should be used by all analysis plug-ins that are filtering data only.
AndConverter	Convert the '&&' operator to a Query API Restriction.
AndRestriction	Combine one or more restrictions with AND: r[0] AND r[1] AND ...
Annotatable	This interface is implemented by all items which can be annotated.
AnnotatableData	An annotatable item is an item that can be annotated with name/value pairs.
AnnotatableProxy	This interface is implemented by items that can be used to hold annotations that are intended for other items.
AnnotatedData	This class extends the CommonData class and implements the AnnotatableData interface.
AnnotatedItem	This is a helper class for items that need to implement the Annotatable interface.
Annotation	This class represents an annotation.
Annotation.QueryRuntimeFilterImpl
Annotation.Source	The annotation source.
AnnotationAssayField	Assay field implementation that exports the annotations of a bioassay.
AnnotationBatcher	Batcher implementation for adding, updating and removing multiple annotations to a large number of items in a single transaction while keeping the memory usage as low as possible.
AnnotationBatcher.Change	A flag indicating what type of change that was made to an annotation as a result of calling AnnotationBatcher.setValues(AnnotationType, List, Unit, boolean)
AnnotationBatcher.CurrentAnnotationInfo	Holds information about an annotation for the current item.
AnnotationBatcher.InsertBatcher	Batcher implementation for inserting into tables.
AnnotationBatcher.UpdateBatcher	Batcher implementation for updating and deleting from tables.
AnnotationBetweenRestriction	Restricts a query using annotation values between a low and high value.
AnnotationData	This class holds information about an annotation
AnnotationExpression	An expression representing the value of an annotation.
AnnotationFilter	Filter implementation that finds the annotation snapshot for a given annotation.
AnnotationFlatFileImporter	Plug-in for importing annotations from simple text files.
AnnotationFlatFileImporter.AnnotationValue
AnnotationFlatFileImporter.NewAnnotations	Internal cache for storing annotation values from the file for a single item.
AnnotationIdMethod	Identification method implementation that can use an annotation for identifying items.
AnnotationInRestriction	Restricts a query using annotation values that exists in a set of given values.
AnnotationJoin	Join annotations values to the query.
AnnotationLink	Class for mapping the "Annotations" table with shortcuts to all 'FooValues' tables.
AnnotationLoader	Node loader implementation for annotations.
AnnotationLoaderUtil	Utility implementation for simple loading of primary annotations via SnapshotManager.
AnnotationLogger	Logger for annotations that logs changes as updates to the parent item the annotations belong to.
AnnotationModel	A model container for BFS annotation files.
AnnotationNameGenerator	Since an Annotation isn't Nameable we construct the name from the name of the annotation type, or from the value type if we are not allowed to access the annotation type.
AnnotationParser	Parser implementation that parses a BFS annotation files.
AnnotationRestriction	Base class for creating restrictions based on annotations.
AnnotationRestriction.Options	Options that specify which annotations to consider when searching.
Annotations	A factory class to create restrictions based on annotation values.
AnnotationSet	An annotation set is the container for all annotations on an item.
AnnotationSet.ProjectSpecificAnnotationsRestriction	Restriction for matching project-specific annotations against the currently active project.
AnnotationSet.QueryRuntimeFilterImpl
AnnotationSetData	This class holds information about a set of annotations.
AnnotationSetLogger	Logger for annotations sets that detects and logs changes to inherited anntations as updates to the parent item that are inheriting the annotations.
AnnotationSetSnapshot	A snapshot of an annotation set that is used to store information as a file.
AnnotationSetSnapshot.SortByProjectComparator	Comparator for sorting annotation snapshots so that project-specific annotations appear before default annotations.
AnnotationSetterPlugin	This is a interface that should be implemented by plug-ins that are setting annotations on items thy create or work with.
AnnotationSimpleRestriction	Restricts a query using annotation values with a simple expression: annotation operator value.
AnnotationSnapshot	Stores information about a single primary or inherited annotation or an inherited annotation set.
AnnotationSnapshot.AnnotationTypeComparator	Comparator implementation for sorting snapshots by name of annotation type.
AnnotationSnapshot.ProjectComparator	Comparator implementation for sorting snapshots by name of project.
AnnotationType	Objects of this class defines an annotation type.
AnnotationType.RemoveInheritedAnnotationsAction
AnnotationTypeCategory	Objects of this class defines an annotation type category.
AnnotationTypeCategoryData	This data layer class holds information about annotation type categories.
AnnotationTypeData	This class holds information about an annotation type.
AnnotationTypeEnumerationLoader	Data loader implementation for loading the enumeration values collection of an annotation type.
AnnotationTypeFilter	Filter implementation that finds all annotation snapshots for a given annotation type.
AnnotationTypeImporter	Plug-in for importing annotation type items in a batch.
AnnotationTypeItemTypesLoader	Data loader implementation for loading the item types collection of an annotation type.
AnnotationUtil	Some utility functions for annotations.
AnnotationUtil	Utility class for working with annotations.
AnnotationUtil.AnnotatableWrapper	This wrapper class is needed because we need to keep track of extracts linked with raw bioassays and derived bioassays until we have loaded the Extracts of a Physical Bioassay.
AnnotationUtil.Cache
AnnotationValidator	Validator implementation for annotations.
AnnotationWriter
AnyLinkColumn	A column action implementation that finds an item linked with a any-to-any link.
AnyLinkColumnActionFactory	Action factory for adding columns to a table that display items that are linked with an any-to-any link.
AnyToAny	An any-to-any link is a named, directed link from one item to another item.
AnyToAny.FastLinkLoader<S extends BasicItem,T extends BasicItem>	Helper class for faster loading of any-to-any links between items.
AnyToAnyData	Represents a link from one item to any other item.
AnyToAnyDataLoader	Data loader implementation that load any-to-any links.
AnyToAnyImporter	Plug-in for importing any-to-any links from simple text files.
AnyToAnyLinkStatistics	Class for holding statisics about any-to-any links between items.
AnyToAnyLinkStatistics.Options	Options to specify how the statistics should be generated.
AnyToAnyLoader	Node loader implementation for any-to-any links.
AnyToAnyLogger	Logger for any-to-any links that logs changes as updates to the 'from' item.
AnyToAnyNameGenerator	Name generator for any-to-any links.
AnyToAnyRestriction	Expression that can be used to filter on the existence or non-existence of a named any-to-any link.
AnyToAnyValidator	Validator implementation for any-to-any links.
Application	This class represents the BASE application and is the starting point for all client applications.
Application.DbCleaner
Application.Pinger	A Pinger is an object that is used to protect another object from timing out by automatically pinging it.
Application.SessionControlCacheCleaner
Application.StartupOptions	Startup optins when starting the BASE application.
ArrayBatch	This class represents the making of a new batch of microarray slides of a particular design.
ArrayBatchData	This class represents the making of a new batch of microarray slides of a particular design.
ArrayBatchImporter	Plug-in for importing array batch items in a batch.
ArrayBatchLoader	Node loader implementation for array batches.
ArrayBatchValidator	Validator implementation for array batch.
ArrayDesign	An array design is a description of the design of a microarray slide.
ArrayDesignBlock
ArrayDesignBlockData	This holds information about a block in an arraydesign.
ArrayDesignData	This class holds information about an arrayDesign
ArrayDesignImporter	Plug-in for importing array design items in a batch.
ArrayDesignLoader	Node loader implementation for array designs.
ArrayDesignPlate
ArrayDesignPlateData	This class connects the ArrayDesign with its plates and adding an index to that connection.
ArrayDesignValidator	Validator implementation for array designs.
ArrayIterator<E>	This class implements the Iterator interface for an array of objects.
ArraySlide	This class represents a physical microarray slide.
ArraySlideData	This class represents a phycsical microarray slide.
ArraySlideImporter	Plug-in for importing array slide items in a batch.
ArraySlideLoader	Node loader implementation for array slides.
ArraySlideValidator	Validator implementation for array slides.
AscOrder	Sort the result of a query in ascending order by the expression.
AssayField	Represents a bioassay field that is going to be exported.
AssayPropertyField	Assay field implementation that exports a named property from a bioassay.
ASTConstantConverter	Converts a constant node to an expression.
ASTFunNodeConverter	Converts a function node to an expression or restriction.
ASTVarNodeConverter	Converts a variable node to a parameter expression or null.
AuthenticatedUser	Objects of this class are returned by the AuthenticationManager.authenticate() method and contains information about the authenticated user.
AuthenticationContext	Gives authentication implementations limited access to the database.
AuthenticationException	This exception can be thrown when an error occurs during the authentication.
AuthenticationManager	Action interface for external authentication.
AuthenticationMethod	Holds information about the method that was used to verify a user when logging in.
AutoChildNodeLoader<I>	Node loader implementation that automatically loads child nodes.
AutoDetectFileFormat	This class has methods for autodetecting file formats.
AutoDetectFileFormat.IsImportableFilter	Filter implementation that filters a collection of ContextUtil.ContextResult:s by checking each plug-ins ability to import a given file.
AutoDetectingImporter	This interface should be implemented by an import plugin that supports auto-detection of the file format.
AutoFormatter	Excel formatter implementation that automatically selects a format depending on the type/class of the value.
AutoItemExportFormatter	Formatter implementation designed for exporting that generates output with best supported method depending on their type.
AutoJoiner<Q extends Query,E extends QueryElement>	An AutoJoiner is an object that automatically joins other tables in query depending on other query elements.
AutoLinkFormatter	Formatter implementation that generates a HTML output trying to link items with best supported method depending on their type.
Base	This class is used to collect some useful methods for the web client into a single place.
Base1FieldConverter	Exportable field converter that support BASE 1 naming conventions.
Base1PluginExecuter	This plug-in executes a plug-in from the Base1 system.
Base1PluginExecuter.Base1JobParameterType
BaseException	This is the base class for exceptions in BASE.
BaseFileExporter	A superclass for exporters that exports spot data to BASEfile format.
BaseFileExporterPlugin	Exports bioassay set data as serial or matrix BASEfile:s.
BaseFileExporterPlugin.ExtendedDynamicField
BaseFileExporterSupport	Exporter implementation for the external program executor that exports data to BASEfile format.
BaseFileImporter	Imports spot data from a serial or matrix BASEfile.
BaseFileImporter.RawDataProxy
BaseFileImporter.ReporterProxy
BaseFileImporterSupport	Importer implementation for the external program executor that imports data from BASEfile format.
BaseFileInfo	Collects information about a BASEfile as it gets parsed by a BaseFileImporter.
BaseFileInfo.ChildBioAssay	Keeps information about a new child bioassay from the 'assays' section or 'spot' sections.
BaseFileInfo.SpotSectionInfo	Keeps information about headers and more in a 'spot' section.
BaseFileParser	Parser for serial and matrix BASEfile:s.
BaseFileSectionParser	A section parser is responsible for parsing and collecting data that is found in a section in a serial or matrix BASEfile.
BaseFileWrapper	File wrapper implementation for files that are located on the BASE file system.
BaseFileWriter	Wraps a writer stream and provides methods for easier creation of BASEfiles.
BaseInputStreamLocator	Input stream locator implementation that works with files within a given directory in the BASE file system.
BasicBatcher<D extends BatchableData>	This is an abstract class for batching functionallity.
BasicChildItem	An abstract base class for all items which are child items to a BasicItem parent item.
BasicData	This is the root superclass of all data classes.
BasicItem	This is the root superclass of all item classes.
BasicItemFilter	A filter implementation that matches against the item that is attached to nodes.
BasicItemNodeLoader<I extends BasicItem>	Abstract class that is useful for all node loaders that works with BasicItem:s.
BasicItemNodeLoaderFactory	Node loader factory implementation for BasicItem node loaders.
BasicItemNodeValidatorFactory	Node validator factory implementation for BasicItem node validators.
BasicItemToIdTransformer	Collection transformer implementation that extracts the ID from BasicItem:s.
BasicNodeValidator<I>	A simple node validation implementation that takes care of missing and denied access to items.
BatchableData	This is a tagging interface only.
BatchedPropertyInfo	Holds information about a batchable property.
Batcher	The basic interface which all batchers must implement.
BatchUtil	Utility class for batching information.
BCrypt	BCrypt implements OpenBSD-style Blowfish password hashing using the scheme described in "A Future-Adaptable Password Scheme" by Niels Provos and David Mazieres.
BeanActionFactory	Generic action factory class that can generate instances of actions if there exists a bean-like implementation of the action class.
BetweenRestriction	Compare if one expression falls between to other expressions: e BETWEEN low AND high.
BfsExporter	Base class for exporting spotdata to BFS format.
BfsExporterPlugin	Exports bioassay set data to BFS format.
BfsExporterPlugin.ExtendedExportableField
BfsExporterSupport	Exporter implementation for the external program executor that exports data to BFS format.
BfsImporter	Imports spot data from a serial or matrix BFS.
BfsImporter.ProgressEventHandler
BfsImporterSupport	Importer implementation for the external program executor that imports data from BFS format.
BfsParser	Interface that it is recommended that all BFS parsers should implement.
BioAssay	Represents the current intensities of raw data after some transformation has been applied to it.
BioAssayData	This class holds information about a bioassay.
BioAssayExperimentalFactorLoader	Data loader that gets annotation values for a bioassay including those that are present on the parent raw bioassay(s) without being directly inherited by the bioassay.
BioAssaySet	A bioassayset represents the current intensities of the raw data after some Transformation has been applied to it.
BioAssaySetData	This class holds information about a bioassayset.
BioAssaySetFilterUtil	This is a utility class for plugins that filters bioassay set data.
BioAssaySetUtil	This is a utility class for BioAssaySet.
BioMaterial	This is the base class for for the three types of biomaterials: BioSource, Sample and Extract.
BioMaterialData	This class is the root class for biomaterials.
BioMaterialEvent	This class represents an event in the life of a MeasuredBioMaterial.
BioMaterialEvent.Type	The type of the event.
BioMaterialEventData	This class is used to register events for measured biomaterials.
BioMaterialEventLogger	Logger for biomaterial events that logs UPDATE:s to CREATION and HYBRIDIZATION events as updates to their parent biomaterial/hybridization.
BioMaterialEventSource	Class for holding information about a parent biomaterial that was used in an event that created a child biomaterial or a physical bioassay.
BioMaterialEventSource.BioMaterialEventSourceTransformer
BioMaterialEventSourceData	Data class for holding information about a parent biomaterial that was used in an event that created a child biomaterial or a physical bioassay.
BioMaterialEventSourceFormatter	Formatter to handle BioMaterialEventSource items.
BioPlate	This class is represents physical bio-plates.
BioPlateData	This class holds information about a bioplate
BioPlateEvent	A bioplate event represents something that happened simultaneously to the biomaterial on one or more bioplates.
BioPlateEventData	This class holds information about a bioplate event.
BioPlateEventLoader	Node loader implementation for bioplate events.
BioPlateEventParticipant	Holds information about a bioplate that is participating in a bioplate event.
BioPlateEventParticipantData	Registers a plate as a participant in a bioplate event.
BioPlateEventType	The type of a bioplate event defines what happened in the event.
BioPlateEventTypeData	Each bioplate event must have a type that defines what happened.
BioPlateImporter	Plug-in for importing bioplate items in a batch.
BioPlateLoader	Node loader implementation for bioplates.
BioPlateNameGenerator	Name generator implementation for BioPlate items.
BioPlateType	This class represents the type of a bio-plate.
BioPlateTypeData	This class holds information about a biomaterial plate type.
BioPlateValidator	Validator implementation for bioplates.
BioSource	This class represent biosource items.
BioSourceData	This represents a biosoruce which is the starting point of all biomaterials.
BioSourceImporter	Plug-in for importing biosource items in a batch.
BioSourceLoader	Node loader implementation for biosources.
BioSourceToSampleTransformer	Source item transformer that transform biosource items to their child samples.
BioSourceValidator	Validator implementation for biosources.
BioWell	A biowell is located on a BioPlate and contains a MeasuredBioMaterial.
BioWell.LockMode	The lock mode for a well is determined by the plate's bio plate type.
BioWellData	This class holds information about a bio well on a bio plate.
BioWellLoader	Node loader implementation that load biomaterial on a bioplate.
BioWellNameGenerator	Name generator implementation for biomaterial items that are located on a biowell.
BlockInfo	A BlockInfo object is used to represent the uniqe identifiers of an ArrayDesignBlock.
Body	This tag defines the body section of a page.
BooleanExpression	A constant boolean expression.
BooleanFormatter	Formats a boolean value.
BooleanFormatter.Type	Enum for holding the various types of boolean output.
BooleanParameterType	This class represent a parameter type that is a boolean.
BooleanParameterValueData	Boolean parameter value.
BooleanWriter	Database-independent writer implementation that writes boolean values from a result set.
Bundle	Declare the names of resource bundles used by the web client.
Button	This tag is used to display a clickable button.
Button	This tag creates a button on a toolbar.
ButtonAction	Actions represented as buttons in a toolbar.
ButtonBean	A simple bean-like implementation of the ButtonAction interface.
ButtonGroup	This tag is used to group buttons together (horizontally) and make them all have the same size.
ByteArrayWriter	Generic writer implementation that writes byte-array values from a result set.
Bzip2FilePacker	This class wraps the TarFilePacker in a BZIP2 stream, creating a tar.bz2 file.
Bzip2FileUnpacker	A plugin for unpacking a bzip2 compressed file to the BASE file system.
CacheControlFilter	This is a filter that sets the "Cache-Control" header in the http response.
CalendarButton	A special button tag that is used to display a "Calendar" button that opens a popup for selecting a date and time.
CaseExpression	An SQL case expression:
CdfFileReporterImporter	This plug-in can import probesets from Affymetrix CDF files as reporters.
CdfValidationAction	Action for validation of CDF files in a file set.
CdfValidationFactory	Action factory for creating CDF file validators.
CdfValidator	Helper class for working with Affymetrix CDF files.
Cell	This tag defines a new cell in a row.
CellStyleCreator	Helper class for keeping track of formatting styles that has been created for given Excel worksheet.
CellValue	This tag adds a value to a cell in a row.
CelValidationAction	Action for validation of CEL files in a file set.
CelValidationFactory	Action factory for creating CEL file validators.
CelValidator	Helper class for working with Affymetrix CEL files.
ChainedProgressReporter	An implementation of the ProgressReporter interface that chains to another progress reporter while recalculating the percentage values.
ChangeHistory
ChangeHistory.TransactionInfo	Holds information about a single transaction.
ChangeHistoryData	Represents the changes made in a single transaction.
ChangeHistoryDetailData	Represents a change (creation/update/deletion) made to a single entity in a transaction.
ChangeHistoryDetailLoader	Data loader implementation for old and new values in the change history which are protected by special permissions.
ChangeHistoryItemLoader	Data loader implementation for loading the changed item.
ChangeHistoryUtil	Utility class for working with change history.
ChangeType	Enumeration that represents the type of change that has happened.
ChangeTypeFormatter	Formatter implementation that converts an integer into it's ChangeType representation and the uses name() as the formatted value.
ChannelFunction	A JEP function class that adds a ch(int) function to a JEP expression parser.
CharacterEncodingFilter	This is a filter that sets the character encoding for both the request and the response.
CharsetDetector	Utility class for testing if a text stream can be parsed using a given character set.
CharsetUtil	Helper class for working with charsets and enabling the UTF-8 with fallback charsets: X-UTF-8_with_ISO-8859-1_fallback X-UTF-8_with_windows-1252_fallback
ChildItem	An abstract base class for all items which are child items to a Shareable parent item.
ChildNodeDirection	Represents the direction to use for loading child nodes in a tree.
ChildNodeLoaderAction	Load and create child nodes for a given parent node.
ClassLocal<E>	This class is a similar to the JDK ThreadLocal class, but stores one object per class instead of one object per thread.
ClassMapErrorHandler	Error handler that allows the registration of one or more error handler for subclasses to Throwable.
ClassUtil	Utility class for Class objects.
Client	This class represents a registered client application.
ClientContext	Keeps information about the current context in the client application that extensions can use to decide what actions to generate.
ClientData	This class holds information about a client.
ClientDefaultSetting	This class is used to represent a setting for specific client application.
ClientDefaultSettingData
ClonableProperty	Represents a reporter property that can be cloned to a per-experiment table in the dynamic database.
ClonableReporterQuery	An interface that indicates that a query may be used together with cloned reporter information.
CloneReportersPlugin	A plug-in that clone reporter annotations to an experiment.
CloseResourceInputStream	Inputstream filter that closes a given resource whenever the parent input stream is closed.
CmdLine	Utility class for parsing command line arguments.
ColFunction	Adds a col() function to Jep.
CollectedExtractsToDerivedBioAssayTransformer	Source item transformer implementation that transform collected extract items to derived bioassays.
CollectedExtractsToRawBioAssayTransformer	Source item transformer implementation that transform collected extract items to raw bioassays.
CollectExtracts	Collect extracts seen on derived bioassays and raw bioassays that has been loaded by other transformers.
CollectionFormatter<I>	Formatter implementation that formats a collection of values to a string by concatenating the values with a given separator.
CollectionTransformer<S,D>	Allows a collection to be transformed by applying some operation to it.
ColorFormatter	Formatter that adds a small colored box next to a value.
ColorGenerator	This class is used to generate colors for numerical values.
Coloring	This class keeps coloring information for items which can be colored when values are displayed in a client application.
ColoringData	Hold coloring information.
ColumnDef	This tag defines a column in the table.
ColumnDef.NullIterator<A,B>	Iterator implementation that returns a single null value and nothing more.
ColumnHeaders	Generate column headers for the columns that has been defined for this table.
ColumnMapper	Returns the string found in the column given by the index set in the constructor.
ColumnSubtitles	Generate column subtitle header for the columns that has been defined for this table.
CombiningEventFilter	Event filter that only passes on events based on multiple other event filters.
CommonData	This is a convenience class that extends the SharedData class and implements the NameableData and RemovableData interfaces.
CommonItem
CompactButtonRenderer	A compact renderer for toolbar button actions, which only only displays the icon.
CompactButtonRendererFactory	Factory that create CompactButtonRenderer objects for rendering ButtonAction:s.
ComparableComparator<T extends Comparable<T>>	A comparator implemenation for any Comparable objects.
CompileAll	This servlet will scan for all files ending with .jsp and issue a request for them with the parameter jsp_precompile=true therby compiling all JSP files into servlets.
ComponentData	Tagging interface that we need all componenets to implement so that we are able to export them properly using generic code.
CompoundMapper	A compound mapper that gets its value by invoking multiple other mappers which are set in the constructor.
ConditionalQueryElement
Config	Use this class to access the configuration settings for BASE.
ConfigurationException	This exception is thrown by the Config class if there is a problem with finding or loading the configuration settings.
ConfigureByExample	This is a tagging interface for all plugins that use the FlatFileParser and wants easier configuration of the regular expressions used to parse the file.
ConnectionClosedException	This exception is thrown when trying to use a DbControl object that has been closed.
ConnectionManager	A connection manager is used to access the contents and metadata about the resource pointed to by a given URI.
ConnectionManagerFactory	A connection manager factory is responsible for creating connection managers for some subset of URI:s that is supported.
ConnectionManagerUtil	Collects utility methods related to connection managers.
ConnectionParameters	Connection parameters, such as username/password, that may be needed to connect to a server.
ConsoleProgressReporter	An implementation of the ProgressReporter interface that writes all messages to the standard console.
ConstantMapper	A constant string mapper.
ContentSecurityPolicyFilter	This is a filter that sets the "Content-Security-Policy" header in the http response.
ContentSecurityPolicyReportServlet	This is a servlet for posting reports from "Content-Security-Policy" violations.
ContextData	This class holds context information to help client applications with storing common settings for tables.
ContextIndex
ContextKey
ContextUtil	A class with utility methods for plug-ins.
ContextUtil.ContextResult	Class for holding the result of a call to the InteractivePlugin.isInContext(GuiContext, Object) method.
ContextUtil.IsInContextFilter	Filter implementation that works on collections of ContextUtil.ContextResult:s and return only those that return true from ContextUtil.ContextResult.isInContext().
Controlled	This is the base tagging interface for items that needs special attention by the DbControl object when DbControl.commit() is called.
ConverterFactory	Keep JepConversionFunction objects for converting built-in JEP object to Query API Expression or Restriction objects.
Coordinate	Util class for coordinate transformations in base.
CountExpression	Count the number of values: COUNT(e)
CropStringMapper	A mapper that crops a string if it is longer than a specified length.
CustomRequestHandler	An extension to the regular request-handler interface that allows life-cycle control by the job agent.
Data	This tag begins the data section of the table.
DatabaseException	Exceptions of this type are thrown when there is an error from the database.
DataCube	A data cube is the main unit for an experiment to store analysed data.
DataCube.RawMappingQuery	Select data from Dynamic#RawParents table.
DataCubeColumn	Represents the column coordinate in a data cube.
DataCubeColumnData	This class holds information about a single column in a data cube.
DataCubeData	This class holds information about a single data cube in a virtual database.
DataCubeExtraValue	Represents a set of extra value in a data cube.
DataCubeExtraValueData	This class holds information about an extra value in a data cube.
DataCubeFilter	This represents a filter in a datacube.
DataCubeFilterData	This class holds information about a single filter in a data cube.
DataCubeLayer	This represents the layer coordinate in a data cube.
DataCubeLayerData	This class holds information about a single layer in a data cube.
DataFileFormatter	Formatter implementation for file sets that lists all member files of a given file type
DataFileLoader	Node loader implementation for data files.
DataFileType	This class is used to represent types of files that are used to hold data instead of importing the data into into the database.
DataFileTypeData	This class hols information about individual files attached to items that store data in files instead of in the database.
DataFileValidator	Validator implementation for data files.
DataLoader<T>	A helper interface for the SimpleExport to get data that in some way are associated with an item.
DataNoFunction	Adds a dataNo() function to Jep.
DataParser	Parser implementation that parses BFS data files.
DataQuery<I extends BasicData>	An implementation of the Query interface that returns data objects.
DataQueryWrapper	A query wrapper for DataQuery:s.
DataResultIterator<I extends BasicData>	Return the results of a DataQuery as an iterator.
DataWriter	Writer implementation for writing BFS data files.
DataWriterFactory<T>	Factory implementations are responsible for creating BFS data writers that accepts data for a given owner object.
DateFormatException	This exception is thrown when parsing a string into a date failed.
DateFormatter	Format a date for output in a client application.
DateParameterType	This class represent a parameter type that is a date.
DateParameterValueData	Date parameter value.
DateUtil	Utility methods that will make it easier to handle date values.
DateWriter	Generic writer implementation that writes date values from a result set.
DbControl	A DbControl object is the main object used for communicating with the database.
DbControl.SaveIf
DbControl.State	Main purpose is to write a warning to the log file in case some user code that created a DbControl instance never called the close() method before the DbControl became uncreachable.
DbEngine	Information about database-specific options that are not covered by the Hibernate Dialect objects.
DbIndexWork	A work implementation that can create, update and drop indexes on tables.
DbLogManager	Log manager implementation that logs changes to the database.
DbLogManagerFactory	Log manager factory implementationt that logs changes to the database.
DebugOnSaveActionFactory	On-save action factory that create actions that print a log message to System.out for all events.
DebugOnSaveActionFactory.DebugOnSaveAction
DefaultConfigurationValues	Provides a default configuration values for GTF file parsing when none has been provided by the user.
DefaultDbEngine	A default DbEngine that is selected if no other can be found.
DefaultEntityLogger	Default logger for all entities that has been tagged with the LoggableData interface.
DefaultFilter	A default filter implementation that enables all extensions and extension points and sorts the extensions based on the Extension.getIndex() values.
DefaultItemFunction<T extends Nameable>	JEP function that can be used to return the name of a default item in a project.
DefaultRequestHandler	This is the default request handler for incoming requests to a job agent.
DelegatingSignalHandler	A signal handler implementation that can delegate to other signal handlers, depending on which signal it receives.
DeletedFilter	Filter implementation for extension files that allow only deleted files to pass.
DeleteResourcesProcessor	A file processor implementation that removes all resources that was previously extracted from a JAR file.
DeprecationLogger	Utility class for logging use of deprecated taglib attributes.
DerivedBioAssay
DerivedBioAssay.FixDerivedBioAssayParentsRecursivelyAction	Whenever we modify the parent items to a derived bioassay, we must make sure that the physical bioassays for all child items are synchronized with the same changes.
DerivedBioAssayData
DerivedBioAssayImporter	Plug-in for importing derived bioassay items in a batch.
DerivedBioAssayLoader
DerivedBioAssayToChildDerivedBioAssayTransformer	Source item transformer implementation that transform derived bioassay items to child derived bioassays.
DerivedBioAssayToParentDerivedBioAssayTransformer	Source item transformer implementation that transform derived bioassay items to parent derived bioassays.
DerivedBioAssayToPhysicalBioAssayTransformer	Source item transformer implementation that transform derived bioassay items to physical bioassays.
DerivedBioAssayToRawBioAssayTransformer	Source item transformer implementation that transform derived bioassay items to raw bioassays.
DerivedBioAssayValidator	Validator implementation for derived bioassays.
DescOrder	Sort the result of a query in descending order by the expression.
DetachedItemException	This exception is thrown when trying to use an item that has been detached from the DbControl that manages it.
DeviceNotVerifiedException	This exception can be thrown when a user is trying to login from a device that has not been verified.
Diff3	This class is helpful when a client application needs to implement long-running transactions and still be able to update items with as few clashes as possible.
DirectionalCacheKey	Cache key implementation that bundles another cache key with a node direction.
Directory	This is used to represent directory items.
DirectoryData	This class holds information about directories.
DisabledInheritanceFilter	Filter implementation that filters away annotations that have an annotation type with inheritance disabled.
DisablePluginsProcessor	File processor implementation that disables plug-ins.
DisallowedValueException	Exception that is thrown when a value is not found among a set of allowed values, for example, when setting an annotation value.
DiskConsumable	This interface is implemented by items that can use a lot of disk space.
DiskConsumableData	A diskconsumable item is an item that occupies a lot of diskspace and should be controlled by the quota system.
DiskFileWrapper	File wrapper implementation for files that are located on the local disk.
DiskInputStreamLocator	Input stream locator implementation that works with files on the local file system.
DiskUsage	This class is used to represent the disk usage of DiskConsumable items.
DiskUsageData	This class holds information about a users and/or groups disk usage.
DiskUsageStatistics	Get disk usage statistics for the BASE server.
DivideConverter	Convert Divide function to a Query API Expression.
DivideExpression	Divide one expression by another: e1 / e2.
DoubleParameterType	This class represent a parameter type that is a double.
DoubleParameterValueData	Double parameter value.
DoubleWriter	Database-independent writer implementation that writes double values from a result set.
Download
DropDynamicTableAction	Transactional action that can drop a table from the dynamic database after a successful commit and/or rollback.
DummyJobExecutor	This is dummy job executor implementation which just sets the status of each job to Job.Status.DONE without actually executing the job.
DummyService	A dummy service implementation that prints out the current time on System.out every x seconds (default = 10) when the service is running.
DuplicateWizardException	This exception is thrown when a plug-in configuration wizard is open and the user tries to open a second one.
Dynamic	A factory class to create expressions, joins, etc. that are only used by queries in the dynamic database.
DynamicActionAttribute	Class for holding the name and value of a dynamic action attribute.
DynamicActionAttributes	Supplementary interface for actions that need to be able to support dynamic attributes that are not pre-defined by the actual Action.
DynamicActionAttributeSupport	Abstract base class intended to be extended by Action implementations that want to support dynamic action attributes.
DynamicExtraValueQuery	Represents a query for extra values in the dynamic database.
DynamicField	Represents a spot or reporter field that is going to be exported from a bioassay set.
DynamicFilter	This interface is used together with the BioAssaySetFilterUtil class to help a plugin filter the data of a bioassay set.
DynamicJoin	Represents a join between two virtual tables in a dynamic query: leftTable JOIN rightTable ON columns.
DynamicPositionQuery	Represents a query for position information against the dynamic database.
DynamicPositionQueryJoiners	This class collects AutoJoiner:s for DynamicPositionQuery queries.
DynamicPositionQueryJoiners.ExtraValueJoiner	Joiner for extra values.
DynamicPositionQueryJoiners.ReporterJoiner	Joiner for reporters
DynamicPositionQueryJoiners.ReporterListJoiner	Auto joiner for reporter lists.
DynamicQuery	Represents a query against the dynamic database.
DynamicQueryWrapper	A query wrapper for DynamicQuery:s.
DynamicRawDataQuery	Represents a query for raw data in a "dynamic" way.
DynamicRawDataQuery.RawBioAssayJoiner	Auto joiner for raw bioassays.
DynamicRawDataQuery.ReporterJoiner	Auto joiner for reporters.
DynamicRawDataQuery.ReporterListJoiner	Auto joiner for reporter lists.
DynamicReporterQuery	Represents a query for reporter data in a "dynamic" way.
DynamicReporterQuery.MasterReporterJoiner	Auto joiner for master reporter table.
DynamicReporterQuery.ReporterListJoiner	Auto joiner for reporter lists.
DynamicRestriction	Creates a restriction that compares a dynamic column with a constant value: tableAlias.column = value or queryRootAlias.column = value
DynamicResultIterator	An iterator view of the result of an AbstractSqlQuery.
DynamicSpotQuery	Represents a query for spot information in the dynamic database.
DynamicSpotQueryJoiners	This class collects AutoJoiner:s for DynamicSpotQuery queries.
DynamicSpotQueryJoiners.ExtraValueJoiner	Joiner for extra values.
DynamicSpotQueryJoiners.RawDataJoiner	Joiner for raw data.
DynamicSpotQueryJoiners.ReporterJoiner	Joiner for reporters
DynamicSpotQueryJoiners.ReporterListJoiner	Joiner for reporter lists.
DynamicUtil	This class is used to collect some useful methods for building and executing dynamic queries.
DynamicUtil.SelectedInfo
EditUtil	Utility class for handling edit-dialog related extensions.
EmailUtil	Utility class for email sending.
EncoderDecoder	Interface for encoding and decoding strings to make them work in a certain context.
EncodeUtil	Utility functions for encoding/decoding strings.
EngineFactory	Creates DbEngine objects based on the Hibernate dialect.
EnhancedThreadSignalHandler	An extension to the thread signal handler that supports any number of signals.
EntityDetails	Contains detailed information about the changes made to an entity during a transaction.
EntityLogger	Entity logger implementations are created by a LogManagerFactory when a change to a logged entity has been detected.
EntityLogOptions	This class collect some static information related to logging for entities.
EntityQuery	This a HQL query that return enitities, ie. items.
EntityQueryWrapper<R>	Wraps a hibernate query and adds checks so that unsaved items aren't added to the query as parameters.
Enumeration<K,V>
Enumeration.Entry<K,V>
EnumFormatter<T extends Enum<T>>	Formatter implementation that converts an enum constant into it's name() as the formatted value.
EqRestriction	Compare if two expressions are equal: e1 == e2, or e1 IS NULL
EqualsConverter	Convert the '==' operator to a Query API Restriction.
EqualsFilter<T>	A filter implementation that only accepts an object if it is equal (using Object.equals()) to a given object.
EqualsHelper	Helper class for implementing equals and hash code calculations in classes.
ErrorHandler	An interface to make it easier to implement dynamic error handling.
ErrorHandler<A extends Action>	Error handlers are created by the factory for each request/use of an extension point.
ErrorHandlerFactory<A extends Action>	Error handler factories are responsible for creating error handlers.
EventFilter	A filter for events before they are sent to an EventHandler.
EventHandler	Event handlers are used for reacting to various parsing events when parsing BFS files.
EventHandler	An event handler receives events about things happening to extensions and extension points.
EventType<T>	Defines an event type that is sent in event notifications to event handlers.
EventType	Represents different types of event.
EventTypeFilter	Event filter that only passes on events of a specifiec event type.
ExcelFormatter<T,E>	Interface that is intended to be implemented by formatters that also want to support generating output for excel.
ExcelValue<T>	Represents a value and style format that should be written to a cell in an excel worksheet.
ExcelValue.BlankValue<T>	Represents a blank cell.
ExcelValue.BooleanValue	Represents a cell with a numeric value.
ExcelValue.DateValue	Represents a cell with a date value.
ExcelValue.IntValue	Represents a cell with a numeric value without decimals.
ExcelValue.NumericValue	Represents a cell with a numeric value.
ExcelValue.StringValue	Represents a cell with a string value.
ExceptionCatcher	This tag is a wrapper that catches any errors in it's body and outputs the error message.
ExceptionInterruptHandler	Interrupt handler implementation that always throw a SignalException.
ExecuteUpdateWork	A JDBC work implementation that executes an update/insert/delete query and returns the number of rows that was affected by the query.
ExpConverter	Convert Exp function to a Query API Expression.
Experiment	An experiment is the starting point of the analysis in BASE.
ExperimentalFactorLoader	Node loader implementation for experimental factors.
ExperimentalFactorValidator	Validator implementation for experimental factors.
ExperimentData	Holds information about an experiment.
ExperimentExplorer	A class for storing settings and doing work related to the experiment explorer tool in the web interface.
ExperimentExplorer.AnnotationGroup	An annotation group contains statistical information about the spot values falling into the group.
ExperimentExplorer.AnnotationSummary	An annotation summary object keeps track of intensities and other statistical information based on the annotation group.
ExperimentExplorer.InExpression	Creates a list of (numerical) values that can be used as the right-hand operand to the IN operator.
ExperimentExplorer.ReporterPositions	Cache entry for a reporter with positions.
ExperimentExplorerPlotServlet	Plot servlet for generating plots from experiment explorer.
ExperimentExplorerPlotServlet.ColumnKey	Uses as a column key in the plots.
ExperimentLoader	Node loader implementation for experiments.
ExperimentValidator	Validator implementation for experiments.
ExpExpression	Calculate the exponential of an expression: exp(e).
ExportableField	Interface that represents an exportable field.
ExportableFieldConverter	Defines method for converting a string representation to an exportable assay or dynamic field that can be used with AbstractBioAssaySetExporter implementations.
ExportableFieldFactory	Utility class with factory methods that helps with the creation of exportable fields.
ExportableFieldFormatter	Formatter implementation that formats an exportable field by returning the column title.
ExportedProperty
ExportOutputStream	An output stream used for immediate download from export plugins.
ExportTemplate	A helper interface for the SimpleExport class to make it easier to output exported data in different formats.
Expression	An expression query element.
Expressions	A factory class to create expressions.
ExpressionSelect	A selection query element that selects an expression, optionally giving it an alias.
ExtendableData	This class is inherited by data classes that supports per-server additions of columns to the underlying database table.
ExtendedAbout	Adds extra information to the About interface.
ExtendedProperties	This class is used for reading XML files with information about extended properties.
ExtendedProperty	Holds information about an extended property for a class.
ExtendedPropertyAccessor	This class is used to interface with Hibernate for extended properties.
ExtendedPropertyAccessor.GetterSetter	This class implements the Hibernate Getter and Setter interfaces.
ExtendedPropertyFormatter<T>	Formatter for extended property values.
ExtendedPropertyLinker	Used to create links from extended property values.
Extension<A extends Action>	Represents a concrete implementation of an extension to an extension point.
ExtensionBean<A extends Action>	A bean-like implementation of the Extension interface.
ExtensionCells	Tag for generating content from extension columns.
ExtensionChildNodeLoader<I>	Wrapper for node loaders that automatically hooks into the extension system when loading child nodes for a parent node.
ExtensionContext<A extends Action>	Invokation context for an extension.
ExtensionEventFilter	Event filter that only passes events for a specific extension.
ExtensionKey	Key implementation used to identify extensions.
ExtensionNodeValidator<I>	Wrapper for node validators that hooks into the extension system when validating nodes.
ExtensionPoint<A extends Action>	An extension point is a place, defined by a client application, that can be extended.
ExtensionPointBean<A extends Action>	A bean-like implementation of the ExtensionPoint interface.
ExtensionPointContext<A extends Action>	Invokation context for an extension point.
ExtensionPointEventFilter	Event filter that only passes events for a specific extension point.
ExtensionPointFilter	Filter implementation that can be used to match extension points and extensions based on the ID of the extension point.
ExtensionPointKey	Key implementation used to identify extension points.
ExtensionsControl	Controller class for the extension system in the web client.
ExtensionsFile	Represents a file with extensions in it.
ExtensionsFile.WriteableExtensionsFile	An extensions file with additional methods that allows adding or modifying information in the underlying extensions file.
ExtensionsFileProcessor	Interface that is used to request a callback for each extensions file managed by an extensions manager.
ExtensionsFilter	Allows extensions and extension points to be enabled/disabled and sorted externally.
ExtensionSignalTransporter	A signal transporter implementation send all signals to extensions extending the "net.sf.basedb.core.signal" extension point.
ExtensionSignalTransporter.SendSignalRenderer
ExtensionsInvoker<A extends Action>	Object of this class handles a single invokation of the extensions for one or several extension points.
ExtensionsLog	Instances hold the log entries for a single extension.
ExtensionsLogger	A simple logger that services can use to send log message to the BASE core.
ExtensionsManager	An extensions manager is responsible for handling a group of extensions in the form of files stored in the file system.
ExtensionsManager.JarFirstURIComparator	Compare URI:s so that 'jar:' scheme always are listed first.
ExtensionsServlet	This servlet is acting as a proxy for requests to extension defined servlets.
ExtensionsUtil	Utility class collecting some useful functions related to extensions.
ExternalProgramExecutor
ExternalProgramExecutor.RequestWrapper
ExternalProgramExecutor.ResponseWrapper
Extract	This class is used to represent extract items.
ExtractData	This represents an extract.
ExtractImporter	Plug-in for importing extract items in a batch.
ExtractLoader	Node loader implementation for extracts.
ExtractNameGenerator	Name generator implementation for Extract items.
ExtractResourcesProcessor	A file processor implementation that extracts resources from JAR files.
ExtractToChildExtractTransformer	Source item transformer implementation that transform extract items to their child extract items.
ExtractToParentExtractTransformer	Source item transformer implementation that transform extract items to their parent extract items.
ExtractToPhysicalBioAssayTransformer	Source item transformer implementation that transform extract items to physical bioassays.
ExtractToSampleTransformer	Source item transformer that transform extract items to their parent samples.
ExtractValidator	Validator implementation for extracts.
ExtractValidator.TagPosition
ExtraFileImporter	Implementors are responsible for importing extra files specified in the BFS metadata file into the BASE file system.
ExtraFloatParser	Parser that is responsible for extracting extra float values from the 'spot' section in a BASEfile.
ExtraUserInformation	Class for holding extra information about a user.
ExtraValue	Represents extra values attached to a BioAssaySet.
ExtraValue.CoordinateType	Defines which coordinates in the data cube the extra values are attached to.
ExtraValueData	This represents the use of extra values that have been calculated for a bioassayset.
ExtraValueExpression	Represents the value of an extra value in a dynamic query: alias.value.
ExtraValueFunction	A JEP function class that adds a xtra(int) function to a JEP expression parser.
ExtraValueJoin	Represents a join to an extra value in a dynamic query: leftTable JOIN extraValueTable ON ...
ExtraValueType	Defines extra values that can be calculated by plugins or some other application and inserted as part of a BioAssaySet.
ExtraValueTypeData	This represents the definitiona of an extra value type that can be calculated by a plugin.
FactoryParametersKey	Key implementation used for configuration parameters for factories.
Failure	Holds information about a failed validation.
FallbackIdMethod	Identification method implementation that first tries a parent id method, and, if no item is found and the identifier is a number, tries to load the item by id.
Feature	This is a utility class for Features.
FeatureBatcher	Batcher class for Features or AffyFeatures.
FeatureCoordinate	Represents the coordinate of a feature on an array design.
FeatureData	This class holds information about a regular feature.
FeatureIdentificationMethod	This enumeration defines constants that are used to specify which method to use for identifying features on an array design.
FieldInfo	Information about a the login/password fields on the login form.
File	This class is used to represent individual file items and information about them.
FileAttachable	A FileAttachable item is an item that can have a File attached to it.
FileAttachableData	A fileattachable item is an item which can have a File attached to it.
FileCopyRunnable	Runnable implementation that copies data from an input stream to an output stream when executed.
FileData	This class holds information about a file.
FileExportOutputStream	An extension to the ExportOutputStream class which directs the output to a File in BASE.
FileImporter	Plug-in for importing file items in a batch.
FileImporter.PathIdMethod
FileImportInputStream	An extension to the ImportInputStream class which reads from a file on the BASE file system.
FileLoader	Node loader implementation for files.
FilenameGenerator<T>	File name generators are used together with DataWriterFactory implementations to generate file names for BFS data files.
FileOnlyImporterSupport	Importer implementation for the external program executor that uploads all created files to BASE and attaches them to a child bioassay set.
FilePacker	This interface should be implemented by classes that can pack files and directories from BASE file system.
FileParameterType	This class represent a parameter type that is a file.
FilePathFormatter	Formatter implementation that format File items to their complete paths.
FileServer	This class represents a file server that is used to store external files.
FileServerData	File entries that are external files can be linked to a file server.
FileSet	A file set is the container for files that have been attach to an item to hold data instead of importing it to the database.
FileSet.QueryRuntimeFilterImpl
FileSetData	This class collects all files used to store data for an item that store data in files instead of in the database.
FileSetMember	This class represents a file that is member of a file set.
FileSetMember.QueryRuntimeFilterImpl
FileSetMemberData	This class hols information about individual files attached to items that store data in files instead of in the database.
FileSetMemberLoader	Data loader implementation that load the files in a file set in FileStoreEnabled items.
FileSetMemberLogger	Logger for file set members that logs changes as updates to the parent item the file belong to.
FileSetMemberNameGenerator	Since a FileSetMember isn't Nameable we construct the name by combining the name of the file type and the name of the file.
FileStoreEnabled	This interface is implemented by items that can use files instead of the database for storing data.
FileStoreEnabledData	Items implementing this interface can store data in files instead of in the database.
FileStoreUtil	Utility class working with FileStoreEnabled items.
FileTypeIndex	This is a helper class for the PlatformData item to help with the Hibernate mapping to PlatformFileTypeData object.
FileUnpacker	This interface should be implemented by plugins that can unpack a single compressed file into the BASE file system.
FileUpload	Objects of this class are used to handle file upload from browsers using the standard mechanism described in RFC1867.
FileUpload.SectionHeaders	This class contains information extracted from the section headers for a form field or file upload field.
FileUpload.UploadStatus	This class contains information about the read status on the ServletInputStream
FileUploadProgress	Objects of this class holds information about the progress of an upload.
FileUtil	This class collects some useful methods for file and stream handling.
FileValidator	Validator implementation for files.
FileViewerContext	This class is used for holding information about a file that is beeing displayed in the GUI in some context.
FileViewerContext.Type
FileViewerUtil	Helper class for handling the "file-viewer" extension point.
FileWrapper	Wrapper around files that provide some basic information about the file.
Filter<T>	A filter is something that selectes or rejects an object due to some property of it.
FilterBatcher	Batcher class for filtered bioassaysets.
FilterUtil	Utility class for working with and using filters.
FirstPassSectionSpotsParser	Parses a 'spots' section of a BASEfile with bioassay set spot data.
Fix	Holds information about a suggested fix to a failure.
FixedButtonFactory	A simple implementation of a toolbar button action factory that creates the same fixed button for all users not using any context information.
FixedMenuItemFactory	A simple implementation of a menu item action factory that creates the same fixed menu item for all users not using any context information.
FixedSkinActionFactory	A simple action factory implementation that always include the given skin on all pages.
FixedSkinActionFactory.MySkinAction
FixedStartPageFactory	A simple start page action factory.
FixedTabFactory	A simple implementation of a tab action factory that creates the same fixed tab for all users not using any context information.
FlatFileParser	This class can be used to parse data from flat text files and from Excel workbooks in xlsx format.
FlatFileParser.Data	This class holds data about a line parsed by the FlatFileParser.hasMoreData() method.
FlatFileParser.ExcelData	Subclass that is used to return data when the source file is an Excel file.
FlatFileParser.Line	This class holds data about a line parsed by the FlatFileParser.parseHeaders() method.
FlatFileParser.LineType	Represents the type of a line matched or unmatched by the parser.
FloatConverter	Convert a Number constant to a Query API Expression from the float value.
FloatExpression	A constant float expression.
FloatParameterType	This class represent a parameter type that is a float.
FloatParameterValueData	Float parameter value.
FloatWriter	Database-independent writer implementation that writes double values from a result set.
Form	An alternative layout for tables which contains only one row.
Formatter<T>	A Formatter formats an object to a string suitable for output in a client application.
FormatterFactory	Factory class for creating formatters for various data types.
FormatterSettings	This is autility class for getting and setting formatter-related settings for the logged in user.
Formula	This class represents a formula.
Formula.AverageMethod	The average method used for the values of this formula.
Formula.Parser	The parser used to parse the formula.
Formula.Type	The type of formula indicats in which situations it can be used.
FormulaData	This class holds information about a formula used in the analysis of raw data and bioassay sets.
FormulaFilter	This plugin provides methods to filter a bioassayset based on formulas entered by the user.
ForwardingSignalHandler	A signal handler implementation that forwards the signal to another signal transporter.
FunctionSafeJep	Extension to the JEP parser that provides better error handling for unknown functions.
FunctionSafeJep.SafeFunctionTable	Function table implementation that pretends that all possible functions exists, but sends an error message if someone tries to use a function that doesn't really exists.
FunctionSafeJep.UnknownFunction	Represents an unknown function that appears in an expression.
GalExporter	Exports an array design with features to a GAL file.
GenericBaseDataWriterFactory<T>	Generic implementation of a data writer factory that create files in the BASE file system.
GenericDiskDataWriterFactory<T>	Generic implementation of a data writer factory that create files on the local file system.
GenericExtraFileImporter	Extra file importer implementation that imports file to a specified directory in the BASE file system.
GenericIntensityParser	Generic spot intensity parser implementation that looks for 'intensity1', ..., 'intensityN' data columns for any number of channels.
GenericOverview	Implementation for holding a generic overview of items.
GeoLocation	Utility class for geographic location.
GeoLocation.ResponseFilter	We only accept "200" status response, "application/json" content type and not more than 1K bytes (should be a lot less under normal operations).
GeometricMeanExpression	Calculates the geometric mean of an expression: EXP(AVG(LN(e)))
GetCurrentCatalogWork	A work implementation that return the name of the current database catalog.
GlobalDefaultSetting	This class is used to represent a global default setting.
GlobalDefaultSettingData
GreaterConverter	Convert the '>' operator to a Query API Restriction.
GreaterEqualsConverter	Convert the '>=' operator to a Query API Restriction.
Group	This class is used to represent groups.
Group.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return groups where the logged in user is a member unless the logged in user has generic read permission.
GroupData	This class holds information about a group.
GroupGroups	Class for mapping the GroupGroups table.
GroupKeys	Class for mapping the GroupKeys table.
GroupPermissions	This class is used to specify permissions to share an item to groups.
GroupProjects	Class for mapping the GroupProjects table.
GteqRestriction	Compare if one expression is greater than or equal to another: e1 > e2.
GtfInputStream	Input stream implementation that reads from a GTF file and converts it to a simple tab-separated file with a single line of column headers.
GtfInputStream.Attribute
GtfReporterImporter	Reporter importer implementation that create reporters from information in GTF files.
GtfReporterMapImporter	Import features to an array design from a GTF file.
GtfValidationAction	Action for validation of GTF files in a file set.
GtfValidationFactory	Action factory for creating GTF file validators.
GtRestriction	Compare if one expression is greater than another: e1 > e2.
GuiContext
GuiContext.Type
GuiContextData	This is a helper component for the PluginDefinitionData item to store the contexts where a plugin can be used in a client application.
GzipFilePacker	This class wraps the TarFilePacker in a GZIP stream, creating a tar.gz file.
GzipFileUnpacker	A plugin for unpacking a gzipped file to the BASE file system.
Hardware	This class is used to represent individual hardware items and information about them.
HardwareData	This class holds information about a Hardware.
HardwareLoader	Node loader implementation for hardware.
HardwareValidator	Validator implementation for hardware.
HasAnnotationRestriction	Restricts a query by the presence of absence of an annotation.
HasAttributeFilter	A filter implementation that checks if a value for a given attribute exists on a node.
Head	This tag defines the header section of a page.
Header	This tag defines a header column among the colummns or on a row.
HeaderRow	Container tag for a single header row in a table.
Headers	Container tag for header rows in a table.
Help	This tag is used to make it easier to add help features on a BASE web page.
Help	This class is used to represent a help text for a client application.
HelpData	This class holds information about an help item.
HelpExporter	This plugin exports helptexts stored in the database to a XML-file.
HelpImporter	This plugin imports helptexts into database from a XML-file.
HibernateUtil	This class collects most of the functionality we need for using Hibernate.
HibernateUtil.DelayedFilterDef
HibernateUtil.FilterConfigurator	Helper class for defining filters at runtime.
Hidden	This tag defines a hidden input element that should be included in the form.
HideableSection	This tag is used to display a section on a web page that can be shown/hidden by the user by clicking on an icon on it's title.
HistogramPlot	A simple plot utility for generating histogram plots without the need to delve deep into the JFreePlot package.
HistogramPlot.HistogramBin	Represents a single bin in a histogram.
HistogramPlot.HistogramDataset	An dataset implementation for histogram data that allows us to send data to JFreeChart the way we want.
HistogramPlot.HistogramSeries	Collects information about one histogram series.
HistogramPlot.TempSeries	Helper class for storing histogram data that needs to split into different annotations.
HistogramPlot.YAggregate	Defines what to to plot on the y axis in a histogram plot.
Hql	A factory class to create expressions, joins, etc. that are only used by HQL queries.
HqlElementsExpression	An expression representing the elements collection of a collection of a Hibernate entity: elements(alias.property).
HqlEntityExpression	An expression representing a Hibernate entity.
HqlEntityParameterExpression	Entity parameter expression.
HqlExpression	A class holding an expression or a restriction where a prefix can be used to represent a root alias in a HQL.
HqlIndexExpression	An expression representing the index collection of a map or list of a Hibernate entity: index(alias.property)
HqlInnerJoin	Inner joins an association to another item: JOIN <alias.property> <joinedAlias> to the query.
HqlLeftJoin	Left joins an association to another item: LEFT JOIN <alias.property> <joinedAlias> to the query.
HqlPropertyExpression	An expression representing the property of a Hibernate entity: alias.property or alias.property[index]
HqlQuery	This is a query that is using HQL (Hibernate Query Language) as the query language.
HqlQueryJoiners	This class collects AutoJoiner:s for HqlQuery queries.
HqlQueryJoiners.AnnotationJoiner	Joiner for annotations.
HqlQueryJoiners.ReporterListJoiner	Joiner for reporter lists.
HqlRightJoin	Right joins an association to another item: RIGHT JOIN <alias.property> <joinedAlias> to the query.
HqlSizeExpression	An expression representing the size of the of a collection of a Hibernate entity: size(alias.property).
HTML	This class contains a set of static methods that may be useful in a web application for handling text/HTML strings.
HttpConnectionManager	Connection manager implementation that support HTTP and HTTPS URI:s.
HttpConnectionManager.TimeoutTimer
HttpConnectionManagerActionFactory	Action factory for http connection manager factory.
HttpConnectionManagerFactory	Connection manager factory for HTTP and HTTPS URI:s.
HttpUtil	Useful methods related to HTTP stuff in general and Apache HTTP components in particular.
Icon	This tag is used to make it easier to display icons on a BASE web page.
Identifiable	An Identifiable item is an item which has an id a type and a version.
IdentifiableData	An identifiable item is an item which has an id and a version.
IdentifiableFormatter	Formatter to handle Identifiable items.
IdentityConverter<T>	Simple "converter" implementation that simply return the same object.
IdentityEncoderDecoder	Encoder decoder implementation that doesn't encode or decode anything.
IdentityFilter<T>	A filter implementation that only accepts an object if it is identical (==) to a given object.
IdentityUnitConverter	A unit "converter" that doesn't modify the values.
IdListRestriction	Restriction that filters on a list of ID values: id IN (a, b, c, ....)
IdMethod	Represents an 'identification method', eg. a way to find an item among the items that already exists in the database.
IfConverter	Convert If function to a Query API Expression.
IgnoreFileProcessor	Processor implementation for ignoring files.
IgnoreFilter	Filter implementation that selects only those extensions that was selected for ignoring by the user in the gui.
IlluminaRawDataImporter	An importer plug-in for Illumina raw data.
IlluminaRawDataImporter.BatchAndMapHolder	Holds a RawBioAssay and the RawDataBatcher to use for import and the Mapper for all it's data columns.
ImageRemapFilter	This is a filter that remaps request to images to some other image.
ImageRemapper	Remaps image URLs.
ImageRemapperUtil	Utility class for working with image remapping.
ImmediateDownloadExporter	This interface should be implemented by export plugins that supports immediate download to the client application.
ImportInputStream	An input stream used for input to import plug-ins.
Include	This enumeration defines constants that are used to specify which items to include in a query.
IncludeContentSectionFactory	A section action factory implementation that includes another resource as the content of a section.
IncludeContentTabFactory	A tab action factory implementation that includes another resource as the content of tab.
IncludeExcludeFilter
IndexedCacheKey	Cache key implementation that bundles another cache key with an index.
InfoRequestHandler	This is a request handler for the info and status commands.
InheritAnnotationsManager	Manager class for batch inheriting of annotations.
InheritAnnotationsManager.AnnotationTypeFilter	Filter for finding annotation types to process.
InheritAnnotationsManager.UsableParentFilter	Filter used to find parent items that are annotated and for which the current user has permission to USE the annotations.
InheritSpecification	Class for holding rules for how annotations should be inherited from parent items.
Input	This tag is used to make it easier to add <input> elements on a BASE web page.
InputStreamCombiner	An input stream implementation that reads one or more input streams sequentially.
InputStreamLocator	Defines a generic interface for opening an input stream from a named resource.
InputStreamSplitter	This class can be used to split an input stream into one or more additional output streams.
InputStreamTracker	This class is used to keep track of the number of bytes read from the underlying input stream.
InputStreamTracker.CurvedScaleFactor	Apply a curved scale factor that has a max upper limit.
InputStreamTracker.IdentityScaleFactor	Do not scale number of bytes.
InputStreamTracker.LinearScaleFactor	Apply a linear scale factor so that when we have read N actual bytes the getNumRead() method return N*scale bytes.
InputStreamTracker.ScaleFactor	A scale factor can be used to match number of read bytes to something that better resembles actual progress.
InReporterListFunction	A JEP function class that adds a inList(reporterListId) function to a JEP expression parser.
InRestriction	Compare if one expression is contained in a set of other expressions: e1 IN (e2[0], e2[1], ...)
Install	This class contains static methods used to install items into an empty database.
Install.ItemSubtypeFT
Install.PlatformFT
InstalledFileProcessor	File processor implementation that sets a final result status for each processed file (eg.
InstalledFilter	Filter implementation for extension files that allow installed files to pass.
InstallFilter	Filter implementation that selects only those extensions that was selected by the user in the gui.
InstanceOfFilter<T>	A filter implementation that accepts all objects that are (sub)classes of a specified class.
IntegerConverter	Convert an Integer constant to a Query API Expression.
IntegerExpression	A constant integer expression.
IntegerFormatter	Formats a number as an integer.
IntegerParameterType	This class represent a parameter type that is an integer.
IntegerParameterValueData	Integer parameter value.
IntegerUtil	Utility methods that will make it easier to implement data validation for integer attributes.
IntegerWriter	Database-independent writer implementation that writes integer values from a result set.
IntensityCalculator	This interface is used together with the IntensityCalculatorUtil class to help a plugin calculate intensities from raw data spots.
IntensityCalculatorPlugin	This plugin provides methods to calculate the intensity for a root bioassayset using different formulas.
IntensityCalculatorUtil	This is a utility class for plugins that calculate intensities from raw spot data.
IntensityCalculatorUtil.JepIntensityCalculatorImpl	An implementation of the IntensityCalculator interface using JEP expressions.
IntensityFormula	Holds information about the formulas used to calculate intensities from a raw data spot.
IntensityTransform	Gives information in what way spot intensities has been transformed before they were stored in the database.
InteractivePlugin	An interactive plugin is a Plugin that supports interactive configuration in a user session.
InternalIdMethod	Identification method implementation that finds an item by using the getById() method.
InternalJobQueue	A simple implementation of a job queue that executes jobs in order of priority and longest waiting time.
InternalJobQueue.JobQueueKeyring	Our own keyring containing the permissions we need to execute the jobs.
InternalSlotManager	The internal slot manager assigns slot to jobs based on their estimated execution time.
InterruptHandler	An interface for handling thread interrupts.
InvalidAndModifiedFilter	Filter implementation for extension files that allow modified but invalid files to pass.
InvalidAnnotationException
InvalidDataException	Exceptions of this type are thrown when invalid data is encountered.
InvalidPasswordException	This exception can be thrown when the password is invalid.
InvalidPasswordException	Exceptions of this type are thrown when user tries to log in, but the password is incorrect.
InvalidPathException	This exception is thrown when BASE is trying to parse a path which is invalid.
InvalidRelationException	Exceptions of this type are thrown when a ValidationAction has detected that a file related to the main file is invalid.
InvalidUseOfNullException	This exception is thrown when an object field or a parameter that mustn't be null is set to null.
InverseFilter<T>	A filter implementation that negates the result of a parent filter.
InvokationContext<A extends Action>	Keeps contextual information about a single invokation of extensions.
IOSupport	This interface is a tagging interface that should be implemented by export and import plug-ins that knows how to cooperate with the external program executor.
Item	This class defines constants for various items in BASE.
Item.DefinedPermissions	Helper class to make it easier to set up the defined permissions.
ItemAlreadyExistsException	This exception is thrown when trying to save an object and another object with the same ID already exists.
ItemContext	This item is a helper class for client applications when they need to store information about the current context for plugins that needs to find out the current context of the running client application.
ItemContext.PropertyFilterPair	Holds a pair of filter.
ItemContext.QueryRestrictions
ItemContext.RowRestrictions
ItemContext.SortDirection	Enumeration used to specify the sort direction.
ItemInUseException	This exception is thrown when trying delete an item that is used (reference to) by some other item or items.
ItemKey	This class is used to get information about which users and groups a Shareable item has been shared to.
ItemKeyData	This class holds information access privileges for users and groups.
ItemList	This class represents a list of items.
ItemList.DelayedAdditionManager	Handles items that should be added as members to the list, but since they were created in the same transaction doesn't have any ID until later in the commit phase.
ItemList.SynchronizeOption	Options for synchronizing an existing item list with a current settings in an ItemContext.
ItemListData	This represents an arbitrary collection of items.
ItemListLoader	Node loader implementation for item lists.
ItemListMemberNameGenerator	Name generator used for item list members.
ItemListSyncFilterData	Synchronization options for item lists.
ItemModifiedException	This exception is thrown when trying to save an item to the database that has been updated (or deleted) by another process in the meantime.
ItemNotFoundException	This exception is thrown when trying to load an item from the database that does not exist.
ItemParameterType<T extends BasicItem>	This class represent a parameter type that is an object derived from BasicData.
ItemParameterValueData	Item parameter value.
ItemProxy
ItemQuery<I extends BasicItem>	An implementation of the Query interface that returns item objects.
ItemQueryLoader<T extends BasicItem>	A class that uses a given query to load data.
ItemQueryWrapper	A query wrapper for ItemQuery:s.
ItemResultIterator<I extends BasicItem>	Return the results of an ItemQuery as an iterator.
ItemResultList<I extends BasicItem>	Return the results of an ItemQuery as a list.
ItemSubtype	Item subtypes can be used to classify items into sub-categories.
ItemSubtypeData	Item subtypes can be used to classify items into sub-categories.
ItemSubtypeFileType	This class represents a specific DataFileType that is associated with an item subtype.
ItemSubtypeFileTypeData	This class hols information about which file types can be used together with item subtypes.
ItemTypeFilter	A filter implementation that mathces item types on nodes.
ItemTypeFormatter	Formatter implementation that converts an integer into it's Item representation and the uses name() as the formatted value.
JarClassLoader	A class loader implementation that loads classes from JAR files.
JarClassLoader.JarClassLoaderProxy	A proxy class loader is typically needed when one extension depends on another extension.
JarClassLoader.JarInfo
Jep	Utility class for parsing mathematical expressions.
JepConversionFunction<T>	Convert a built-in JEP function or operation to a Query API Expression or Restriction.
JepDynamicField	A dynamic field implementation that uses a JEP expression to generate the expression that is needed to select the data.
JepExpressionFunction	This interface should be implemented by JEP functions that can also be converted into an Expression that can be used in queries.
JepExtraValueCalculator	This plugin caluclates extra values from a bioassayset using mathematical formulas entered by the user.
JepFunction	This interface should be implemented by objects that can perform some kind of calculation for a JEP expression.
JepIntensityTransformer	This plugin transform channel intensities using mathematical formulas entered by the user.
JepMapper	A mapper that uses Jep to calculate the final value.
JepRestrictionFunction	This interface should be implemented by JEP functions that can also be converted into a Restriction that can be used in queries.
Job	This class represents the execution of a job.
Job.ExecutionTime	A rough estimate of the execution time of a job.
Job.ProgressReporterImpl	Implements the ProgressReporter interface and stores the percentage completed for the current job.
Job.SignalKeyring	Our own keyring containing the permissions signal handlers may need to update job status, eq.
Job.Status	The status of a job.
Job.Type	The type of job.
JobAgent	This class represents a job agent, which is a program running in another virtual machine on the same or a different server.
JobAgentConnection	This class is used by client applications to communicate with job agents.
JobAgentData	This class holds information about a job agent.
JobAgentInfo	This class can hold information about the status of a job agent.
JobAgentServerConnection	This class is used by job agents to listen for incoming requests from client applications.
JobAgentServerConnection.ListenerThread	This class is used for listening to the specified socket for incoming connections.
JobAgentServerConnection.RequestHandlerThread	This class is used for forwarding requests to a RequestHandler.
JobAgentSettings	This class contains a job agent's settings for a specific plugin.
JobAgentSettingsData	This class holds information about plugin settings for a particular job agent.
JobData	This class holds information about a job.
JobExecutor	This interface must be implemented by all classes that want's to act as a job executor.
JobInfo	Hold information about a job that is running on a job agent.
JobQueueChecker	This class is given the responsibility to check the job queue for jobs that are awaiting execution.
JobRunner	A runnable class that makes it possible to execute each job in it's own thread.
Join	A join query element.
JoinType	An enumeration used to specify the type of join.
JsonConverter<T>	Implementations should convert a given object to an object that can be serialized into a JSON string.
JsonUtil	Utility functions for working with JSON data.
JspContext	Context object for the web application.
Key	This is the base class for keys.
KeyData	This abstract class is the base class for the key classes which holds access privileges for users, groups, projects and roles.
KeyPermission	Class for holding a keyId and a permission value.
Keyring	Objects of this class holds information about a user's access permissions, group and role membership.
Kit	This class is used to represent a kit of reagents and other stuff used in the lab process.
KitData	This class holds information about a kit.
KitImporter	Plug-in for importing kit items in a batch.
KitLoader	Node loader implementation for kits.
KitValidator	Validator implementation for kits.
Label	This tag creates a label on a toolbar.
LeftFunction	Adds a left(string, index|string) function to Jep.
LessConverter	Convert the '<' operator to a Query API Restriction.
LessEqualsConverter	Convert the '<=' operator to a Query API Restriction.
LikeRestriction	Check if one expression matches another: e1 LIKE e2
LinearUnitConverter	A linear unit converter is a converter implementation were all units can be converted to another unit using a multiplication factor and/or an offset.
LineNoFunction	Adds a lineNo() function to Jep.
LinkedFileFormatter	Formatter implementation that generates a HTML output linking a file item.
LinkedItemFormatter	Formatter implementation that generates a HTML output linking a nameable item.
Listable	Tagging interface for items that can be put in an ItemList.
ListableUtil	Utility class for working with Listable items.
ListColumnAction<I,V>	Action that inserts a new column into a table listing.
ListColumnDataLoader<I>	Data loader implementation that acts as a proxy to a ListColumnAction object.
ListColumnExportRenderer<I>	Renderer implementation that add formatter and data loader implementation for a list column that can be exported.
ListColumnUtil	Utility class for list column extension points.
ListUtil
LoadServletsProcessor	Processor implementation that define servlets based on what it can find in the META-INF/servlets.xml file.
LocalSignalReceiver	A signal receiver implementation that can receive signals from the local virtual machine only.
LocalSignalTransporter	A signal transporter implementation that can transport signals within the local virtual machine only.
Location	This enumeration defines constants that are used to specify different file storage locations.
Log10MACalculator	MA calculator for log2-transformed spot intensity values.
Log2Function	A JEP function class that adds a log2(expression) function to a JEP expression parser.
Log2MACalculator	MA calculator for log2-transformed spot intensity values.
LogarithmConverter	Convert Logarithm function to a Query API Expression.
LogControl	Gives information about the current transaction and gives log implementations limited access to the database.
LogEntry	An entry in the log.
LogExpression	Take the n-based logarithm of an expression: log(n, e).
LoggableData	Tagging interface that should be implemented by all data classes that we want to log in the change history tables.
LoggingErrorHandlerFactory	Exception handler factory implementation that logs error messages using the default logging mechanism.
LoggingErrorHandlerFactory.Level	Log level implementations for slf4j.
LoggingInterceptor	Interceptor that attaches to Hibernate sessions to provide logging of items that are updated/created/deleted.
LoggingInterceptor.LogDetails
LoggingInterceptor.LogManagerAndFactory
LoginException	This exception can be thrown when an error occurs during the authentication, but it is not known if the username or password is causing the problem.
LoginException	Exceptions of this type are thrown when the BASE server uses an external authentication plug-in and it is not clear if the login or password is causing the failure.
LoginFormAction	An action for customizing the login form.
LoginFormBean	A simple implementation of the LoginFormAction interface.
LoginRequest	Hold information about a login request such as login, password, etc.
LogLevel	The level of the log message.
LogManager	Manages the logging of changes made in a single transaction.
LogManagerFactory	A log manager factory handles the creation of log managers and entity loggers.
LogUtil	Utility class for LOG4J logging.
LongParameterType	This class represent a parameter type that is a long.
LongParameterValueData	Long parameter value.
LongWriter	Database-independent writer implementation that writes long values from a result set.
LookupFormatter<T>	A formatter implementation that uses a map to lookup values from a set of keys.
LowessNormalization
LowessNormalization.CallableWorker
LowessNormalization.SpotData
LteqRestriction	Compare if one expression is less than or equal to another: e1 <= e2.
LtRestriction	Compare if one expression is less than another: e1 < e2.
MACalculator	Calculates M and A values for 2-channel data.
ManualDerivedBioAssayCreator	Plug-in that allows a user to manually register an external analysis procedure for derived bioassays and to upload files that was generated by it.
ManualEntryLogger	Logger for manual entries.
ManualLogEntry	Represents a manual entry into the change history log.
ManualTransformCreator	Plug-in that allows a user to manually register an external analysis procedure and to upload files that was generated by it.
MAParser	Spot intensity parser implementation for 2-channel data that looks for M/A values in the spot data and converts them to ch1/ch2 intensity values.
MAPlotFactory	Factory for generating MA and correction factor plots for 2-channel data.
Mapper	Represents a mapping expression that gets a single value from a line of data.
MappingBatcher	Batcher class for inserting parent mapping information in the dynamic database.
MappingCoordinate	This class defines a mapping coordinate, which is a triplet of plate number, row and column.
MapValueLoader	Data loader implementation that load values from a map collection.
MarkAsProcessedProcessor	File processor implementation that marks all extension files as processed.
MasterSlotManager	An extension to the internal slot manager which also accepts slot assignment from remote job agents.
MasterSlotManager.RemoteSlot	A remote slot is a slot with some information about when it was created and last updated.
MasterSlotManager.RemoteSlotRequestHandler	Request handler implementation that accepts requests for slots from remote hosts.
MasterSlotManager.RemoteSlotTimeoutChecker	Task that is scheduled at regular intervals to check for timed out slots.
MatrixBaseFileExporter	Exporter implementation that exports bioassay set data as a matrix BASEfile.
MatrixBfsExporter	BFS exporter implementation that exports spot data in matrix format.
MatrixModel	A model container for BFS data files.
MatrixSpotIntensityEventHandler	Event handler that extracts spot intensity information from matrix BFS data files and inserts the values to a spot batcher.
MaxExpression	Calculates the maximum of an expression: MIN(e)
MD5	This class calculates the MD5 hash of a string and returns it represented as a hexadecimal string.
MeanExpression	Calculates the arithmetic mean of an expression: AVG(e)
MeanFunction	A JEP function class that adds a mean(string) function to a JEP expression parser.
MeanRawDataPropertyExpression	An expression representing the mean value of property of a raw data spot.
MeasuredBioMaterial	This class is the base class for measured biomaterial items.
MeasuredBioMaterial.RemainingQuantityAction	Transaction handler for updating the remaining quantity of a biomaterial based on the sum of the used quantity in this transaction.
MeasuredBioMaterialData	This class is the root class for measured biomaterials, ie biomaterials for where the quantity is tracked.
MedianRatioNormalization
MedianRatioNormalization.SpotData
Menu	This tag defines a drop-down menu that is is opened when the user moves the mouse over or clicks at the title of the menu.
Menuitem	This tag defines a menu item inside a drop-down menu.
MenuItemAction	An action for extensions to the menu system.
MenuItemAction.MenuType
MenuItemBean	A simple bean-like implementation of the MenuItemAction interface.
Menuseparator	This tag defines a horizontal separator line inside a drop-down menu.
Message	This class represents a message.
Message.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return messages for the currently logged in user unless the logged in user has generic read permission.
MessageData	This class holds information about messages.
Metadata<C>	Utility methods for retreiving metadata about items.
Metadata.BasicData2ItemPropertyPath<C extends BasicData,V extends BasicItem>	Property path implementation that converts a BasicData object to a BasicItem.
Metadata.BasicItem2DataPropertyPath<C extends BasicItem,V extends BasicData>	Property path implementation that converts a BasicItem to a BasicData object.
Metadata.CollectionPropertyPath<C>	Property path implementation which wraps a collection inside an unmodifiable collection.
Metadata.CombinedPropertyPath<C,V>	Property path implementation that combines a list of property paths to create a long chain.
Metadata.ComponentPropertyPath<C,V>	Property path implementation which gets a value from a component.
Metadata.DateCopyPropertyPath	Property path implementation clones a Date.
Metadata.EntityPropertyPath<C,V>	Property path implementation which gets a value from an entity.
Metadata.EvictPropertyPath<C>	Property path implementation that evicts the selected item from the Hibernate first-level cache.
Metadata.IdentifierPropertyPath	Property path implementation which gets the id from an entity.
Metadata.MapPropertyPath	Property path implementation which wraps a map inside an unmodifiable map.
Metadata.NoopPropertyPath<C>	Property path implementation that does nothing.
Metadata.PropertyPath<C,V>	Contract for getting the value of a specific property for an item.
Metadata.ReporterScore2DataPropertyPath	Property path implementation that converts a ReporterScore to a ReporterListScoreData object.
MetadataModel	A model container of the contents of a BFS metadata file.
MetadataModel.Section	Holds information about a section.
MetadataModel.SectionEntry	Holds information about a section entry.
MetadataParser	Parser implementation that parses a BFS metadata file.
MetadataWriter	Writer implementation for writing BFS metadata files.
Migration	Class for migrating a database to PostgreSQL.
MimeType	This class is used to represent mime types.
MimeTypeData	This class holds information about mimetypes
MinExpression	Calculates the minumum of an expression: MIN(e)
ModeInfo
MultiEventHandler	Event handler implementation that forwards a single event to multiple event handlers.
MultiFormatter	A generic formatter that can be used to format objects of mixed classes.
MultiPermissions	This is a helper class that is very useful when you have a collection of Shareable items and want to modify some permissions on all of them without affecting the rest of the permissions.
MultiplyConverter	Convert Multiply function to a Query API Expression.
MultiplyExpression	Multiply two expressions: e1 * e2.
MultiPropertyIdMethod	Identification method implementation that can use a multiple properties (eg, name, id, externalId, etc.) for identifying items.
MultiProtocolRequestHandler	Request handler implementation that forwards all requests to a registered protocol-specific handler.
MultiQueryIterator<E extends BasicItem>	Helper class for executing multiple queries and return the result as a single iterator.
MultiStepCollectionTransformer<S,D>	Collection transformer implementation that transforms a source collection into the destination collection using multiple steps.
MultiUpdateWork	A JDBC Work implementation that executes multiple queries that doesn't return any result.
MySQLEngine	Database engine for My SQL.
Nameable	A Nameable item is an item that has a name and description.
NameableComparator<T extends Nameable>	An implementation of the Comparator interface which uses the name of Nameable items to compare the objects.
NameableConverter<T extends Nameable>	Simple "converter" implementation that create JSON objects with the name and id of Nameable items.
NameableData	A nameable item is an item that has a name and, optionally, a description.
NameableFormatter	Formatter to handle Nameable items.
NameableNameGenerator<I extends Nameable>	Name generator implementation for Nameable items.
NameableNodeValidator<I extends Nameable>
NameableUtil	Utility methods that will make it easier to implement the Nameable interface, including data validation.
NamespaceParameterValuesWrapper	A helper class that wraps a parameter values object with a namespace.
NamespacePluginParameter<T>	A helper class that wraps a plug-in parameter object with a namespace.
NamespaceRequestWrapper	A helper class that wraps a request object with a namespace.
NativeQueryWrapper<R>	A simple wrapper around hibernate native (SQL) queries which simply forwards all calls to a parent query.
NativeSQLFunction	Helper class for mixing native SQL with HQL queries.
NaturalLogarithmConverter	Convert NaturalLogarithm function to a Query API Expression.
Navigator	This tag is used to display a navigator for a pageable table of items.
NegateExpression	Negate an expression: -e1.
NeqRestriction	Compare if two expressions are inequal: e1 <> e2, or NOT e1 IS NULL
NestedIterator<E>	This class implements the Iterator interface for iterating multiple collections as if it was one big collection.
News	This class represents news items.
News.QueryRuntimeFilterImpl
NewsData	This class holds information about news items.
NiceFormatter	Nicely format a string for output on a web page.
Node	A node in an overview.
Node.Type	The type of node.
NodeAttribute<T>	Defines per-node attributes that can be used to store extra information together with a node that doesn't fit the regular properties.
NodeCache<K>	A cache implementation for nodes.
NodeFactory<I extends BasicItem>	A node factory is responsible for creating item-type nodes.
NodeLoader<I>	A node loader is an object that knows how to create a node for some specific item and how to load forward and reverse nodes for related items.
NodeLoaderFactory<L,K>	A node loader factory is a class that know how to create NodeLoader:s for a given key domain.
NodeNameGenerator<I>	A name generator is an object that can create the name and title for a node when given the item that should be attached to the node.
NodeTypeFilter	A filter implementation that matches the node type.
NodeValidator<I>	A node validator is responsible for checking the "validity" of a node.
NodeValidatorAction<I>	The same as a NodeValidator.
NodeValidatorFactory<L,K>	A node validator factory is a class that know how to create NodeValidator:s for a given key domain.
NoneOfFilter<T>	A filter implementation that accpets an object only if at none of the parent filters accepts it.
NonRestartable	This is a tagging interface that should be implemented by the plug-ins that don't support restart and reconfiguration of a job after an interrupted execution.
NotConverter	Convert Not function to a Query API Restriction.
NotEqualsConverter	Convert the '!
NotInReporterListFunction	A JEP function class that adds a notInList(reporterListId) function to a JEP expression parser.
NotLoggable	Getter methods that are annotated with this annotation should not trigger a log entry even if their values have changed.
NotLoggedInException	This exception is thrown if you try to perform a function that requires a user to be logged in without beeing logged in.
NotNullFilter<T>	A filter implementation that rejects all null objects.
NotRestriction	Negate a restriction: NOT r
NullIfExceptionMapper	A mapper that returns null if there is an exception when parsing the input data.
NullNodeLoader<I>	A node loader implementation that doesn't load any nodes.
NullNodeValidator<I>	A node validator implementation that accepts all nodes, except missing items and denied access items (depending on configuration).
NumberFormatFormatter	Formatter implementation for numeric values that simply wrap a NumberFormat instance.
NumberFormatter	Formats a number for output on a web page.
NumberFormatUtil	Utility class for working with NumberFormat object.
NumberOutOfRangeException	This exception is thrown when an item's field or a parameter that only accepts numeric values within a certain range are passed a value outside that range.
ObjectKey<O>	Instances of object keys should be something that uniquely identifies an object that has been defined by an extension.
OlderThanFileFilter	An implementation of the FileFilter interface that filter files based on their age.
OneOfFilter<T>	A filter implementation that accpets an object if at least one parent filters accepts it.
OnSaveAction	Action that is called when an item is saved in gui.
OnSaveRenderer	Renderer implementations for OnSaveAction:s.
Operator
OrConverter	Convert the '||' operator to a Query API Restriction.
Order	An ordering query element.
Orders	A factory class to create order by expressions.
OrRestriction	Combine one or more restrictions with OR: r[0] OR r[1] OR ...
OverviewContext	Interface that should be implemented by overview generating classes.
OverviewPlotAction	Action for generating overview plots for a bioassay set.
OverviewPlotBean	A simple bean-like implementation of the OverviewPlotAction interface.
OverviewUtil	Utility class for the overview generation functionality.
Ownable	An Ownable item is an item which has a User as its owner.
OwnableData	An ownable item is an item which has an owner.
OwnableUtil	Utility methods that will make it easier to implement the Ownable interface, including data validation.
OwnableUtil
OwnedData	This class extends the BasicData class and implements the OwnableData interface.
OwnedItem	This class inherits from the BasicItem class and implements the Ownable interface.
PackedFileExporter	Plug-in that packs one or more selected files and directories into a single file.
PackUtil
Page	This tag should be used together with the <base:head> and <base:body> tags on every JSP page in BASE.
Panel	This tag creates a panel in the table.
ParameterDefinition	Represents a parameter definition for the external program.
ParameterException	This exception is thrown by classes that uses the parameter system, ParameterType and ParameterValueData.
ParameterExpression	Parameter expression.
ParameterInfo	Get information about a plugin configuration or parameter.
Parameters	Utility class for creating some useful plug-in parameters.
ParameterType<T>	This is the base class for all parameter types.
ParameterValueData<T>	The base class for the different types of parameter values.
ParameterValues	This interface is used by the plugin to access the different parameters attached to its job and configuration.
ParameterValuesImpl	An implementation of the ParameterValues interface that lets a plugin write the job's configuration.
ParameterValuesWrapper	A helper class that will wrap the parameter values from one job, one configuration and one request object.
ParentBioMaterialEventSourceLoader	This is a loader implementation that load information about all source biomaterial for a given child biomaterial.
ParentBioMaterialEventSourceLoaderFromBioAssay	This is a loader implementation that load information about all source biomaterial for a given physical bioassay.
ParentBioMaterialLoader	This class get data from the parents to a MeasuredBioMaterial
PasswordData	This class holds the password for a user.
PasswordLoginFormFactory	A version of the default login form that can be installed as an extension.
PasswordParameterType	This class represent a parameter type that is a password (or any other type of masked string).
Path	This tag defines a navigation path.
Path	This class is used represent the path to a Directory or File item.
Path.Type	An enum that describes what type the path is
PathConverter	A value converter that can be used on all setter methods that has been annotated with the PathSetter and PathType annotations.
PathElement	This tag defines an element of a path.
PathLoader	This is a loader implementation that load the path of a file or directory.
PathParameterType	This class represent a parameter type that is a path to either a directory or a file.
PathSetter	Indicates that a factory setter method which takes a string as it's input will have the value scanned by a PathConverter before the setter method is invoked.
PathType	Specify the type of paths.
PauseRequestHandler	This is a request handler for the pause command.
PerformanceTimer	A simple timer for measuring code performance.
Permission	This enumeration defined constants for permissions.
PermissionButtonFactory	A button factory that can hide or disable button items based on the logged in user's permissions.
PermissionDeniedException	This exception is thrown when trying to load or manipulate an item in the database and you don't have the required permission.
PermissionMenuItemFactory	A menu item factory that can hide or disable menu items based on the logged in user's permissions.
PermissionRestriction	Restriction that inserts an "impossible" filter requirement (1=0) if the logged in user is lacking a given permission.
Permissions	This class holds permissions requested by a plugin.
PermissionTemplate	A permission template with permissions to users, groups and projects.
PermissionTemplateData	A permission template with permissions to users, groups and projects.
PermissionUtil	This class is used to collect some useful methods for assigning permissions to roles and shared items.
PhysicalBioAssay	A physical bioassay is a representation of the process of performing an experiment one or more Extract:s.
PhysicalBioAssayData	This class holds information about a physical bioassay (eg. a hybridization or similar).
PhysicalBioAssayImporter	Plug-in for importing physical bioassays items in a batch.
PhysicalBioAssayLoader	Node loader implementation for physical bioassays.
PhysicalBioAssayToDerivedBioAssayTransformer	Source item transformer implementation that transform physical bioassay items to derived bioassays.
PhysicalBioAssayToExtractTransformer	Source item transformer implementation that transform physical bioassay items to extracts.
PhysicalBioAssayValidator	Validator implementation for physical bioassays.
PingRequestHandler	This is a request handler for the ping command.
PlainTextTemplate	A plain text template that exports data in tab-delimited format.
Plate	This class is represents physical plates.
PlateCoordinate	This class defines a plate coordinate, which is row and column on a plate.
PlateData	This class holds information about a plate.
PlateEvent	This class represents an event in the life of a Plate.
PlateEventData	This class holds information about a plate event.
PlateEventLogger	Logger for plate events that logs changes as updates to the plate the event belongs to.
PlateEventType	This class is used together with the PlateType class to define event types for plates.
PlateEventTypeData	This class holds information about a plate event type.
PlateFlatFileImporter
PlateGeometry	This class defines a plate geometry, which is the number of rows and columns of wells on a Plate.
PlateGeometryData	This class holds information about a plate geometry.
PlateMapping	This class represents a mapping from one plate geometry to another.
PlateMappingData	This class holds information about a plate mapping.
PlateMappingExporter	Exporter for plate mappings.
PlateMappingImporter	Importer for plate mappings.
PlateType	This class represents plate types, which is a name, description, geometry and a list of event types.
PlateTypeData	This class holds information about a plate type.
Platform	This class is used to represent an experimental platform in BASE.
PlatformData	This class hols information about experimental platforms.
PlatformFileType	This class represents a specific DataFileType that is part of a platform.
PlatformFileTypeData	This class hols information about which file types are used on which experimental platforms and variants.
PlatformLoader	Node loader implementation for platform and platform variant.
PlatformValidator	Validator implementation for platforms/variants.
PlatformVariant	Represents variants of a Platform.
PlatformVariantData	This class hols information about variants of experimental platforms.
PlotAnnotation	Used to map spot data into different annotations.
PlotGenerator	Contains information about a single image in an overview plot.
PlotGeneratorBean	A simple bean-like implementation of the PlotGenerator interface.
PlotServlet	This servlet can plot spot data for a bioassay or bioassay set.
PlotServlet.CFResultIterator	Special implementation of a SqlResultIterator that combines the result from the parent and child into one virtual iterator.
PlotServlet.CFSqlResult	A single result row that is combined from the parent and child results. 1 --> parent A, 2 --> parent M, 3 --> parent M - child M
Plugin	This interface must be implemented by all plugins to BASE.
Plugin.MainType
PluginConfiguration	This class is used to configure a plugin.
PluginConfigurationData	This data class is used to configure a plugin.
PluginConfigurationExporter	This plugin exports parameters of a pluginconfiguration into an XML-file.
PluginConfigurationImporter	This plugin imports pluginconfiguration from an XML-file.
PluginConfigurationRequest	Configures a plugin or job.
PluginDefinition	A plugin definition represents the executable plugin.
PluginDefinitionData	This class represent an installed plugin.
PluginDefinitionFilter	Filter implementation that only matches tags for plug-in definitions.
PluginExecutionRequest	Executes a job.
PluginInfo	Object for holding information about a plug-in definition as it is loaded from the extensions definition file.
PluginInfoKey	Key implementation used to identify plug-in definitions.
PluginInstallationProcessor	File processor implementation that load and install plug-ins.
PluginKeys	Class for mapping the PluginKeys table.
PluginParameter<T>	Contains information about a single parameter that the plugin needs for a request.
PluginPermission
PluginPermission
PluginRequest<P extends Plugin>	Configures or executes a plugin.
PluginResponse	Get the response from a configuration step or execution of a plugin.
PluginSessionControl	This is a special session control implementation that is used for executing plugins that prevents them from logging in or out.
PluginType
PluginTypeData	This class represent an interface that a plugin can implement.
PositionBatcher	Batcher class for per-position data in the dynamic database.
PositionEventHandler	Event handler implementation intended to be used with a SynchronizedSpotDataParser to extract the position number from the parsed data.
PositionExtraValueBatcher<I>	Batcher class for per-position extra values.
PositionFunction	A JEP function class that adds a pos function to a JEP expression parser.
PostgresDbEngine	Database engine for Postgres.
PostgresResultWriterFactory	Result writer factory implementation for formatting result values suitable for importing by a PostgreSQL database.
PowerExpression	Calculate the power: base ^ exponent
PredefinedQuery	This class is used for reading XML files with information about predefined queries.
PrefixSuffixFormatter<T>	Formats a value with optional prefix and suffix.
PrefixSuffixRenderer<A extends Action>	A wrapping renderer for HTML output that can wrap the HTML generated by a parent renderer with a prefix and/or suffix.
Presets	This is a generic class for handling named presets consisting of multiple key/value pairs.
Presets.Preset	Represents a single preset.
PresetSelector	Special tag for generating a list of saved contexts and other settings.
PrintMapFlatFileImporter	A plugin that imports an ArrayDesign from a printmap.
PrintMapFlatFileImporter.FormatType
PrintMapFlatFileImporter.MetaBlock
PrintMapFlatFileImporter.Section
PriorityComparator<T>	A comparator implemenation that sorts a given set of objects before all other object.
ProcessJobExecutor	This is a job executor which starts a new process for each job to be executed.
ProcessJobExecutor.StreamRedirector	Used for redirecting standard output to a string.
ProcessResults	Class for collecting results from a scan for new/deleted/updated extensions.
ProcessResults.FileResults	Scan results for a single XML or JAR file.
ProgramParameter	A program parameter definition and it's values for a specific job.
ProgressInputStream	Input stream wrapper that calls a progress reporter at regular intervals.
ProgressReporter	Certain methods in BASE can report their progress back to the calling client application if they are giving an object that implements this interface.
ProgressReporterSignalHandler	An implementation of a signal handler that uses a ProgressReporter to communicate signals back to the target.
Project	This class is used to represent projects.
Project.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return projects where the logged in user is a member or owner unless the logged in user has generic read permission.
ProjectData	This class holds information about a project.
ProjectFilter	Filter implementation that finds all annotation snapshots for a given set of projects.
ProjectKey	This class is used to get information about which projects a Shareable item has been shared to.
ProjectKeyData	This class holds information access privileges for projects.
ProjectKeys	Class for mapping the ProjectKeys table.
ProjectPermission	Class for holding a project id and a permission value.
ProjectPermissions	This class is used to specify permissions to share an item to projects.
ProjectSpecificAnnotationsManager	Internal class for keeping the "override_id" column in the "Annotations" table synchronized when annotations are creted and deleted.
ProjectSpecificAnnotationsManager.AnnotationInfo	Holds some information about the annotation that has been created.
ProjectSpecificInfoFilter	Helper class for finding out information about about annotation snapshots returned by AnnotationLoaderUtil.findAll(net.sf.basedb.core.snapshot.AnnotationSetSnapshot, Filter) method.
PropertyFilter	Special tag for outputting the filter HTML that a ColumnDef has registered with the Table object.
PropertyFilter	Used to store filter settings in the current context.
PropertyFilterData	This class holds context information to help client applications with storing common settings for tables.
PropertyFilterFormatter	Formatter for PropertyFilter items.
PropertyIdMethod	Identification method implementation that can use a single property (eg, name, id, externalId, etc.) for identifying items.
PropertyPathActionFactory<I,V>	A factory implementation that generates list columns based on a property path as used by the Metadata class.
PropertyPathActionFactory.PropertyPathAction<I,V>	A concrete implementation of the ListColumnAction interface.
PropertyPathProtected	Getter methods that are annotated with this annotation should can not use Metadata.getPropertyPath to retreive their values.
PropertyValue	This tag is used to display the property of a BasicItem.
Protocol	This class is used to represent individual protocol items and information about them.
ProtocolData
ProtocolLoader	Node loader implementation for protocols.
ProtocolParameterLoader	Node loader implementation for protocol parameters.
ProtocolParameterValidator	Validator implementation for protocol parameters.
ProtocolValidator	Validator implementation for protocols.
ProxyActionFactory	Generic action factory class that can generate instances of actions if the action class is an interface.
PushToParentsTransformer	Transformer implementation that can be used to to find parent items to children that have a subtype with the "push annotations to parent" flag set.
QuadraticMeanExpression	Calculates the quadratic mean of an expression
Quantity	This class is used to represent a quantity for specifying units to annotations.
QuantityData	This class holds information quantities.
Query	This defines the simplest form of a relational query.
QueryElement	A query element is used in various places in a Query to build the structure of the query.
QueryExecutor	Utility class for executing SQL and Hibernate queries.
QueryExecutor.Cancelable	Interface to be implemented by classes that knows how to cancel a query.
QueryExecutor.CancelableSession	Cancels the query running in a Hibernate session.
QueryExecutor.CancelableStatelessSession	Cancels a query running in a stateless Hibernate session.
QueryExecutor.CancelableStatement	Cancels a statement by calling Statement.cancel().
QueryExecutor.FutureItem<T>
QueryExecutor.FutureResultSet	A callable implementation the calls PreparedStatement.executeQuery()
QueryExecutor.FutureScrollIterator<T>	Calls Query.scroll(ScrollMode) and returns the result as a ScrollIterator.
QueryExecutor.FutureUpdate	A callable implementation the calls PreparedStatement.executeUpdate()
QueryFilterAction	Actions for creating restrictions on queries.
QueryParameter	Holds information (name, type and value) about a single parameter to a query.
QueryParameters	Utiltity class for parsing string values in the form of HTTP request query parameters:
QueryResult	This is the root interface for query results.
QueryRuntimeFilter	Represents a filter that is applied to a query just before it is executed in order to limit the result.
QueryRuntimeFilterFactory	This is a factory class for QueryRuntimeFilter implementations.
QueryRuntimeFilterFactory.AnnotatableFilter	A required filter for Annotatable items.
QueryRuntimeFilterFactory.BasicFilter	An optional default filter for BasicItem:s that are not Ownable or Shareable.
QueryRuntimeFilterFactory.ChainedFilter	Chains one or more filters into a single filter.
QueryRuntimeFilterFactory.ChildFilter	An optional filter that can be used by BasicItem:s to replace the QueryRuntimeFilterFactory.BasicFilter.
QueryRuntimeFilterFactory.DenyAllFilter	A required filter for all items, which checks if the logged in user has been "granted" the Permission.DENIED permission for a specific item type.
QueryRuntimeFilterFactory.OwnableFilter	An optional default filter for Ownable items that are not Shareable.
QueryRuntimeFilterFactory.RemovableFilter	A required filter for Removable items.
QueryRuntimeFilterFactory.ShareableFilter	An optional default filter for Shareable items.
QueryRuntimeFilterManager	This class manages the enabling/disabling of QueryRuntimeFilter:s.
QuerySection	Indicates which part of a query that is currently beeing built.
QueryType	A type representing the language of the query.
QueryWrapper<T>	A helper interface for the SimpleExport class to make it easier to interact with different types of queries.
QueryWrapper<R>	A simple wrapper around hibernate queries which simply forwards all calls to a parent query.
Quota	This class is used to represent disk quota settings for users and groups.
Quota.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return the quota assigned to the logged in user unless the logged in user has generic read permission.
QuotaData	This file holds information about a qouta.
QuotaException	This exception is thrown to signal that the user's quota has been exceeded and that an DiskConsumable item cannot be saved.
QuotaIndex	This is a helper class for the QuotaData item to help with the Hibernate mapping between quota and quota type/location/max bytes.
QuotaType	This class represents the different types a quota can have.
QuotaTypeData	This class holds information about different QuotaTypes.
RawBioAssay	A rawbioassay represents the raw data generated from a single DerivedBioAssay.
RawBioAssayData	This class holds information about a raw bioassay, which is the raw data extracted from a scan.
RawBioAssayImporter	Plug-in for importing raw bioassay items in a batch.
RawBioAssayLoader	Node loader implementation for raw bioassays.
RawBioAssayPropertyExpression	An expression representing the property of a raw bioassay.
RawBioAssayToDerivedBioAssayTransformer	Source item transformer implementation that transform raw bioassay items to derived bioassays.
RawBioAssayValidator	Validator implementation for raw bioassays and root raw bioassays.
RawChannelFunction	A JEP function class that adds a rawCh(int) function to a JEP expression parser.
RawData	Represents the measurements for single raw data spot.
RawDataBatcher	Batcher class for raw data.
RawDataBatcher.FeatureInfo
RawDataBatcher.FeatureProxy
RawDataBatcher.ReporterProxy
RawDataFlatFileImporter	A plugin that imports rawdata from a flatfile.
RawDataProperty	Holds information about an extended property for raw data.
RawDataPropertyExpression	An expression representing the property of a raw data spot.
RawDataType	This class holds information about a raw data type.
RawDataTypeFilter	Filter implementation that accept raw bioassay items of a given raw data type.
RawDataTypes	This class is used for reading the XML configuration file with information about raw data types.
RawDataTypes.NameComparator	Comparator implementation that sorts raw data types according to their name.
RawDataUtil	Utiltity class for getting and setting non-public properties of raw data objects.
RawFunction	A JEP function class that adds a raw(string) function to a JEP expression parser.
RealJoin	Represents a join from one virtual table in the dynamic database to a table in the regular database or between two tables in the regular database.
RealTable	This class defines constants that are used to specify a table in the regular (non-dynamic) database while doing analysis with dynamic queries.
ReflectValidationRuleActionFactory	Factory implementation for validation rule actions that uses reflection to access the value of a public static field and return that as the validation rule.
RegexpFileFilter	An implementation of the FileFilter interface that filter files and directories based on regular expressions.
Registered	Items that implements this interface has their registration date stored in the database.
RegisteredData	Adds the date an item was registered in the database.
RegisterExtensionsProcessor	Extension file processor implementation that will load the extension definitions from each file and register them with the registry that is managed by the manager.
RegisterExtensionsProcessor.FileData	Keep track of the extension points and extensions found in a file.
Registry	A registry for keeping track of extensions points and installed extensions.
Registry.AttributeKey	Identifies attribute.
Registry.RegisteredAbout
Registry.RegisteredEventHandler
Registry.RegisteredExtension<A extends Action>	Internal representation of an extension.
Registry.RegisteredExtensionPoint<A extends Action>	Internal representation of an extension point.
RelatedItemAnnotationColumn	Related item column that load annotation values from the parent or child items.
RelatedItemColumn	A column action implementation that finds a parent or child item of a given subtype and then get an annotation or other property value from it.
RelatedItemColumn.Specification	Represents a specification for loading a related parent or child item.
RelatedItemColumnActionFactory	Action factory for adding columns to a table that pull data from a parent or child item from an arbitrary location up or down the chain of linked items.
RelatedItemErrorColumn	Related item column that displays an error message.
RelatedItemExtensionColumn	Related item column that get values from an extension.
RelatedItemHelper	Helper class for storing request-scoped objects that may be useful to re-use between multiple columns.
RelatedItemHelper.CloseMyDbControl
RelatedItemListColumn	Related item column that get the item lists that the parent or child item is a member of.
RelatedItemMultiHopColumn	Related item column that get values from multiple hops betweeen child->parent->child.
RelatedItemPropertyColumn	Related item column that get values from parent or child items by specifying a "property path".
RemoteSlotManager	Slot manager implementation that requests slots from another job agent.
RemoteSlotManager.RemoteSlotPinger	Task that is scheduled at regular intervals to send ping commands to the remote host.
Removable	A Removable item is an item that can be flagged as removed.
RemovableData	A removable item is an item that can be flagged as removed.
RemovableUtil
RemoveAllTransformer<I>	Collection transformer implementation that removes all elements in the source collection from the destination collection.
Render	Tag for rendering extensions.
Renderer<A extends Action>	A renderer is an object that knows how to render an action in the client interface.
RendererFactory<A extends Action>	A renderer factory is a factory that can create Renderer objects.
Reporter	This is an utilitiy class for reporters.
ReporterBatcher	Batcher class for reporters.
ReporterCloneBatcher	Batcher implementation that is used to handle cloned reporter information in the dynamic database.
ReporterCloneBatcher.CloneSource	Specifies which source table to use for finding out which reporters that are part of the current experiment.
ReporterClonePropertyData	This class holds information about cloned reporter properties.
ReporterCloneTemplate	A reporter clone template is a definition of which reporter properties/annotations that should be cloned to a per-experiment table in the dynamic database.
ReporterCloneTemplateData	A template for holding information about reporter properties that are/should be cloned in the dynamic database.
ReporterData	This class represents the idea of clone, oligo or some other reporter for a gene.
ReporterFlatFileImporter	A plugin that imports reporter from a flat file.
ReporterFunction	A JEP function class that adds a rep(string) or mrep(string) function to a JEP expression parser.
ReporterList
ReporterListData	This class holds information about a reporter list.
ReporterListExpression	Represents a property of a reporter list in a dynamic query: alias.property.
ReporterListJoin	Represents a join to a reporter list in a dynamic query: leftTable JOIN ReporterListScores ON ...
ReporterListScoreData	This class holds information about the score of a reporter in a reporter list.
ReporterMapFlatFileImporter	A plugin that imports features to an ArrayDesign from a flat file.
ReporterPropertyExpression	An expression representing the property of a reporter.
ReporterScore	Get information about the reporters and their score in a reporter list.
ReporterScoreQuery	This is a temporary solution to query against the reporter list's score.
ReporterScoreQueryWrapper	A query wrapper for ReporterScoreQuery:s.
ReporterScoreResultIterator	This is a temporary solution for returning reporter list scores as an iterator.
ReporterType	This class holds reporter type information.
ReporterTypeData	This class holds reporter type information.
Request	Pass request information to a plugin.
RequestHandler	A request handler object takes care of an incoming request from a JobAgentServerConnection, processes it and returns an answer.
RequestInformation	Get information about the parameters the plugin needs for a particular request.
RequestWrapper	Wrapper for HttpServletRequest that allows us to set proper servlet path and path info attributes for an extension servlet.
ResetMetadataRenderer	Renderer implementation for resetting metadata for the members of a file set.
ResetProcessor	File processor implementation that reset the error flag, class loader, etc.
ResourceBundleFactory	Factory for loading resource bundles.
ResourceBundleWrapper	A wrapper around ResourceBundle objects.
Response	The response interface used by the core.
Response.Status
Restriction	A restriction query element.
Restrictions	A factory class to create restrictions.
RestrictionTransformer	Transformer implementation that is intended to provide a final filtering of target items.
ResultIterator<I>	Return the result of a query as an iterator.
ResultList<I>	Return the result of a query as a list.
ResultSetWork<R>	A work implementation that executes an SQL query on the connection, and returns a value that is picked by a subclass from the resulting ResultSet.
ResultWriter	Interface for quick writing of data from a JDBC result set to a writer.
ResultWriterFactory	Interface for factories that knows how to create result writers.
ResumableConnectionManager	An extension to the ConnectionManager interface that add support for specifying a start offset when downloading the external file.
RethrowErrorHandlerFactory	Extension to the logging error handler factory that create error handlers that re-throw the original exception.
ReturnClassFilter	Filter implementation that checks if the items returned by a EntityQuery are compatible with the specified class.
RlikeRestriction	Checks if an expression matches a regular expression: e RLIKE regexp (MySQL) or e ~ regexp (Postgres).
Role	This class is used to represent roles.
Role.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return roles where the logged in user is a member unless the logged in user has generic read permission.
RoleData	This class holds information about a role.
RoleKey	This class is used to represent a role key.
RoleKeyData	This class holds information access privileges for roles.
RoleKeys	Class for mapping the RoleKeys table.
RootRawBioAssay	Represents the use of a raw bioassay in an experiment.
RootRawBioAssayData	This class holds the link between experiments and raw bioassays including an annotation set that is representing the experimental factor values.
RootRawBioAssayLoader	Node loader implementation for root raw bioassays.
Row	This tag defines a new row in the table.
Rows	This tag is a place-holder for <tbl:row> tags.
RssNewsFeed	A servlet that generates a RSS feed from the public news on the BASE server.
RunnableInheritAnnotationsManager	Utility class for processing multiple items with a InheritAnnotationsManager in a separated thread with progress reporting.
Sample	This class is used to represent sample items.
SampleData	This represents a sample.
SampleImporter	Plug-in for importing sample items in a batch.
SampleLoader	Node loader implementation for samples.
SampleToBioSourceTransformer	Source item transformer that transform sample items to their parent biosources.
SampleToChildSampleTransformer	Source item transformer implementation that transform sample items to their child sample items.
SampleToExtractTransformer	Source item transformer that transform sample items to their child extract.
SampleToParentSampleTransformer	Source item transformer implementation that transform sample items to their parent sample items.
SampleValidator	Validator implementation for sample.
SavePointWork<R>	A wrapper work that protects a parent work with a savepoint.
ScatterPlot	A simple plot utility for generating scatter plots without the need to delve deep into the JFreePlot package.
Scheduler	This class is a cousin to the standard Timer class but only allows scheduling of tasks.
SchemaExistsWork	A work implementation that checks if a given catalog+schema exists in the database or not.
SchemaGenerator	Replaces the Hibernate SchemaExport and SchemaUpdate tools.
SchemaGenerator.CollectSqlTarget	Helper class used for collecting SQL statements generated by Hibernate schema creation/update tools.
SchemaGenerator.Mode	The installation mode.
SchemaGenerator.SqlStatement
SchemaVersionData	This class holds information about the current schema version of the database.
ScoreFunction	A JEP function class that adds a score(reporterListId) function to a JEP expression parser.
Scripts	Tag for creating <script> tags from a JspContext.
ScrollIterator<E>	This is an iterator view of the result from a query using the Hibernate ScrollableResults object.
SecondPassSectionSpotsParser	The second pass of the 'spots' section extracts spot and extra value data.
SectionAction	Action that inserts a new section in a jsp page.
SectionAssaysParser	Parses the 'assays' section of a BASEfile with bioassay set spot data.
SectionBean	A simple bean-like implementation of the SectionAction interface.
SectionReporterListParser	Parses the 'reporterlist' section of a BASEfile.
Select	This tag is used to display a selection list of items.
Select	A selection query element.
SelectedExpression	An expression representing an already selected expression.
Selects	A factory class to create select expressions.
SequenceFilenameGenerator	File name generator implementation that generates file names using a simple numerical counter.
SerialBaseFileExporter	Exporter implementation that exports bioassay set data as a serial BASEfile.
SerialBfsExporter	BFS exporter implementation that exports spot data in serial format.
SerialSpotIntensityEventHandler	Event handler that extracts spot intensity information from serial BFS data files and inserts the values to a spot batcher.
ServiceControllerAction	Action for controlling services installed under the extensions system.
Services	Utility class for starting and stopping services.
ServiceSessionControl	A special session control implementation used for services.
ServiceSessionControl.FlushSessionAction	Flushes the given session before the transaction is committed.
ServiceSessionControl.ServicesKeyring	Our own keyring containing the only permission: Permission.ACT_AS_ANOTHER_USER.
ServicesEventHandler	Event handler for managing services when new extension are added or existing extension are updated or deleted.
ServicesUtil	Utility class for the "services" extension point.
ServletExportOutputStream	An extension to the ExportOutputStream class which directs the output to the response stream of a HttpServletResponse object.
ServletLoader	Loads servlet definitions from an XML file.
ServletWrapper	A wrapper class for servlets defined by extensions.
ServletWrapperKey	Key implementation used to identify servlets.
Session	A session represents the time between login and logout for a single user.
Session.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return sessions for the currently logged in user unless the logged in user has generic read permission.
SessionControl	This class handles user sessions.
SessionControl.ClientInfo
SessionControl.LoginInfo	Internal class to hold information about the logged in user.
SessionControl.SettingInfo	Internal class to hold information about a setting
SessionControl.UnverifiedDeviceInfo	Class for storing temporary device information for a user that has been authenticated but before a device has been verified.
SessionData	This class holds information about a session.
SessionFactoryConfiguration	Deprecated. In 3.8, use ServiceSessionControl.createSessionFactoryConfiguration(String, String, int, ClassLoader) instead
SessionWrapper	Wrapper around Hibernate sessions that includes a query cache.
Setting	This is the base class for all setting items.
SettingData
Settings	Class for keeping settings for the extensions system.
Severity	Severity levels for a validation rule.
Shareable	An Shareable item is an item which can be shared to other User:s, Group:s and Project:s.
ShareableData	A shareable item is an item which can be shared to other users, groups or projects.
ShareableUtil	Utility methods that will make it easier to implement the Shareable interface, including data validation.
ShareableUtil
SharedData	This class extends the OwnedData class and implements the ShareableData interface.
SharedItem	This class inherits from the OwnedItem class and implements the Shareable interface.
SharedToRestriction	A special restriction that works on Shareable items.
ShortWriter	Database-independent writer implementation that writes short values from a result set.
ShutdownSignalSender	A signal sender implementation that is used by the system when shutting down.
Signal	Represents a signal that can be sent to a class implementing the SignalTarget interface.
SignalException	Base class for all signal exceptions.
SignalHandler	A signal handler is an object that is able to receive and act on signals.
SignalReceivedException	This exception can be thrown by signal handlers when one or more signal has been received.
SignalReceiver	A signal receiver is a class that knows how to receive a Signal from a SignalTransporter and how to distribute this to a SignalHandler.
SignalRequestHandler	This is a request handler for the signal commands.
SignalSender	A signal sender is responsible for sending a signal to a signal handler.
SignalTarget	This interface should be implemented by classes that are able to receive Signal:s.
SignalTransporter	A signal transporter is a class that knows how to send a signal to a specific SignalReceiver implementation.
SimpleAbsoluteProgressReporter	This is a simple implementation of the AbsoluteProgressReporter interface, which simply remembers that last values.
SimpleDynamicField	Represents an exported data field.
SimpleErrorHandler	A simple error handler that either ignores all errors or re-throws them.
SimpleExport	Export plugin for exporting data from table listings in the web client.
SimpleJepFunction	A simple base class for registering a JEP function by name and number of parameters.
SimpleProgressReporter	This is a simple implementation of the ProgressReporter interface, which simply remembers that last values.
SimpleSignalProgressReporter	This class can be used to report progress and hold signal receiver for those export plugins that download immediately.
SimpleSignalSender	A signal sender implementation that sends a specific signal to all handlers that supports it.
SimpleStringDetector	A simple string detector implementation that works with two strings.
SingleExtensionFilter	A filter implementation that enables a single extension and disables all other.
SingleFileValidationAction	Base class for validators that works on single files of a known data file type.
SkinAction	Action for adding skins to BASE.
Slot	Represents a slot that has been assigned to a job.
SlotManager	A slot manager is responsible for slot assigment to jobs.
SnapshotManager	Manager for annotation snapshots.
SocketSignalReceiver	A signal receiver implementation that listens on a socket for incoming signals.
SocketSignalTransporter
SocketUtil	This class contains some useful methods when working with sockets.
Software	This class is used to represent individual software items and information about them.
SoftwareData	This class holds information about a software.
SoftwareLoader	Node loader implementation for software.
SoftwareValidator	Validator implementation for software.
SourceItemTransformer	Implementations are responsible for transforming a set of source item ID:s into a set of related target item ID:s.
SourceItemTransformerChain	Chains together one or more source item transformers.
SourceItemTransformerFactory	A source item transformer factory is responsible for creating SourceItemTransformer:s that can transform between the supported SourceItemTransformerFactory.getSupportedSourceItems(SyncFilter.SourceItemTransform) to the specified SourceItemTransformerFactory.getTargetItem().
SourceItemTransformerWithCache	This is a wrapper transformer factory that can be applied to any other factory in order to provide support for caching.
SourceItemTransformerWithCache.TransformerWithCache
SpecialQuery<C>	A special HQL query implementation that can return almost any kind of object.
SpotBatcher	Batcher class for per-spot intensity values for bioassaysets.
SpotExtraValueBatcher<I>	Batcher class for per-spot extra values.
SpotIntensityParser	A spot intensity parser is responsible for parsing and extracting spot intensity data on a row-by-row basis from a BASEfile.
SqlColumnExpression	An expression representing the column in a database tabe: alias.column.
SqlQuery	This is a query that is using SQL as the query language.
SqlResult	This interface represents a single row in the results of a SqlQuery.
SqlResultIterator	Return the result of a SqlQuery as an iterator.
SqlResultList<I>
SqrtExpression
SquareRootConverter	Convert SquareRoot function to a Query API Expression.
SSLUtil2	Utility class for working with SSL connections.
StandardFieldConverter	Default field converter implementation that works mainly by checking names and/or external id values of formulas, extra values, experimental factors etc.
StartPageAction	Action for selecting the start page that should be displayed after logging in to BASE.
StartPageBean	A simple bean-like implementation of the StartPageAction interface.
StartRequestHandler	This is a request handler for the start command.
StartServiceRenderer	A renderer that starts the service of a ServiceControllerAction.
StartStopServlet	Servlet listener for starting BASE when the web server is started and stopping BASE when the web server is stopped.
StatelessSessionWrapper	Wrapper around stateless Hibernate sessions that includes a query cache.
StaticCache	A cache for storing data to files on the file system.
StaticCache.CleanupTask	A timer task that clean up the cache when it is executed.
StaticCache.LockEntry	Keeps track of a locked cached entry.
StaticCache.LockSafeInputStream	A lock-safe input stream that releases the associated read lock when the stream is closed.
StaticCache.LockSafeOutputStream	A lock-safe output stream that releases the associated write lock when the stream is closed.
StaticCache.State	Inner class for performing the actual release of locks and closing of streams (in/out).
StaticFilter<T>	A filter implementation that either rejects or accepts all object (including null).
StaticKeyManager	A key manager implementation that always selects a specified keystore entry.
StopRequestHandler	This is a request handler for the stop command.
StopServiceRenderer	A renderer that stops the service of a ServiceControllerAction.
StreamCacher	Caches the contents of a stream to a local temporary file.
StringConverter	Convert strings to other data types.
StringConverter	Convert a String constant to a Query API Expression.
StringDetector	Interface for checking if a text line in a file seems to be decoded correctly with the current character set.
StringFormatter	Format a string for output on a web page.
StringLengthComparator	A comparator implementation for strings that sorts them according to their length.
StringMatcher	A wrapper class for fuzzy string matching using the SecondString package.
StringMatcher.FuzzyMatch	Wrapper that holds information about a fuzzy match.
StringParameterType	This class represent a parameter type that is a string.
StringParameterValueData	String parameter value.
StringTooLongException	This exception is thrown when an item's field or a parameter which must be shorter than a specified length exceeds that length.
StringUtil	Utility methods that will make it easier to implement data validation for string attributes.
StylableTag	Generic tag class for tags that want to support id, class and style of the main html object they use.
Stylesheets	Tag for creating <link> tags to stylesheets from a JspContext.
Submenu	This tag defines a menu item inside a drop-down menu.
SubqueryExpression	Expression that returns the result of a query as it's value.
SubtractConverter	Convert Subtract function to a Query API Expression.
SubtractExpression	Subtract one expression from another: e1 - e2.
Subtypable	A subtypable item is an item that can have a subtype.
SubtypableData	A subtypable item is an item that can have a subtype.
SubtypableRelatedItems	Annotation that can be used by Subtypable items to tell about related items.
SubtypeFilter	Filter implementation that accept (annotatable) items of a given subtype.
SuggestedFilenameGenerator	File name generator implementation that uses the suggested file name.
SumExpression	Calculates the sum of an expression: SUM(e)
SupportsPushAnnotations	Annotation (java) that can be used by Subtypable items to enable/disable support for pushing annotations (BASE) to parent items.
SyncFilter	Holds information about a synchronization filter used by an item list.
SyncFilter.SourceItemTransform
SynchronizedSpotDataParser	A parser that synchronizes the parsing of multiple underlying data parsers and a master reporter annotations parser.
SynchronizedSpotDataParser.SynchronizedData	This class holds information that is sent to the event handler when SynchronizedSpotDataParser.DATA_EVENT:s are sent.
SystemData	A system item is an item which has an additional id in the form of string.
SystemItem	A SystemItem is an item which has an additional systemwide unique id in the form of string.
SystemItems	This class is used to map the system id of all SystemData items to the numerical internal id in the current installation.
Tab	This tag defines the title and contents of a single tab inside a tab control.
TabAction	Action that inserts a new tab in a tabcontrol.
TabBean	A simple bean-like implementation of the TabAction interface.
TabControl	This is the main tag for the tab control.
TabCrLfEncoderDecoder	Symmetrical encoder/decoder implementation that replaces newline, carriage return, tab and backslash with \n, \r, \t and \\.
Table	This is the main tag for the table.
TableColumn	Column properties class used to define table columns. Example use in a jsp page:
TableExistsWork	A work implementation that checks if a given table exists in the database or not.
TableInfo	Holds minimal but useful information about a table in the database.
TableInfo.ColumnInfo	Holds information about a single column in a table.
TableInfo.ForeignKeyInfo	Holds information about a foreign key of a table.
TableInfo.IndexInfo	Holds information about an index in a table.
TableInfo.PrimaryKeyInfo	Holds information about the primary key of a table.
TableInfoWork	A work implementation that loads database metadata for a table and returns it as a TableInfo object.
TableWriter	Wraps a writer stream and provides methods for easier writing of tabular data.
Tag	This class represents a tag.
TagData	This represents a tag that is used to mark an extract so that it can be tracked on physical bioassays.
TagImporter	Plug-in for importing tag items in a batch.
TagLoader	Node loader implementation for tags.
TagValidator	Validator implementation for tags.
TarFilePacker	This class packs files into a TAR archive.
TarFileUnpacker	A plugin for unpacking tar, gzipped tar and bzipped tar files to the BASE file system.
TarUtil	Contains utility functions for TAR archives.
TextParameterValueData	Text parameter value.
TextWriter	Generic writer implementation that writes string values from a result set.
ThreadJobExecutor	This is a job executor which executes jobs in the current thread.
ThreadJobExecutor.ShutdownHook
ThreadSignalHandler	An implementation of a signal handler that uses the Thread class to communicate signals back to the SignalTarget.
ThreadTimerTask	Class for forcing the execution of a TimerTask in a new thread.
ThrowableUtil	Utility class for working with Throwable:s.
TimestampParameterType	This class represent a parameter type that is a timestamp.
TimestampParameterValueData	Date+time parameter value.
TimestampWriter	Generic writer implementation that writes timestamp values from a result set.
ToBioSourceSourceItemTransformerFactory	Transformer factory implementation for transforming to biosources.
ToDateExpression	Get the date part of a date or timestamp epxression.
ToDerivedBioAssaySourceItemTransformerFactory	Transformer factory implementation for transforming to derived bioassays.
ToExtractSourceItemTransformerFactory	Transformer factory implementation for transforming to extracts.
Toolbar	This tag creates a toolbar.
ToolbarButtonRenderer	A renderer for toolbar button actions, which displays the action as a toolbar button.
ToolbarButtonRendererFactory	Factory that create ToolbarButtonRenderer objects for rendering ButtonAction:s.
ToolbarUtil	Utility class for toolbar extension points.
ToPhysicalBioAssaySourceItemTransformerFactory	Transformer factory implementation for transforming to physical bioassays.
ToRawBioAssaySourceItemTransformerFactory	Transformer factory implementation for transforming to raw bioassays.
ToSampleSourceItemTransformerFactory	Transformer factory implementation for transforming to samples.
ToSpaceEncoderDecoder	Encoder implementation that replaces newline, carriage return, tab and backslash with a space.
ToStringComparator<T>	An implementation of the Comparator interface which uses the result of the toString method to compare the objects.
ToStringFormatter<T>	A generic formatter that simply formats objects by calling the toString() method.
Transactional	This interface is a tagging interface for items that wants to be notified before a transaction is committed or after it has been completed or rollbacked.
Transactional.Action	Enumeration constants used to tell the item what is going on in the core.
TransactionalAction	Interface that define hooks for callbacks during transaction commit and rollback.
TransactionDetails	Holds information about the curren transaction, such as the logged in user, the active project, the plug-in that is executing, etc.
TransferRateProgressReporter	A progress reporter implementation that has a "side-effect" that limits the transfer rate.
Transformation	A transformation represents an analysis step for an Experiment.
TransformationData	This class holds information about a transformation.
TransformCache	A simple cache implementation for holding the result of source item to target item transformation.
TransformCache.CacheEntry
TransformCache.CacheKey
TransformContext	Transformation context that can be used to keep track of vital information when doing multi-step transformations.
Transformer<T,F>
Trashcan	This class contains functionality to manage items that have been marked for deletion.
Trashcan.CircularRefInfo	Helper class for holding information about a single item, other items using it and other information that is relevant for resolving circular references.
Tree<E>
Tree.Entry<E>	Represents an entry for a node in the tree.
Type	This class defines constants for supported value types in BASE.
TypeWrapper<T extends Type>	Wrapper class for Hibernate types that will try to "hide" issues with the redesign of the type system in Hibernate that is going on in Hibernate 3.5.2 --> Hibernate 3.6.
UMinusConverter	Convert UMinus function to a Query API Expression.
UninstalledFileProcessor	File processor implementation that finalizes the uninstallation of an extensions file by removing it from the settings.
UninstallFilter	Filter implementation that selects only those extensions that was selected for uninstallation by the user in the gui.
Unit	This class is used to represent a specific unit that can be used with annotations.
UnitCache	Helper class for optimized lookup of units by symbol.
UnitCache.CacheKey	Units are cached by (quantity,symbol) combination.
UnitConverter	Interface for converting values between two units.
UnitData	This class holds information units.
UnitSymbolData	This class holds information the symbol that are used with units.
UnitUtil	A utility class for working with Unit:s.
UnknownLoginException	This exception can be thrown when the login is unknown to the authentication server.
UnmodifiableResultList<T>
UnregisterExtensionsProcessor	Extensions file processor implementation that unregisters all extension points and extensions.
UnsafeScriptable	Annotation to be used on an Action interface to mark it as a possible candidate for generating unsafe inline javascripts.
UnsavedItemException	This exception is thrown when trying to use an item that has not been saved to the database in places where this is required.
UnsupportedFileFormatException	Thrown when an import plug-in is forced to use a file that is not of the correct format.
UnsupportedSignalException	This exception is thrown by signal handlers and others that doesn't support a given signal.
Update	This class contains static methods used to update items already in the database.
Update.DropColumnChange	Action that drops a column in a table.
Update.SchemaChange	Action that need to make some change to the database schem after the main transaction in Update.adjustExistingItems(ProgressReporter, int, String, String) has finished.
Upload	The upload servlet is used to handle single file uploads.
UploadAbortedException
UploadedFile	Objects of this class can be used to get information about an uploaded file and save the file to a directory in the filesystem.
UriMetadata	Holds metadata about the data referenced by given URI.
UsableDataFileType	Utility interface for collecting information about data file requirements when used on a certain platform/variant or item subtype.
UsedQuantityMapper	A special mapper for "Used quantity" values.
User	This class is used to represent a user in BASE.
User.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return users which are members of at least one group where the logged in user is also a member unless the logged in user has generic read permission.
UserClientSetting	This class is used to represent a setting valid for a specific user using a specific client application.
UserClientSettingData
UserData	This class holds information about a user.
UserDefaultSetting	This class is used to represent a setting valid for a specific user using any client application.
UserDefaultSettingData
UserDevice	A user device represents a verified device a user may use for accessing BASE.
UserDevice.QueryRuntimeFilterImpl	A runtime filter implementation that limits a query to only return devices for the currently logged in user unless the logged in user has generic read permission.
UserDeviceData	This class holds information about a verified user device.
UserGroups	Class for mapping the UserGroups table.
UserKeys	Class for mapping the UserKeys table.
UserPermissions	This class is used to specify permissions to share an item to users.
UserProjects	Class for mapping the UserProjects table.
UserRoles	Class for mapping the UserRoles table.
Utf8PropertiesResourceBundleControl	ResourceBundle.Control implementation that open property files in UTF-8 format instead of ISO-8859-1 format.
ValidAndNewOrModifiedFilter	Filter implementation for extension files that allow valid and new or modified files to pass.
Validatable	This interface is a tagging interface for items that needs case 2 validation.
ValidatingFileSetMember	This class is a proxy used for holding information about a file set member that is currently undergoing validation.
ValidationAction	Action for validating and metadata extraction from files in a file set.
ValidationOptions	Stores all validation options (ie. validator -- severity) combinations.
ValidationRenderer	Renderer implementation for validating the members of a file set.
ValidationRuleAction	The same as a Validator.
Validator	Placeholder for a validation rule.
ValueConverter	Interface for classes that wants to inspect/convert parameters from the XML file before they are passed to factory setter methods.
Values	Utility class to handle the conversion between data objects and item objects.
Values	This class contains a set of static methods that may be useful for handling strings, ints and other values.
ValueTypeFormatter	Formatter implementation that converts an integer into it's Type representation and the uses name() as the formatted value.
VariableConverter	A value converter that can be used on all setter methods that has been annotated with the VariableSetter annotation.
VariableSetter	Indicates that a factory setter method which takes a string as it's input will have the value scanned by a VariableConverter before the setter method is invoked.
Version	Get information about the BASE version.
VersionedParameter	The key to a plugin configuration parameter.
ViewAndDownloadActionFactory	Facotry for creating the "View" and "Download" actions in file lists.
VirtualColumn	This class is used to define columns in the virtual tables in the dynamic part of the database that are storing analysed data.
VirtualColumnExpression
VirtualColumnExpression.WrappedExpression
VirtualDb	A virtual database represents the set of tables in the dynamic database used by a single experiment to store it's analysed data.
VirtualDbData	This class holds information about a virtual database in the dynamic part of Base.
VirtualTable	This enumeration defines constants that are used to specify different virtual tables in the dynamic part of the database used for analysis.
WasProcessedFilter	Filter implementation that passes all extension files that has been processed according to the information in the given ProcessResults object.
WebClientRegisterExtensionsProcessor	A subclass to the regular extensions processor that adds information about various paths (eg. home path, servlet path) on the web client as variables in the XmlLoader that is used to process the definition files.
WebException	This exception can be thrown on any JSP page in BASE.
Well	A well is located on a Plate and contains a ReporterData.
WellCoordinateFormatter	Formats an internal well coordinate to an external coordinate.
WellData	This class holds information about a well on a plate.
WhenStatement	Create a WHEN statement to be used in a CaseExpression.
WrappedConfigureByExample	This is an extension to the ConfigureByExample interface that allows a plug-in to wrap an input stream with another stream.
WrappedFormatter<T>	Excel formatter implementation that uses the value from any parent formatter and creates a string cell value.
WrappingRenderer<A extends Action>	An extension to the regular renderer interface intended for renderers that wants to wrap an existing renderer to give the result their own touch.
XJspCompiler	Class that enabled compilation of custom JSP pages that are part of an extension that uses classes from the extension JAR file (eg. a JAR file in the /WEB-INF/extensions directory).
XlsxTableWriter	This is a simple wrapper for the TableWriter class to make it create an Excel workbook instead of a CSV file.
XlsxTemplate	Template implementation that exports data to Excel format (xlsx).
XlsxToCsvUtil	Utility class for converting Excel worksheets to CSV-formatted InputStreams.
XlsxToCsvUtil.CellTypeWithInfo
XmlLoader	Loads extension points and extensions from extension definition XML files.
XMLTemplate	A XML template that exports data in a simple one-level XML format.
XmlUtil2	This class contains some useful methods for handling XML documents using JDOM2.
XmlUtil2.Validator	This class is used to handle callbacks from the XML parser.
ZipFilePacker	This class packs files into a ZIP archive.
ZipFileUnpacker	A plugin for unpacking zip and jar file on the BASE file system.
ZipUnpacker	This class can be used to unpack zip files into the BASE directory structure.
Zoom	This tag is used to make it easier to add zoom features on a BASE web page.