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
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.
FastAnnotationLoader<T>
Implements an API for simple and fast loading of annotation values optimized for situations when a single annotation is needed for many (=thousands) of items.
FastAnnotationLoader.FastAnnotation<T>
Holds information about a single annotation value.
FastAnnotationLoader.FastIterator<T>
Iterator implementation that splits the query into multiple calls depending on the max number of parameters that can be used in a query.
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.
LoggableWithoutValues
Getter methods that are annotated with this annotation should not have their old/new values logged in the change history log.
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.
NoAutoUnlinkAnyToAny
Tagging interface for items that are unlikely to be linked via an AnyToAny link.
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.
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.