All Classes and Interfaces
Class
Description
Get information, such as the name, version and authors,
about a plugin.
An implementation of the
About interface, which
complements all getter methods with setter methods.A simple implementation of the
About interface.Convert
Abs function
to a Query API Expression.Calculate the absolute value of an expression: abs(e).
This is interface is an extension to the
ProgressReporter
interface.This is a base class that is useful for all analysis type plugins.
This is an abstract class for batchers that are connected to a
single
DbControl object.An abstract superclass for all exporters that exports spot data from
a bioassay set.
Abstract base class for custom request handler implementations.
Abstract implementation of a data writer factory.
An abstract superclass with default implementations for most
DbEngine
methods.An abstract implementation of the
EntityQuery interface.An abstract base class for all exporter plugins that wish to implement
the
ImmediateDownloadExporter interface.Abstract helper class for implementing
ExportableFieldConverter.Abstract superclass for file names generator implementions that will help
with ensuring that a generator creates unique file names.
This is a base class for all plugins that wants to implement the
FileUnpacker
interface.An abstract base class for all importers that imports data from one or more
flat files.
An abstract implementation of the
HqlQuery interface.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.An abstract base class for plug-ins that import items in batch.
Abstract superclass implementing the
JepConversionFunction
interface.An abstract base class for action factories that may need
to support adding scripts and stylesheets to the rendered
JSP page.
An abstract BASE class for action and renderer factories.
An abstract base class for action factories that may need
to support adding scripts and stylesheets to the rendered
JSP page.
A simple bean-like implementation of the ListColumn interface.
Abstract node loader implementation that does nothing/throws an
exception.
Abstract base implementation of the OnSaveAction interface.
This is an abstract base class useful for developing plugins.
An abstract implementation of the
Query interface.Abstract base class used to cache queries for a session.
Abstract class that provides a default implementation
of the deprecated
AbstractRenderer.render(Action) method.This is a list of the result from a query.
Abstract base implementation of a result writer that simply
store the result set, writer, etc. that are needed later.
An abstract base class for signal handler implementations.
Abstract base class that is useful when implementing signal receivers.
Abstract base class that is useful when implementing signal transporters.
Abstract base class for source item transformers that can be useful
for implementing some common functionality.
Abstract base class for source item transformer factories that can be useful
for implementing some common functionality.
An abstract implementation of the
SqlQuery interface.Return result from the
ValidationAction.acceptFile(net.sf.basedb.core.FileSetMember)
method.This interface should be implemented by a class representing items
which requires the logged in user to have permission to access them.
This exception is thrown if you try to log in
with an account that has expired.
An action is an object that is added to an
ExtensionPoint
by an Extension.Event filter that only passes on events to extension points with a
given action class.
An action factory is an object which knows how to create
Action:s.Iterator for iterating over all actions that will be
created by extensions after a call to
Registry.useExtensions(ClientContext, ExtensionsFilter, String...).Formats a number for output on a web page adapting thwe number of
decimals depending on the order of magnitude of the value.
Collection transformer implementation that adds all elements in
the source collection to the destination collection.
Convert
Add function
to a Query API Expression.Add two expressions: e1 + e2.
Field converter implementation that gives more detailed control how
fields are converted and used in the export.
Utility class with Affymetrix-related functionality.
This is the actual job agent application.
This is the command line controller class for the job agent application.
Signal receiver implementation for job agents that is compatible with
the
SocketSignalReceiver.A factory class to create aggregate expressions.
Event filter that passes all events.
A filter implementation that accpets an object if
all parent filters accepts it.
A simple implementation of a host name verifyer that allows all hosts.
This exception is thrown if you try to log in
but are already logged in.
This is a tagging interface that should be used by all analysis plug-ins that
are filtering data only.
Convert the '&&' operator
to a Query API
Restriction.Combine one or more restrictions with AND: r[0] AND r[1] AND ...
This interface is implemented by all items which can be annotated.
An annotatable item is an item that can be annotated with
name/value pairs.
This interface is implemented by items that can be used to hold annotations
that are intended for other items.
This class extends the
CommonData class and implements the
AnnotatableData interface.This is a helper class for items that need to implement the
Annotatable interface.This class represents an annotation.
The annotation source.
Assay field implementation that exports the annotations of a
bioassay.
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.
A flag indicating what type of change that was made to an
annotation as a result of calling
AnnotationBatcher.setValues(AnnotationType, List, Unit, boolean)Holds information about an annotation for the current item.
Batcher implementation for inserting into tables.
Batcher implementation for updating and deleting from tables.
Restricts a query using annotation values between a low and high
value.
This class holds information about an annotation
An expression representing the value of an annotation.
Filter implementation that finds the annotation snapshot
for a given annotation.
Plug-in for importing annotations from simple text files.
Internal cache for storing annotation values from the file
for a single item.
Identification method implementation that can use an annotation
for identifying items.
Restricts a query using annotation values that exists in a set
of given values.
Join annotations values to the query.
Class for mapping the "Annotations" table with
shortcuts to all 'FooValues' tables.
Node loader implementation for annotations.
Utility implementation for simple loading of primary annotations
via
SnapshotManager.Logger for annotations that logs changes as
updates to the parent item the annotations belong to.
A model container for BFS annotation files.
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.
Parser implementation that parses a BFS annotation files.
Base class for creating restrictions based on annotations.
Options that specify which annotations to consider when searching.
A factory class to create restrictions based on annotation values.
An annotation set is the container for all annotations on an item.
Restriction for matching project-specific annotations against
the currently active project.
This class holds information about a set of annotations.
Logger for annotations sets that detects and logs
changes to inherited anntations as updates to the parent
item that are inheriting the annotations.
A snapshot of an annotation set that is used to store
information as a file.
Comparator for sorting annotation snapshots so that
project-specific annotations appear before default
annotations.
This is a interface that should be implemented by plug-ins that are setting
annotations on items thy create or work with.
Restricts a query using annotation values with a simple expression:
annotation operator value.Stores information about a single primary or inherited
annotation or an inherited annotation set.
Comparator implementation for sorting snapshots
by name of annotation type.
Comparator implementation for sorting snapshots
by name of project.
Objects of this class defines an annotation type.
Objects of this class defines an annotation type category.
This data layer class holds information about annotation type categories.
This class holds information about an annotation type.
Data loader implementation for loading the enumeration
values collection of an annotation type.
Filter implementation that finds all annotation snapshots
for a given annotation type.
Plug-in for importing annotation type items in a batch.
Data loader implementation for loading the item types
collection of an annotation type.
Some utility functions for annotations.
Utility class for working with annotations.
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.
Validator implementation for annotations.
A column action implementation that finds an item linked with
a any-to-any link.
Action factory for adding columns to a table that display items that are linked
with an any-to-any link.
An any-to-any link is a named, directed link from one item to another item.
Helper class for faster loading of any-to-any links between items.
Represents a link from one item to any other item.
Data loader implementation that load any-to-any links.
Plug-in for importing any-to-any links from simple text files.
Class for holding statisics about any-to-any links between items.
Options to specify how the statistics should be generated.
Node loader implementation for any-to-any links.
Logger for any-to-any links that logs changes as
updates to the 'from' item.
Name generator for any-to-any links.
Expression that can be used to filter on the existence or non-existence
of a named any-to-any link.
Validator implementation for any-to-any links.
This class represents the BASE application and is the starting point for
all client applications.
A
Pinger is an object that is used to protect another
object from timing out by automatically pinging it.Startup optins when starting the BASE application.
This class represents the making of a new batch of microarray
slides of a particular design.
This class represents the making of a new batch of microarray
slides of a particular design.
Plug-in for importing array batch items in a batch.
Node loader implementation for array batches.
Validator implementation for array batch.
An array design is a description of the design of a microarray
slide.
This holds information about a block in an arraydesign.
This class holds information about an arrayDesign
Plug-in for importing array design items in a batch.
Node loader implementation for array designs.
This class connects the ArrayDesign with its plates and adding an index to that connection.
Validator implementation for array designs.
This class implements the
Iterator interface
for an array of objects.This class represents a physical microarray slide.
This class represents a phycsical microarray slide.
Plug-in for importing array slide items in a batch.
Node loader implementation for array slides.
Validator implementation for array slides.
Sort the result of a query in ascending order by the expression.
Represents a bioassay field that is going to be exported.
Assay field implementation that exports a named property
from a bioassay.
Converts a constant node to an expression.
Converts a function node to an expression or restriction.
Converts a variable node to a parameter expression or null.
Objects of this class are returned by the
AuthenticationManager.authenticate()
method and contains information about the authenticated
user.Gives authentication implementations limited access to the database.
This exception can be thrown when an error occurs during the
authentication.
Action interface for external authentication.
Holds information about the method that was used to verify a user when logging in.
Node loader implementation that automatically loads child nodes.
This class has methods for autodetecting file formats.
Filter implementation that filters a collection of
ContextUtil.ContextResult:s by checking each plug-ins ability to
import a given file.This interface should be implemented by an import
plugin that supports auto-detection of the file
format.
Excel formatter implementation that automatically selects a format
depending on the type/class of the value.
Formatter implementation designed for exporting that generates output
with best supported method depending on their type.
An
AutoJoiner is an object that automatically joins
other tables in query depending on other query elements.Formatter implementation that generates a HTML output trying to
link items with best supported method depending on their type.
This class is used to collect some useful methods for the web client
into a single place.
Exportable field converter that support BASE 1 naming conventions.
This plug-in executes a plug-in from the Base1 system.
This is the base class for exceptions in BASE.
A superclass for exporters that exports spot data to BASEfile format.
Exports bioassay set data as serial or matrix BASEfile:s.
Exporter implementation for the external program executor that
exports data to BASEfile format.
Imports spot data from a serial or matrix BASEfile.
Importer implementation for the external program executor that
imports data from BASEfile format.
Collects information about a BASEfile as it gets parsed
by a
BaseFileImporter.Keeps information about a new child bioassay from
the 'assays' section or 'spot' sections.
Keeps information about headers and more in a 'spot' section.
Parser for serial and matrix BASEfile:s.
A section parser is responsible for parsing and collecting data
that is found in a section in a serial or matrix BASEfile.
File wrapper implementation for files that are located on the BASE file system.
Wraps a writer stream and provides methods for easier
creation of BASEfiles.
Input stream locator implementation that works with files within a given
directory in the BASE file system.
This is an abstract class for batching functionallity.
An abstract base class for all items which are child items to
a
BasicItem parent item.This is the root superclass of all data classes.
This is the root superclass of all item classes.
A filter implementation that matches against the item
that is attached to nodes.
Abstract class that is useful for all node loaders that works
with
BasicItem:s.Node loader factory implementation for
BasicItem node loaders.Node validator factory implementation for
BasicItem node validators.Collection transformer implementation that extracts the ID from
BasicItem:s.A simple node validation implementation that takes care of missing
and denied access to items.
This is a tagging interface only.
Holds information about a batchable property.
The basic interface which all batchers must implement.
Utility class for batching information.
BCrypt implements OpenBSD-style Blowfish password hashing using
the scheme described in "A Future-Adaptable Password Scheme" by
Niels Provos and David Mazieres.
Generic action factory class that can generate instances of
actions if there exists a bean-like implementation of the
action class.
Compare if one expression falls between to other expressions: e BETWEEN low AND high.
Base class for exporting spotdata to BFS format.
Exports bioassay set data to BFS format.
Exporter implementation for the external program executor that
exports data to BFS format.
Imports spot data from a serial or matrix BFS.
Importer implementation for the external program executor that
imports data from BFS format.
Interface that it is recommended that all BFS parsers should implement.
Represents the current intensities of raw data after some transformation
has been applied to it.
This class holds information about a bioassay.
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.
A bioassayset represents the current intensities of the raw data
after some
Transformation has been applied to it.This class holds information about a bioassayset.
This is a utility class for plugins that filters bioassay set data.
This is a utility class for
BioAssaySet.This class is the root class for biomaterials.
This class represents an event in the life of a
MeasuredBioMaterial.The type of the event.
This class is used to register events for measured biomaterials.
Logger for biomaterial events that logs UPDATE:s to
CREATION and HYBRIDIZATION events as updates to their
parent biomaterial/hybridization.
Class for holding information about a parent biomaterial
that was used in an event that created a child biomaterial or
a physical bioassay.
Data class for holding information about a parent biomaterial
that was used in an event that created a child biomaterial or
a physical bioassay.
Formatter to handle
BioMaterialEventSource items.This class is represents physical bio-plates.
This class holds information about a bioplate
A bioplate event represents something that happened simultaneously to the biomaterial
on one or more bioplates.
This class holds information about a bioplate event.
Node loader implementation for bioplate events.
Holds information about a bioplate that is participating in a bioplate event.
Registers a plate as a participant in a bioplate event.
The type of a bioplate event defines what happened in the event.
Each bioplate event must have a type that defines what happened.
Plug-in for importing bioplate items in a batch.
Node loader implementation for bioplates.
Name generator implementation for
BioPlate items.This class represents the type of a bio-plate.
This class holds information about a biomaterial plate type.
Validator implementation for bioplates.
This class represent biosource items.
This represents a biosoruce which is the starting point of
all biomaterials.
Plug-in for importing biosource items in a batch.
Node loader implementation for biosources.
Source item transformer that transform biosource items to their child
samples.
Validator implementation for biosources.
A biowell is located on a
BioPlate and contains a MeasuredBioMaterial.The lock mode for a well is determined by the plate's bio
plate type.
This class holds information about a bio well on a bio plate.
Node loader implementation that load biomaterial on a bioplate.
Name generator implementation for biomaterial items
that are located on a biowell.
A
BlockInfo object is used to represent the uniqe identifiers of an
ArrayDesignBlock.This tag defines the body section of a page.
A constant boolean expression.
Formats a boolean value.
Enum for holding the various types of boolean output.
This class represent a parameter type that is a boolean.
Boolean parameter value.
Database-independent writer implementation that writes boolean
values from a result set.
Declare the names of resource bundles used by the web client.
This tag is used to display a clickable button.
This tag creates a button on a toolbar.
Actions represented as buttons in a toolbar.
A simple bean-like implementation of the
ButtonAction
interface.This tag is used to group buttons together (horizontally)
and make them all have the same size.
Generic writer implementation that writes byte-array values
from a result set.
This class wraps the
TarFilePacker in a BZIP2 stream, creating
a tar.bz2 file.A plugin for unpacking a bzip2 compressed file to
the BASE file system.
This is a filter that sets the "Cache-Control" header
in the http response.
A special button tag that is used to display a "Calendar" button
that opens a popup for selecting a date and time.
An SQL case expression:
This plug-in can import probesets from Affymetrix CDF files as reporters.
Action for validation of CDF files in a file set.
Action factory for creating CDF file validators.
Helper class for working with Affymetrix CDF files.
This tag defines a new cell in a row.
Helper class for keeping track of formatting styles that has
been created for given Excel worksheet.
This tag adds a value to a cell in a row.
Action for validation of CEL files in a file set.
Action factory for creating CEL file validators.
Helper class for working with Affymetrix CEL files.
An implementation of the ProgressReporter interface that chains
to another progress reporter while recalculating the percentage
values.
Holds information about a single transaction.
Represents the changes made in a single transaction.
Represents a change (creation/update/deletion) made to a
single entity in a transaction.
Data loader implementation for old and new values in the
change history which are protected by special permissions.
Data loader implementation for loading the changed item.
Utility class for working with change history.
Enumeration that represents the type of change that has happened.
Formatter implementation that converts an integer into it's ChangeType
representation and the uses name() as the formatted value.
A JEP function class that adds a
ch(int) function to a
JEP expression parser.This is a filter that sets the character encoding for both the
request and the response.
Utility class for testing if a text stream can be parsed using
a given character set.
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
An abstract base class for all items which are child items to
a
Shareable parent item.Represents the direction to use for loading child nodes in a tree.
Load and create child nodes for a given parent node.
This class is a similar to the JDK
ThreadLocal class,
but stores one object per class instead of one object per thread.Error handler that allows the registration of one or more
error handler for subclasses to
Throwable.Utility class for
Class objects.This class represents a registered client application.
Keeps information about the current context in the client
application that extensions can use to decide what actions to
generate.
This class holds information about a client.
This class is used to represent a setting for
specific client application.
Represents a reporter property that can be cloned to a per-experiment
table in the dynamic database.
An interface that indicates that a query may be used together with
cloned reporter information.
A plug-in that clone reporter annotations to an experiment.
Inputstream filter that closes a given resource whenever the
parent input stream is closed.
Utility class for parsing command line arguments.
Adds a
col() function to Jep.Source item transformer implementation that transform collected extract items
to derived bioassays.
Source item transformer implementation that transform collected extract items
to raw bioassays.
Collect extracts seen on derived bioassays and raw bioassays that
has been loaded by other transformers.
Formatter implementation that formats a collection of values to a
string by concatenating the values with a given separator.
Allows a collection to be transformed by applying some operation to it.
Formatter that adds a small colored box next to a value.
This class is used to generate colors for numerical values.
This class keeps coloring information for items which can be colored when values
are displayed in a client application.
Hold coloring information.
This tag defines a column in the table.
Iterator implementation that returns a single null value and nothing more.
Generate column headers for the columns that has been defined for this table.
Returns the string found in the column given by the index
set in the constructor.
Generate column subtitle header for the columns that has been defined for
this table.
Event filter that only passes on events based on multiple
other event filters.
This is a convenience class that extends the
SharedData class
and implements the NameableData and RemovableData
interfaces.A compact renderer for toolbar button actions, which only
only displays the icon.
Factory that create
CompactButtonRenderer objects
for rendering ButtonAction:s.A comparator implemenation for any Comparable objects.
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.Tagging interface that we need all componenets to implement
so that we are able to export them properly using generic code.
A compound mapper that gets its value by invoking multiple other mappers
which are set in the constructor.
Use this class to access the configuration settings for BASE.
This exception is thrown by the
Config class
if there is a problem with finding or loading the configuration
settings.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.This exception is thrown when trying to use a
DbControl object that has been closed.A connection manager is used to access the contents and metadata about
the resource pointed to by a given URI.
A connection manager factory is responsible for creating connection
managers for some subset of URI:s that is supported.
Collects utility methods related to connection managers.
Connection parameters, such as username/password, that may be needed
to connect to a server.
An implementation of the ProgressReporter interface that writes
all messages to the standard console.
A constant string mapper.
This is a filter that sets the "Content-Security-Policy" header
in the http response.
This is a servlet for posting reports from "Content-Security-Policy" violations.
This class holds context information to help client applications
with storing common settings for tables.
A class with utility methods for plug-ins.
Class for holding the result of a call to the
InteractivePlugin.isInContext(GuiContext, Object)
method.Filter implementation that works on collections
of
ContextUtil.ContextResult:s and return only those
that return true from ContextUtil.ContextResult.isInContext().This is the base tagging interface for items that needs special
attention by the
DbControl object when DbControl.commit()
is called.Keep
JepConversionFunction objects for converting built-in
JEP object to Query API Expression or Restriction
objects.Util class for coordinate transformations in base.
Count the number of values: COUNT(e)
A mapper that crops a string if it is longer than a specified
length.
An extension to the regular request-handler interface that allows
life-cycle control by the job agent.
This tag begins the data section of the table.
Exceptions of this type are thrown when there is an error
from the database.
A data cube is the main unit for an experiment to store analysed data.
Select data from Dynamic#RawParents table.
Represents the column coordinate in a data cube.
This class holds information about a single column in a data cube.
This class holds information about a single data cube in a virtual database.
Represents a set of extra value in a data cube.
This class holds information about an extra value in a data cube.
This represents a filter in a datacube.
This class holds information about a single filter in a data cube.
This represents the layer coordinate in a data cube.
This class holds information about a single layer in a data cube.
Formatter implementation for file sets that lists all member files
of a given file type
Node loader implementation for data files.
This class is used to represent types of files that are used
to hold data instead of importing the data into into the database.
This class hols information about individual files attached
to items that store data in files instead of in the
database.
Validator implementation for data files.
A helper interface for the
SimpleExport to get data
that in some way are associated with an item.Adds a
dataNo() function to Jep.Parser implementation that parses BFS data files.
An implementation of the
Query interface that returns data
objects.A query wrapper for
DataQuery:s.Return the results of a
DataQuery as an iterator.Writer implementation for writing BFS data files.
Factory implementations are responsible for creating BFS data writers
that accepts data for a given owner object.
This exception is thrown when parsing a string into a date failed.
Format a date for output in a client application.
This class represent a parameter type that is a date.
Date parameter value.
Utility methods that will make it easier to handle date values.
Generic writer implementation that writes date values from a result
set.
A
DbControl object is the main object used for communicating
with the database.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.
Information about database-specific options that are not covered by the
Hibernate
Dialect objects.A work implementation that can create, update and drop indexes
on tables.
Log manager implementation that logs changes to the database.
Log manager factory implementationt that logs changes
to the database.
On-save action factory that create actions that print a log message
to System.out for all events.
Provides a default configuration values for GTF file parsing
when none has been provided by the user.
A default DbEngine that is selected if no other can be found.
Default logger for all entities that has been tagged with the
LoggableData interface.A default filter implementation that enables all
extensions and extension points and sorts the
extensions based on the
Extension.getIndex()
values.JEP function that can be used to return the name of a default item in
a project.
This is the default request handler for incoming requests to
a job agent.
A signal handler implementation that can delegate to other signal handlers,
depending on which signal it receives.
Filter implementation for extension files that
allow only deleted files to pass.
A file processor implementation that removes all resources that
was previously extracted from a JAR file.
Utility class for logging use of deprecated taglib attributes.
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.
Plug-in for importing derived bioassay items in a batch.
Source item transformer implementation that transform derived bioassay items
to child derived bioassays.
Source item transformer implementation that transform derived bioassay items
to parent derived bioassays.
Source item transformer implementation that transform derived bioassay items
to physical bioassays.
Source item transformer implementation that transform derived bioassay items
to raw bioassays.
Validator implementation for derived bioassays.
Sort the result of a query in descending order by the expression.
This exception is thrown when trying to use an item
that has been detached from the
DbControl that
manages it.This exception can be thrown when a user is trying to login
from a device that has not been verified.
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.
Cache key implementation that bundles another cache key
with a node direction.
This is used to represent directory items.
This class holds information about directories.
Filter implementation that filters away annotations that
have an annotation type with inheritance disabled.
File processor implementation that disables plug-ins.
Exception that is thrown when a value is not found among a set of allowed
values, for example, when setting an annotation value.
This interface is implemented by items that can use a lot
of disk space.
A diskconsumable item is an item that occupies a lot of diskspace and
should be controlled by the quota system.
File wrapper implementation for files that are located on the local disk.
Input stream locator implementation that works with files on the
local file system.
This class is used to represent the disk usage of
DiskConsumable items.This class holds information about a users and/or groups disk usage.
Get disk usage statistics for the BASE server.
Convert
Divide function
to a Query API Expression.Divide one expression by another: e1 / e2.
This class represent a parameter type that is a double.
Double parameter value.
Database-independent writer implementation that writes double
values from a result set.
Transactional action that can drop a table from the dynamic database
after a successful commit and/or rollback.
This is dummy job executor implementation which just sets the status
of each job to
Job.Status.DONE without actually
executing the job.A dummy service implementation that prints out the current
time on
System.out every x seconds (default = 10) when
the service is running.This exception is thrown when a plug-in configuration wizard
is open and the user tries to open a second one.
A factory class to create expressions, joins, etc. that are only used
by queries in the dynamic database.
Class for holding the name and value of a dynamic action attribute.
Supplementary interface for actions that need to be able to support
dynamic attributes that are not pre-defined by the actual
Action.Abstract base class intended to be extended by
Action implementations
that want to support dynamic action attributes.Represents a query for extra values in the dynamic database.
Represents a spot or reporter field that is going to be exported
from a bioassay set.
This interface is used together with the
BioAssaySetFilterUtil
class to help a plugin filter the data of a bioassay set.Represents a join between two virtual tables in a dynamic
query:
leftTable JOIN rightTable ON columns.Represents a query for position information against the dynamic database.
This class collects
AutoJoiner:s for DynamicPositionQuery
queries.Joiner for extra values.
Joiner for reporters
Auto joiner for reporter lists.
Represents a query against the dynamic database.
A query wrapper for
DynamicQuery:s.Represents a query for raw data in a "dynamic" way.
Auto joiner for raw bioassays.
Auto joiner for reporters.
Auto joiner for reporter lists.
Represents a query for reporter data in a "dynamic" way.
Auto joiner for master reporter table.
Auto joiner for reporter lists.
Creates a restriction that compares a dynamic column with a constant
value:
tableAlias.column = value or
queryRootAlias.column = valueAn iterator view of the result of an
AbstractSqlQuery.Represents a query for spot information in the dynamic database.
This class collects
AutoJoiner:s for DynamicSpotQuery
queries.Joiner for extra values.
Joiner for raw data.
Joiner for reporters
Joiner for reporter lists.
This class is used to collect some useful methods for building and executing
dynamic queries.
Utility class for handling edit-dialog related extensions.
Utility class for email sending.
Interface for encoding and decoding strings to make them work in a certain
context.
Utility functions for encoding/decoding strings.
Creates
DbEngine objects based on the Hibernate dialect.An extension to the thread signal handler that supports any number of
signals.
Contains detailed information about the changes made to an
entity during a transaction.
Entity logger implementations are created by a
LogManagerFactory
when a change to a logged entity has been detected.This class collect some static information related to logging for
entities.
This a HQL query that return enitities, ie. items.
Wraps a hibernate query and adds checks so that unsaved items aren't
added to the query as parameters.
Converted implementation that create JSON objects
with the NAME of enumeration.
Formatter implementation that converts an enum constant
into it's name() as the formatted value.
Compare if two expressions are equal: e1 == e2, or
e1 IS NULL
Convert the '==' operator
to a Query API
Restriction.A filter implementation that only accepts an object if it is
equal (using Object.equals()) to a given object.
Helper class for implementing equals and hash code calculations in
classes.
An interface to make it easier to implement dynamic error handling.
Error handlers are created by the factory for each request/use of
an extension point.
Error handler factories are responsible for creating error handlers.
A filter for events before they are sent to an
EventHandler.Event handlers are used for reacting to various parsing events when
parsing BFS files.
An event handler receives events about things happening to
extensions and extension points.
Defines an event type that is sent in event notifications to event
handlers.
Represents different types of event.
Event filter that only passes on events of a specifiec event
type.
Interface that is intended to be implemented by formatters
that also want to support generating output for excel.
Represents a value and style format that should be written to
a cell in an excel worksheet.
Represents a blank cell.
Represents a cell with a numeric value.
Represents a cell with a date value.
Represents a cell with a numeric value without decimals.
Represents a cell with a numeric value.
Represents a cell with a string value.
This tag is a wrapper that catches any errors in it's
body and outputs the error message.
Interrupt handler implementation that always throw a
SignalException.A JDBC work implementation that executes an update/insert/delete
query and returns the number of rows that was affected by the query.
Convert
Exp function
to a Query API Expression.An experiment is the starting point of the analysis in BASE.
Node loader implementation for experimental factors.
Validator implementation for experimental factors.
Holds information about an experiment.
A class for storing settings and doing work related to the experiment
explorer tool in the web interface.
An annotation group contains statistical information about the spot
values falling into the group.
An annotation summary object keeps track of intensities and other
statistical information based on the annotation group.
Creates a list of (numerical) values that can be used as the
right-hand operand to the IN operator.
Cache entry for a reporter with positions.
Plot servlet for generating plots from experiment explorer.
Uses as a column key in the plots.
Node loader implementation for experiments.
Validator implementation for experiments.
Calculate the exponential of an expression: exp(e).
Interface that represents an exportable field.
Defines method for converting a string representation to
an exportable assay or dynamic field that can be used with
AbstractBioAssaySetExporter implementations.Utility class with factory methods that helps with the creation
of exportable fields.
Formatter implementation that formats an exportable field
by returning the column title.
An output stream used for immediate download from export plugins.
A helper interface for the
SimpleExport class to make it
easier to output exported data in different formats.An expression query element.
A factory class to create expressions.
A selection query element that selects an expression, optionally
giving it an alias.
This class is inherited by data classes that supports
per-server additions of columns to the underlying database table.
Adds extra information to the About interface.
This class is used for reading XML files with information
about extended properties.
Holds information about an extended property for a
class.
This class is used to interface with Hibernate for extended
properties.
This class implements the Hibernate
Getter and
Setter interfaces.Formatter for extended property values.
Used to create links from extended property values.
Represents a concrete implementation of an extension to an
extension point.
A bean-like implementation of the
Extension interface.Tag for generating content from extension columns.
Wrapper for node loaders that automatically hooks into the
extension system when loading child nodes for a parent node.
Invokation context for an extension.
Event filter that only passes events for a specific extension.
Key implementation used to identify extensions.
Wrapper for node validators that hooks into the extension system when
validating nodes.
An extension point is a place, defined by a client application, that
can be extended.
A bean-like implementation of the
ExtensionPoint
interface.Invokation context for an extension point.
Event filter that only passes events for a specific extension point.
Filter implementation that can be used to match extension
points and extensions based on the ID of the extension point.
Key implementation used to identify extension points.
Controller class for the extension system in the web client.
Represents a file with extensions in it.
An extensions file with additional methods that allows adding
or modifying information in the underlying extensions file.
Interface that is used to request a callback for each extensions file
managed by an extensions manager.
Allows extensions and extension points to be enabled/disabled
and sorted externally.
A signal transporter implementation send all signals to extensions
extending the "net.sf.basedb.core.signal" extension point.
Object of this class handles a single invokation of the extensions
for one or several extension points.
Instances hold the log entries for a single extension.
A simple logger that services can use to send log message to the BASE
core.
An extensions manager is responsible for handling a group of
extensions in the form of files stored in the file system.
Compare URI:s so that 'jar:' scheme always are listed first.
This servlet is acting as a proxy for requests to extension defined
servlets.
Utility class collecting some useful functions related to
extensions.
This class is used to represent extract items.
This represents an extract.
Plug-in for importing extract items in a batch.
Node loader implementation for extracts.
Name generator implementation for
Extract
items.A file processor implementation that extracts resources from JAR files.
Source item transformer implementation that transform extract items to their
child extract items.
Source item transformer implementation that transform extract items to their
parent extract items.
Source item transformer implementation that transform extract items to physical bioassays.
Source item transformer that transform extract items to their parent
samples.
Validator implementation for extracts.
Implementors are responsible for importing extra files specified in
the BFS metadata file into the BASE file system.
Parser that is responsible for extracting extra float values
from the 'spot' section in a BASEfile.
Class for holding extra information about a user.
Represents extra values attached to a
BioAssaySet.Defines which coordinates in the data cube the extra values are attached to.
This represents the use of extra values that have been calculated for a bioassayset.
Represents the value of an extra value in a dynamic query:
alias.value.A JEP function class that adds a
xtra(int) function to a
JEP expression parser.Represents a join to an extra value in a dynamic query:
leftTable JOIN extraValueTable ON ...Defines extra values that can be calculated by plugins or some other
application and inserted as part of a
BioAssaySet.This represents the definitiona of an extra value type
that can be calculated by a plugin.
Key implementation used for configuration parameters for factories.
Holds information about a failed validation.
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.
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.
Holds information about a single annotation value.
Iterator implementation that splits the query into multiple calls depending
on the max number of parameters that can be used in a query.
This is a utility class for Features.
Batcher class for Features or AffyFeatures.
Represents the coordinate of a feature on an array design.
This class holds information about a regular feature.
This enumeration defines constants that are used to specify
which method to use for identifying features on an array design.
Information about a the login/password fields on the login form.
This class is used to represent individual file items
and information about them.
A
FileAttachable item is an item that can have
a File attached to it.A fileattachable item is an item which can have a
File
attached to it.Runnable implementation that copies data from an input stream
to an output stream when executed.
This class holds information about a file.
An extension to the
ExportOutputStream class which
directs the output to a File in BASE.Plug-in for importing file items in a batch.
An extension to the
ImportInputStream class which
reads from a file on the BASE file system.Node loader implementation for files.
File name generators are used together with
DataWriterFactory
implementations to generate file names for BFS data files.Importer implementation for the external program executor that
uploads all created files to BASE and attaches them to a child
bioassay set.
This interface should be implemented by classes that can pack files and directories
from BASE file system.
This class represent a parameter type that is a file.
Formatter implementation that format
File items
to their complete paths.This class represents a file server that is used to store
external files.
File entries that are external files can be linked to a file server.
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.
This class collects all files used to store data
for an item that store data in files instead of in the
database.
This class represents a file that is member of a file set.
This class hols information about individual files attached
to items that store data in files instead of in the
database.
Data loader implementation that load the files in a file set
in
FileStoreEnabled items.Logger for file set members that logs changes as
updates to the parent item the file belong to.
Since a FileSetMember isn't Nameable we construct the name
by combining the name of the file type and the name of the
file.
This interface is implemented by items that can use files instead
of the database for storing data.
Items implementing this interface can store data in files
instead of in the database.
Utility class working with
FileStoreEnabled items.This is a helper class for the
PlatformData item to
help with the Hibernate mapping to PlatformFileTypeData
object.This interface should be implemented by plugins that can unpack a single compressed
file into the BASE file system.
Objects of this class are used to handle file upload from browsers using
the standard mechanism described in RFC1867.
This class contains information extracted from the section headers for a form field
or file upload field.
This class contains information about the read status on the ServletInputStream
Objects of this class holds information about the progress
of an upload.
This class collects some useful methods for file and stream
handling.
Validator implementation for files.
This class is used for holding information about a file that is beeing displayed
in the GUI in some context.
Helper class for handling the "file-viewer" extension point.
Wrapper around files that provide some basic information about the file.
A filter is something that selectes or rejects an object
due to some property of it.
Batcher class for filtered bioassaysets.
Utility class for working with and using filters.
Parses a 'spots' section of a BASEfile with bioassay set spot
data.
Holds information about a suggested fix to a failure.
A simple implementation of a toolbar button action factory that
creates the same fixed button for all users
not using any context information.
A simple implementation of a menu item action factory that
creates the same fixed menu item for all users
not using any context information.
A simple action factory implementation that always include the
given skin on all pages.
A simple start page action factory.
A simple implementation of a tab action factory that
creates the same fixed tab for all users not using any
context information.
This class can be used to parse data from flat text files and from
Excel workbooks in xlsx format.
This class holds data about a line parsed by the
FlatFileParser.hasMoreData() method.Subclass that is used to return data when the source file is an Excel
file.
This class holds data about a line parsed by the
FlatFileParser.parseHeaders() method.Represents the type of a line matched or unmatched by the parser.
Convert a
Number constant
to a Query API Expression from the float value.A constant float expression.
This class represent a parameter type that is a float.
Float parameter value.
Database-independent writer implementation that writes double
values from a result set.
An alternative layout for tables which contains only one row.
A
Formatter formats an object to a string suitable for
output in a client application.Factory class for creating formatters for various data types.
This is autility class for getting and setting formatter-related settings for
the logged in user.
This class represents a formula.
The average method used for the values of this formula.
The parser used to parse the formula.
The type of formula indicats in which situations it can be used.
This class holds information about a formula used in the analysis of raw data
and bioassay sets.
This plugin provides methods to filter a bioassayset based on
formulas entered by the user.
A signal handler implementation that forwards the signal to
another signal transporter.
Extension to the JEP parser that provides better error handling for
unknown functions.
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.
Represents an unknown function that appears in an expression.
Exports an array design with features to a GAL file.
Generic implementation of a data writer factory that create
files in the BASE file system.
Generic implementation of a data writer factory that create
files on the local file system.
Extra file importer implementation that imports file to a specified
directory in the BASE file system.
Generic spot intensity parser implementation that
looks for 'intensity1', ..., 'intensityN' data columns for any
number of channels.
Implementation for holding a generic overview of items.
Utility class for geographic location.
We only accept "200" status response, "application/json" content type
and not more than 1K bytes (should be a lot less under normal operations).
Calculates the geometric mean of an expression: EXP(AVG(LN(e)))
A work implementation that return the name of the current database catalog.
This class is used to represent a global default setting.
Convert the '>' operator
to a Query API
Restriction.Convert the '>=' operator
to a Query API
Restriction.This class is used to represent groups.
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.
This class holds information about a group.
Class for mapping the
GroupGroups table.Class for mapping the
GroupKeys table.This class is used to specify permissions to share an item to
groups.
Class for mapping the
GroupProjects table.Compare if one expression is greater than or equal to
another: e1 > e2.
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.
Reporter importer implementation that create reporters from information
in GTF files.
Import features to an array design from a GTF file.
Action for validation of GTF files in a file set.
Action factory for creating GTF file validators.
Compare if one expression is greater than another: e1 > e2.
This is a helper component for the
PluginDefinitionData item to
store the contexts where a plugin can be used in a client application.This class wraps the
TarFilePacker in a GZIP stream, creating
a tar.gz file.A plugin for unpacking a gzipped file to
the BASE file system.
This class is used to represent individual hardware items
and information about them.
This class holds information about a Hardware.
Node loader implementation for hardware.
Validator implementation for hardware.
Restricts a query by the presence of absence of an annotation.
A filter implementation that checks if a value for a given attribute
exists on a node.
This tag defines the header section of a page.
This tag defines a header column among the colummns
or on a row.
Container tag for a single header row in a table.
Container tag for header rows in a table.
This tag is used to make it easier to add help features on a BASE web page.
This class is used to represent a help text for
a client application.
This class holds information about an help item.
This plugin exports helptexts stored in the database to a XML-file.
This plugin imports helptexts into database from a XML-file.
This class collects most of the functionality we need for using Hibernate.
Helper class for defining filters at runtime.
This tag defines a hidden input element that should be included in
the form.
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.
A simple plot utility for generating histogram plots without
the need to delve deep into the JFreePlot package.
Represents a single bin in a histogram.
An dataset implementation for histogram data that allows
us to send data to JFreeChart the way we want.
Collects information about one histogram series.
Helper class for storing histogram data that needs to split into
different annotations.
Defines what to to plot on the y axis in a histogram plot.
A factory class to create expressions, joins, etc. that are only used
by HQL queries.
An expression representing the elements collection of a
collection of a Hibernate entity: elements(alias.property).
An expression representing a Hibernate entity.
Entity parameter expression.
A class holding an expression or a restriction where a prefix
can be used to represent a root alias in a HQL.
An expression representing the index collection of a
map or list of a Hibernate entity: index(alias.property)
Inner joins an association to another item:
JOIN <alias.property> <joinedAlias>
to the query.Left joins an association to another item:
LEFT JOIN <alias.property> <joinedAlias>
to the query.An expression representing the property of a
Hibernate entity: alias.property or alias.property[index]
This is a query that is using HQL (Hibernate Query Language) as
the query language.
This class collects
AutoJoiner:s for HqlQuery
queries.Joiner for annotations.
Joiner for reporter lists.
Right joins an association to another item:
RIGHT JOIN <alias.property> <joinedAlias>
to the query.An expression representing the size of the of a
collection of a Hibernate entity: size(alias.property).
This class contains a set of static methods that may be useful
in a web application for handling text/HTML strings.
Connection manager implementation that support HTTP and HTTPS URI:s.
Action factory for http connection manager factory.
Connection manager factory for HTTP and HTTPS URI:s.
Useful methods related to HTTP stuff in general and
Apache HTTP components in particular.
This tag is used to make it easier to display icons
on a BASE web page.
An
Identifiable item is an item which has an
id a type and a version.An identifiable item is an item which has an
id and
a version.Formatter to handle
Identifiable items.Simple "converter" implementation that simply return the same object.
Encoder decoder implementation that doesn't encode or decode
anything.
A filter implementation that only accepts an object if it is
identical (==) to a given object.
A unit "converter" that doesn't modify the values.
Restriction that filters on a list of ID values:
id IN (a, b, c, ....)
Represents an 'identification method', eg. a way to find an item among
the items that already exists in the database.
Convert
If function
to a Query API Expression.Processor implementation for ignoring files.
Filter implementation that selects only those extensions that
was selected for ignoring by the user in the gui.
An importer plug-in for Illumina raw data.
Holds a RawBioAssay and the RawDataBatcher to use for import and the
Mapper for all it's data columns.
This is a filter that remaps request to images to some other image.
Remaps image URLs.
Utility class for working with image remapping.
This interface should be implemented by export plugins
that supports immediate download to the client application.
An input stream used for input to import plug-ins.
This enumeration defines constants that are used to specify which items
to include in a query.
A section action factory implementation that includes another resource
as the content of a section.
A tab action factory implementation that includes another resource
as the content of tab.
Cache key implementation that bundles another cache key
with an index.
This is a request handler for the
info and status
commands.Manager class for batch inheriting of annotations.
Filter for finding annotation types to process.
Filter used to find parent items that are annotated and for which the current user has
permission to USE the annotations.
Class for holding rules for how annotations should be inherited from
parent items.
This tag is used to make it easier to add <input> elements
on a BASE web page.
An input stream implementation that reads one or more input streams
sequentially.
Defines a generic interface for opening an input stream from a named
resource.
This class can be used to split an input stream into one or more
additional output streams.
This class is used to keep track of the number of bytes read from the
underlying input stream.
Apply a curved scale factor that has a max upper limit.
Do not scale number of bytes.
Apply a linear scale factor so that when we have read N actual bytes
the getNumRead() method return N*scale bytes.
A scale factor can be used to match number of read bytes to something
that better resembles actual progress.
A JEP function class that adds a
inList(reporterListId) function to a
JEP expression parser.Compare if one expression is contained in a set of other expressions:
e1 IN (e2[0], e2[1], ...)
This class contains static methods used to install items into an
empty database.
File processor implementation that sets a final result status for each
processed file (eg.
Filter implementation for extension files that
allow installed files to pass.
Filter implementation that selects only those extensions that
was selected by the user in the gui.
A filter implementation that accepts all objects
that are (sub)classes of a specified class.
Convert an
Integer constant
to a Query API Expression.A constant integer expression.
Formats a number as an integer.
This class represent a parameter type that is an integer.
Integer parameter value.
Utility methods that will make it easier to implement
data validation for integer attributes.
Database-independent writer implementation that writes integer
values from a result set.
This interface is used together with the
IntensityCalculatorUtil
class to help a plugin calculate intensities from raw data spots.This plugin provides methods to calculate the intensity for a root bioassayset
using different formulas.
This is a utility class for plugins that calculate intensities
from raw spot data.
An implementation of the
IntensityCalculator interface using
JEP expressions.Holds information about the formulas used to calculate intensities from
a raw data spot.
Gives information in what way spot intensities has been transformed
before they were stored in the database.
An interactive plugin is a
Plugin that supports interactive
configuration in a user session.Identification method implementation that finds an item
by using the
getById() method.A simple implementation of a job queue that executes jobs
in order of priority and longest waiting time.
Our own keyring containing the permissions we need to execute the jobs.
The internal slot manager assigns slot to jobs based on their
estimated execution time.
An interface for handling thread interrupts.
Filter implementation for extension files that
allow modified but invalid files to pass.
Exceptions of this type are thrown when invalid data is encountered.
This exception can be thrown when the password is invalid.
Exceptions of this type are thrown when user tries to log in, but
the password is incorrect.
This exception is thrown when BASE is trying to parse a path
which is invalid.
Exceptions of this type are thrown when a
ValidationAction has detected that a file
related to the main file is invalid.This exception is thrown when an object field or a parameter
that mustn't be null is set to null.
A filter implementation that negates the result of a parent
filter.
Keeps contextual information about a single invokation of
extensions.
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.
This class defines constants for various items in BASE.
Helper class to make it easier to set up the defined permissions.
This exception is thrown when trying to save an object
and another object with the same ID already exists.
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.
Parameter options for
ItemContext.setSubCategory(AnnotationTypeCategory, AddFilter)Holds a pair of filter.
Enumeration used to specify the sort direction.
This exception is thrown when trying delete an item
that is used (reference to) by some other item or items.
This class is used to get information about which users and groups
a
Shareable item has been shared to.This class holds information access privileges for users and groups.
This class represents a list of items.
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.
Options for synchronizing an existing item list with a current settings
in an
ItemContext.This represents an arbitrary collection of items.
Node loader implementation for item lists.
Name generator used for item list members.
Synchronization options for item lists.
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.
This exception is thrown when trying to load an item from
the database that does not exist.
This class represent a parameter type that is an object derived from
BasicData.Item parameter value.
An implementation of the
Query interface that returns item
objects.A class that uses a given query to load data.
A query wrapper for
ItemQuery:s.Return the results of an
ItemQuery as an iterator.Return the results of an
ItemQuery as a list.Item subtypes can be used to classify items into sub-categories.
Item subtypes can be used to classify items into sub-categories.
This class represents a specific
DataFileType
that is associated with an item subtype.This class hols information about which file types
can be used together with item subtypes.
A filter implementation that mathces item types on nodes.
Formatter implementation that converts an integer into it's Item
representation and the uses name() as the formatted value.
A class loader implementation that loads classes from JAR files.
A proxy class loader is typically needed when one extension
depends on another extension.
Utility class for parsing mathematical expressions.
Convert a built-in JEP function or operation to a Query
API
Expression or Restriction.A dynamic field implementation that uses a JEP expression to
generate the expression that is needed to select the data.
This interface should be implemented by JEP functions
that can also be converted into an
Expression that
can be used in queries.This plugin caluclates extra values from a bioassayset using mathematical
formulas entered by the user.
This interface should be implemented by objects that can
perform some kind of calculation for a
JEP expression.This plugin transform channel intensities using mathematical formulas
entered by the user.
A mapper that uses Jep to calculate the final value.
This interface should be implemented by JEP functions
that can also be converted into a
Restriction that
can be used in queries.This class represents the execution of a job.
A rough estimate of the execution time of a job.
Implements the ProgressReporter interface and
stores the percentage completed for the current job.
Our own keyring containing the permissions signal handlers may need
to update job status, eq.
The status of a job.
The type of job.
This class represents a job agent, which is a program running
in another virtual machine on the same or a different server.
This class is used by client applications to communicate with job agents.
This class holds information about a job agent.
This class can hold information about the status of a job agent.
This class is used by job agents to listen for incoming
requests from client applications.
This class is used for listening to the specified socket for
incoming connections.
This class is used for forwarding requests to a
RequestHandler.This class contains a job agent's settings for a specific plugin.
This class holds information about plugin settings for
a particular job agent.
This class holds information about a job.
This interface must be implemented by all classes that want's to act
as a job executor.
Hold information about a job that is running on a job agent.
This class is given the responsibility to check the job queue for
jobs that are awaiting execution.
A runnable class that makes it possible to execute each job in it's own thread.
A join query element.
An enumeration used to specify the type of join.
Implementations should convert a given object to an object that
can be serialized into a JSON string.
Utility functions for working with JSON data.
Context object for the web application.
This is the base class for keys.
This abstract class is the base class for the key classes
which holds access privileges for users, groups, projects and roles.
Class for holding a keyId and a permission value.
Objects of this class holds information about a user's access permissions,
group and role membership.
This class is used to represent a kit of reagents and other stuff used in
the lab process.
This class holds information about a kit.
Plug-in for importing kit items in a batch.
Node loader implementation for kits.
Validator implementation for kits.
This tag creates a label on a toolbar.
Adds a
left(string, index|string) function to Jep.Convert the '<' operator
to a Query API
Restriction.Convert the '<=' operator
to a Query API
Restriction.Check if one expression matches another: e1 LIKE e2
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.
Adds a
lineNo() function to Jep.Formatter implementation that generates a HTML output linking
a file item.
Formatter implementation that generates a HTML output linking
a nameable item.
Tagging interface for items that can be put in an
ItemList.Utility class for working with
Listable items.Action that inserts a new column into a table listing.
Data loader implementation that acts as a proxy to a ListColumnAction object.
Renderer implementation that add formatter and data loader
implementation for a list column that can be exported.
Utility class for list column extension points.
Processor implementation that define servlets based on what it can
find in the META-INF/servlets.xml file.
A signal receiver implementation that can receive signals from the
local virtual machine only.
A signal transporter implementation that can transport signals within
the local virtual machine only.
This enumeration defines constants that are used to specify different
file storage locations.
MA calculator for log2-transformed spot intensity values.
A JEP function class that adds a
log2(expression) function to a
JEP expression parser.MA calculator for log2-transformed spot intensity values.
Convert
Logarithm function
to a Query API Expression.Gives information about the current transaction and gives log
implementations limited access to the database.
An entry in the log.
Take the n-based logarithm of an expression: log(n, e).
Tagging interface that should be implemented by all
data classes that we want to log in the change history
tables.
Getter methods that are annotated with this annotation
should not have their old/new values logged in the change
history log.
Exception handler factory implementation that logs error messages
using the default logging mechanism.
Log level implementations for slf4j.
Interceptor that attaches to Hibernate sessions to provide
logging of items that are updated/created/deleted.
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.
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.
An action for customizing the login form.
A simple implementation of the
LoginFormAction interface.Hold information about a login request such as login, password, etc.
The level of the log message.
Manages the logging of changes made in a single transaction.
A log manager factory handles the creation of log managers and
entity loggers.
Utility class for LOG4J logging.
This class represent a parameter type that is a long.
Long parameter value.
Database-independent writer implementation that writes long
values from a result set.
A formatter implementation that uses a map to lookup values from
a set of keys.
Compare if one expression is less than or equal to another: e1 <= e2.
Compare if one expression is less than another: e1 < e2.
Calculates M and A values for 2-channel data.
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.
Logger for manual entries.
Represents a manual entry into the change history log.
Plug-in that allows a user to manually register an external analysis
procedure and to upload files that was generated by it.
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.
Factory for generating MA and correction factor plots for
2-channel data.
Represents a mapping expression that gets a single value from
a line of data.
Batcher class for inserting parent mapping information in the
dynamic database.
This class defines a mapping coordinate, which is a triplet of
plate number, row and column.
Data loader implementation that load values from a map
collection.
File processor implementation that marks all extension files
as processed.
An extension to the internal slot manager which also accepts
slot assignment from remote job agents.
A remote slot is a slot with some information about
when it was created and last updated.
Request handler implementation that accepts requests for slots
from remote hosts.
Task that is scheduled at regular intervals to check for
timed out slots.
Exporter implementation that exports bioassay set data as a matrix
BASEfile.
BFS exporter implementation that exports spot data in matrix format.
A model container for BFS data files.
Event handler that extracts spot intensity information from matrix BFS
data files and inserts the values to a spot batcher.
Calculates the maximum of an expression: MIN(e)
This class calculates the MD5 hash of a string and
returns it represented as a hexadecimal string.
Calculates the arithmetic mean of an expression: AVG(e)
A JEP function class that adds a
mean(string) function to a
JEP expression parser.An expression representing the mean value of property of a
raw data spot.
This class is the base class for measured biomaterial items.
Transaction handler for updating the remaining quantity of a biomaterial
based on the sum of the used quantity in this transaction.
This class is the root class for measured biomaterials, ie biomaterials for
where the quantity is tracked.
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.
This tag defines a menu item inside a drop-down menu.
An action for extensions to the menu system.
A simple bean-like implementation of the
MenuItemAction
interface.This tag defines a horizontal separator line inside a drop-down menu.
This class represents a message.
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.
This class holds information about messages.
Utility methods for retreiving metadata about items.
Property path implementation that converts a BasicData object
to a BasicItem.
Property path implementation that converts a BasicItem to a BasicData
object.
Property path implementation which wraps a collection inside an unmodifiable
collection.
Property path implementation that combines a list of property paths
to create a long chain.
Property path implementation which gets a value from a component.
Property path implementation clones a Date.
Property path implementation which gets a value from an entity.
Property path implementation that evicts the selected item from
the Hibernate first-level cache.
Property path implementation which gets the id from an entity.
Property path implementation which wraps a map inside an unmodifiable
map.
Property path implementation that does nothing.
Contract for getting the value of a specific property for an item.
Property path implementation that converts a ReporterScore to a ReporterListScoreData
object.
A model container of the contents of a BFS metadata file.
Holds information about a section.
Holds information about a section entry.
Parser implementation that parses a BFS metadata file.
Writer implementation for writing BFS metadata files.
Used for adding log entries to the database if that is enabled.
Hold information a raw bioassay.
Hold the mappings defined in the mapping file.
Class for migrating a database to PostgreSQL.
This class is used to represent mime types.
This class holds information about mimetypes
Calculates the minumum of an expression: MIN(e)
This implementation create main contextes from a mode and item type
which means that we can have different default subcontexts for the
default list pages and for selection list pages.
Event handler implementation that forwards a single event to multiple
event handlers.
A generic formatter that can be used to format objects of mixed classes.
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.Convert
Multiply function
to a Query API Expression.Multiply two expressions: e1 * e2.
Identification method implementation that can use a multiple properties
(eg, name, id, externalId, etc.) for identifying items.
Request handler implementation that forwards all requests to a registered
protocol-specific handler.
Helper class for executing multiple queries and return the result as
a single iterator.
Collection transformer implementation that transforms a source
collection into the destination collection using multiple steps.
A JDBC Work implementation that executes multiple queries that
doesn't return any result.
Database engine for My SQL.
A
Nameable item is an item that has
a name and description.An implementation of the
Comparator interface which uses
the name of Nameable items to compare the objects.Simple "converter" implementation that create JSON objects
with the name and id of
Nameable items.A nameable item is an item that has a
name
and, optionally, a description.Formatter to handle
Nameable items.Name generator implementation for
Nameable
items.Utility methods that will make it easier to implement
the
Nameable interface, including data validation.A helper class that wraps a parameter values object with
a namespace.
A helper class that wraps a plug-in parameter object with a namespace.
A helper class that wraps a request object with a namespace.
A simple wrapper around hibernate native (SQL) queries which simply forwards
all calls to a parent query.
Helper class for mixing native SQL with HQL queries.
Convert
NaturalLogarithm function
to a Query API Expression.This tag is used to display a navigator for a pageable table
of items.
Negate an expression: -e1.
Compare if two expressions are inequal: e1 <> e2, or
NOT e1 IS NULL
This class implements the
Iterator interface
for iterating multiple collections as if it was one big collection.This class represents news items.
This class holds information about news items.
Nicely format a string for output on a web page.
Tagging interface for items that are unlikely to be linked
via an AnyToAny link.
A node in an overview.
The type of node.
Defines per-node attributes that can be used to store
extra information together with a node that doesn't fit
the regular properties.
A cache implementation for nodes.
A node factory is responsible for creating item-type nodes.
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.
A node loader factory is a class that know how to
create
NodeLoader:s for a given key domain.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.
A filter implementation that matches the node type.
A node validator is responsible for checking the "validity" of
a node.
The same as a NodeValidator.
A node validator factory is a class that know how to
create
NodeValidator:s for a given key domain.A filter implementation that accpets an object only if
at none of the parent filters accepts it.
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.
Convert
Not function
to a Query API Restriction.Convert the '!
A JEP function class that adds a
notInList(reporterListId) function to a
JEP expression parser.Getter methods that are annotated with this annotation should
not trigger a log entry even if their values have changed.
This exception is thrown if you try to perform a function that
requires a user to be logged in without beeing logged in.
A filter implementation that rejects all null objects.
Negate a restriction: NOT r
A mapper that returns null if there is an exception when parsing the
input data.
A node loader implementation that doesn't load any nodes.
A node validator implementation that accepts all nodes,
except missing items and denied access items (depending on configuration).
Formatter implementation for numeric values that simply wrap a
NumberFormat instance.
Formats a number for output on a web page.
Utility class for working with
NumberFormat object.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.
Instances of object keys should be something that uniquely
identifies an object that has been defined by an extension.
An implementation of the
FileFilter interface
that filter files based on their age.A filter implementation that accpets an object if
at least one parent filters accepts it.
Action that is called when an item is saved in gui.
Renderer implementations for OnSaveAction:s.
Convert the '||' operator
to a Query API
Restriction.An ordering query element.
A factory class to create order by expressions.
Combine one or more restrictions with OR: r[0] OR r[1] OR ...
Interface that should be implemented by overview generating
classes.
Action for generating overview plots for a bioassay set.
A simple bean-like implementation of the
OverviewPlotAction
interface.Utility class for the overview generation functionality.
An
Ownable item is an item which has a User as its owner.An ownable item is an item which has an owner.
Utility methods that will make it easier to implement
the
Ownable interface, including data validation.This class extends the
BasicData class and implements the
OwnableData interface.Plug-in that packs one or more selected files and directories into a single file.
This tag should be used together with the
<base:head> and
<base:body> tags on every JSP page in BASE.This tag creates a panel in the table.
Represents a parameter definition for the external program.
This exception is thrown by classes that uses the
parameter system,
ParameterType and
ParameterValueData.Parameter expression.
Get information about a plugin configuration or parameter.
Utility class for creating some useful plug-in parameters.
This is the base class for all parameter types.
The base class for the different types of parameter values.
This interface is used by the plugin to access the different parameters
attached to its job and configuration.
An implementation of the
ParameterValues interface that
lets a plugin write the job's configuration.A helper class that will wrap the parameter values from one job, one configuration
and one request object.
This is a loader implementation that load information about all source biomaterial
for a given child biomaterial.
This is a loader implementation that load information about all source biomaterial
for a given physical bioassay.
This class get data from the parents to a
MeasuredBioMaterialThis class holds the password for a user.
A version of the default login form that can be
installed as an extension.
This class represent a parameter type that is a password
(or any other type of masked string).
This tag defines a navigation path.
An enum that describes what type the path is
A value converter that can be used on all setter methods
that has been annotated with the
PathSetter and
PathType annotations.This tag defines an element of a path.
This is a loader implementation that load the path of a file or directory.
This class represent a parameter type that is a path to either a
directory or a file.
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.Specify the type of paths.
This is a request handler for the
pause command.A simple timer for measuring code performance.
This enumeration defined constants for permissions.
A button factory that can hide or disable button items based
on the logged in user's permissions.
This exception is thrown when trying to load or manipulate an
item in the database and you don't have the required permission.
A menu item factory that can hide or disable menu items based
on the logged in user's permissions.
Restriction that inserts an "impossible" filter requirement (1=0)
if the logged in user is lacking a given permission.
This class holds permissions requested by a plugin.
A permission template with permissions to users, groups and
projects.
A permission template with permissions to users, groups and
projects.
This class is used to collect some useful methods for assigning
permissions to roles and shared items.
A physical bioassay is a representation of the process of
performing an experiment one or more
Extract:s.This class holds information about a physical bioassay (eg. a hybridization or similar).
Plug-in for importing physical bioassays items in a batch.
Node loader implementation for physical bioassays.
Source item transformer implementation that transform physical bioassay items
to derived bioassays.
Source item transformer implementation that transform physical bioassay items
to extracts.
Validator implementation for physical bioassays.
This is a request handler for the
ping command.A plain text template that exports data in tab-delimited format.
This class is represents physical plates.
This class defines a plate coordinate, which is row and column
on a plate.
This class holds information about a plate.
This class represents an event in the life of a
Plate.This class holds information about a plate event.
Logger for plate events that logs changes as
updates to the plate the event belongs to.
This class is used together with the
PlateType class
to define event types for plates.This class holds information about a plate event type.
This class defines a plate geometry, which is the number of rows
and columns of wells on a
Plate.This class holds information about a plate geometry.
This class represents a mapping from one plate geometry to another.
This class holds information about a plate mapping.
Exporter for plate mappings.
Importer for plate mappings.
This class represents plate types, which is a name, description,
geometry and a list of event types.
This class holds information about a plate type.
This class is used to represent an experimental platform in BASE.
This class hols information about experimental platforms.
This class represents a specific
DataFileType
that is part of a platform.This class hols information about which file types
are used on which experimental platforms and variants.
Node loader implementation for platform and platform variant.
Validator implementation for platforms/variants.
Represents variants of a
Platform.This class hols information about variants of experimental platforms.
Used to map spot data into different annotations.
Contains information about a single image in an overview plot.
A simple bean-like implementation of the
PlotGenerator
interface.This servlet can plot spot data for a bioassay or bioassay set.
Special implementation of a
SqlResultIterator
that combines the result from the parent and child into
one virtual iterator.A single result row that is combined from the parent and
child results. 1 --> parent A, 2 --> parent M, 3 --> parent M - child M
This interface must be implemented by all plugins to BASE.
This class is used to configure a plugin.
This data class is used to configure a plugin.
This plugin exports parameters of a pluginconfiguration into an XML-file.
This plugin imports pluginconfiguration from an XML-file.
Configures a plugin or job.
A plugin definition represents the executable plugin.
This class represent an installed plugin.
Filter implementation that only matches tags for plug-in definitions.
Executes a job.
Object for holding information about a plug-in definition as
it is loaded from the extensions definition file.
Key implementation used to identify plug-in definitions.
File processor implementation that load and install
plug-ins.
Class for mapping the
PluginKeys table.Contains information about a single parameter that the
plugin needs for a request.
Configures or executes a plugin.
Get the response from a configuration step or execution of a plugin.
This is a special session control implementation that is used for
executing plugins that prevents them from logging in or out.
This class represent an interface that a plugin can implement.
Batcher class for per-position data in the dynamic database.
Event handler implementation intended to be used with a
SynchronizedSpotDataParser to extract the position
number from the parsed data.Batcher class for per-position extra values.
A JEP function class that adds a
pos function to a
JEP expression parser.Database engine for Postgres.
Result writer factory implementation for formatting
result values suitable for importing by a PostgreSQL
database.
Calculate the power: base ^ exponent
This class is used for reading XML files with information
about predefined queries.
Formats a value with optional prefix and suffix.
A wrapping renderer for HTML output that can wrap the
HTML generated by a parent renderer with a prefix
and/or suffix.
This is a generic class for handling named presets consisting of multiple
key/value pairs.
Represents a single preset.
Special tag for generating a list of saved contexts and other settings.
A plugin that imports an
ArrayDesign from a printmap.A comparator implemenation that sorts a given set of
objects before all other object.
This is a job executor which starts a new process for each job to be
executed.
Used for redirecting standard output to a string.
Class for collecting results from a scan for new/deleted/updated
extensions.
Scan results for a single XML or JAR file.
A program parameter definition and it's values for a specific
job.
Input stream wrapper that calls a progress reporter at regular
intervals.
Certain methods in BASE can report their progress back to
the calling client application if they are giving an object
that implements this interface.
An implementation of a signal handler that uses a
ProgressReporter
to communicate signals back to the target.This class is used to represent projects.
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.
This class holds information about a project.
Filter implementation that finds all annotation snapshots
for a given set of projects.
This class is used to get information about which projects
a
Shareable item has been shared to.This class holds information access privileges for projects.
Class for mapping the
ProjectKeys table.Class for holding a project id and a permission value.
This class is used to specify permissions to share an item to
projects.
Internal class for keeping the "override_id" column in
the "Annotations" table synchronized when annotations
are creted and deleted.
Holds some information about the annotation that
has been created.
Helper class for finding out information about about
annotation snapshots returned by
AnnotationLoaderUtil.findAll(net.sf.basedb.core.snapshot.AnnotationSetSnapshot, Filter)
method.Used to store filter settings in the current context.
This class holds context information to help client applications
with storing common settings for tables.
Formatter for PropertyFilter items.
Identification method implementation that can use a single property
(eg, name, id, externalId, etc.) for identifying items.
A factory implementation that generates list columns based on a property path
as used by the
Metadata class.A concrete implementation of the ListColumnAction
interface.
Getter methods that are annotated with this annotation should
can not use Metadata.getPropertyPath to retreive their values.
This tag is used to display the property of a
BasicItem.This class is used to represent individual protocol items
and information about them.
Node loader implementation for protocols.
Node loader implementation for protocol parameters.
Validator implementation for protocol parameters.
Validator implementation for protocols.
Generic action factory class that can generate instances of
actions if the action class is an interface.
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.
Calculates the quadratic mean of an expression
This class is used to represent a quantity for specifying units
to annotations.
This class holds information quantities.
This defines the simplest form of a relational query.
A query element is used in various places in a
Query to
build the structure of the query.Utility class for executing SQL and Hibernate queries.
Interface to be implemented by classes that knows how to cancel
a query.
Cancels the query running in a Hibernate session.
Cancels a query running in a stateless Hibernate session.
Cancels a statement by calling
Statement.cancel().A callable implementation the calls
PreparedStatement.executeQuery()Calls
Query.scroll(ScrollMode) and returns the result as a
ScrollIterator.A callable implementation the calls
PreparedStatement.executeUpdate()Actions for creating restrictions on queries.
Holds information (name, type and value) about a single parameter
to a query.
Utiltity class for parsing string values in the form of
HTTP request query parameters:
This is the root interface for query results.
Represents a filter that is applied to a query just before it
is executed in order to limit the result.
This is a factory class for
QueryRuntimeFilter implementations.A required filter for
Annotatable items.Chains one or more filters into a single filter.
An optional filter that can be used by
BasicItem:s to replace
the QueryRuntimeFilterFactory.BasicFilter.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.A required filter for
Removable items.An optional default filter for
Shareable items.This class manages the enabling/disabling of
QueryRuntimeFilter:s.Indicates which part of a query that is currently beeing built.
A type representing the language of the query.
A helper interface for the
SimpleExport class to make it
easier to interact with different types of queries.A simple wrapper around hibernate queries which simply forwards
all calls to a parent query.
This class is used to represent disk quota settings for users
and groups.
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.
This file holds information about a qouta.
This exception is thrown to signal that the user's quota has been exceeded
and that an
DiskConsumable item cannot be saved.This is a helper class for the
QuotaData item to
help with the Hibernate mapping between quota and
quota type/location/max bytes.This class represents the different types a quota can have.
This class holds information about different QuotaTypes.
A rawbioassay represents the raw data generated from a single
DerivedBioAssay.This class holds information about a raw bioassay, which is the
raw data extracted from a scan.
Plug-in for importing raw bioassay items in a batch.
Node loader implementation for raw bioassays.
An expression representing the property of a raw bioassay.
Source item transformer implementation that transform raw bioassay items
to derived bioassays.
Validator implementation for raw bioassays and root raw bioassays.
A JEP function class that adds a
rawCh(int) function to a
JEP expression parser.Represents the measurements for single raw data spot.
Batcher class for raw data.
A plugin that imports rawdata from a flatfile.
Holds information about an extended property for raw data.
An expression representing the property of a
raw data spot.
This class holds information about a raw data type.
Filter implementation that accept raw bioassay items of a given raw data type.
This class is used for reading the XML configuration file with
information about raw data types.
Comparator implementation that sorts raw data types
according to their name.
Utiltity class for getting and setting non-public properties of
raw data objects.
A JEP function class that adds a
raw(string) function to a
JEP expression parser.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.
This class defines constants that are used to specify a table in
the regular (non-dynamic) database while doing analysis with dynamic
queries.
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.
An implementation of the
FileFilter interface
that filter files and directories based on regular expressions.Items that implements this interface has their registration
date stored in the database.
Adds the date an item was registered in the database.
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.
Keep track of the extension points and extensions found in a file.
A registry for keeping track of extensions points and
installed extensions.
Identifies attribute.
Internal representation of an extension.
Internal representation of an extension point.
Related item column that load annotation values from the parent or child items.
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.
Represents a specification for loading a related parent or child item.
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.
Related item column that displays an error message.
Related item column that get values from an extension.
Helper class for storing request-scoped objects that may
be useful to re-use between multiple columns.
Related item column that get the item lists that the parent or child
item is a member of.
Related item column that get values from multiple hops betweeen child->parent->child.
Related item column that get values from parent or child items by specifying
a "property path".
Slot manager implementation that requests slots from another
job agent.
Task that is scheduled at regular intervals to send ping commands
to the remote host.
A
Removable item is an item that can be flagged
as removed.A removable item is an item that can be flagged
as removed.
Collection transformer implementation that removes all elements in
the source collection from the destination collection.
Tag for rendering extensions.
A renderer is an object that knows how to render an action
in the client interface.
A renderer factory is a factory that can create
Renderer
objects.This is an utilitiy class for reporters.
Batcher class for reporters.
Batcher implementation that is used to handle cloned reporter
information in the dynamic database.
Specifies which source table to use for finding out which reporters
that are part of the current experiment.
This class holds information about cloned reporter properties.
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.
A template for holding information about reporter properties that are/should
be cloned in the dynamic database.
This class represents the idea of clone, oligo or some other
reporter for a gene.
A plugin that imports reporter from a flat file.
A JEP function class that adds a
rep(string) or mrep(string)
function to a JEP expression parser.This class holds information about a reporter list.
Represents a property of a reporter list in a dynamic query:
alias.property.Represents a join to a reporter list in a dynamic query:
leftTable JOIN ReporterListScores ON ...This class holds information about the score of a reporter in a
reporter list.
A plugin that imports features to an ArrayDesign from a flat file.
An expression representing the property of a
reporter.
Get information about the reporters and their score in a reporter list.
This is a temporary solution to query against the reporter list's
score.
A query wrapper for
ReporterScoreQuery:s.This is a temporary solution for returning reporter list scores
as an iterator.
This class holds reporter type information.
This class holds reporter type information.
Pass request information to a plugin.
A request handler object takes care of an incoming request from a
JobAgentServerConnection, processes it and returns an answer.Get information about the parameters the plugin needs for a particular request.
Wrapper for HttpServletRequest that allows us to set
proper servlet path and path info attributes for an extension
servlet.
Renderer implementation for resetting metadata for the members of a file set.
File processor implementation that reset the error flag, class loader, etc.
Factory for loading resource bundles.
A wrapper around
ResourceBundle objects.The response interface used by the core.
A restriction query element.
A factory class to create restrictions.
Transformer implementation that is intended to provide a final
filtering of target items.
Return the result of a query as an iterator.
Return the result of a query as a list.
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.Interface for quick writing of data from a JDBC result set to a
writer.
Interface for factories that knows how to create result writers.
An extension to the
ConnectionManager interface that
add support for specifying a start offset when downloading the
external file.Extension to the logging error handler factory that create error handlers
that re-throw the original exception.
Filter implementation that checks if the items
returned by a
EntityQuery are compatible
with the specified class.Checks if an expression matches a regular expression:
e RLIKE regexp (MySQL) or e ~ regexp (Postgres).
This class is used to represent roles.
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.
This class holds information about a role.
This class is used to represent a role key.
This class holds information access privileges for roles.
Class for mapping the
RoleKeys table.Represents the use of a raw bioassay in an experiment.
This class holds the link between experiments and
raw bioassays including an annotation set that is
representing the experimental factor values.
Node loader implementation for root raw bioassays.
This tag defines a new row in the table.
This tag is a place-holder for
<tbl:row> tags.A servlet that generates a RSS feed from the public news on the BASE server.
Utility class for processing multiple items with a
InheritAnnotationsManager in a separated thread
with progress reporting.This class is used to represent sample items.
This represents a sample.
Plug-in for importing sample items in a batch.
Node loader implementation for samples.
Source item transformer that transform sample items to their parent
biosources.
Source item transformer implementation that transform sample items to their
child sample items.
Source item transformer that transform sample items to their child
extract.
Source item transformer implementation that transform sample items to their
parent sample items.
Validator implementation for sample.
A wrapper work that protects a parent work with a savepoint.
A simple plot utility for generating scatter plots without
the need to delve deep into the JFreePlot package.
This class is a cousin to the standard
Timer class
but only allows scheduling of tasks.A work implementation that checks if a given catalog+schema exists
in the database or not.
Replaces the Hibernate SchemaExport and SchemaUpdate tools.
Helper class used for collecting SQL statements generated by Hibernate
schema creation/update tools.
The installation mode.
This class holds information about the current schema version of the database.
A JEP function class that adds a
score(reporterListId) function to a
JEP expression parser.Tag for creating <script> tags from a
JspContext.This is an iterator view of the result from a query
using the Hibernate
ScrollableResults object.The second pass of the 'spots' section extracts spot and extra value
data.
Action that inserts a new section in a jsp page.
Parses the 'assays' section of a BASEfile with bioassay set spot
data.
A simple bean-like implementation of the SectionAction
interface.
Parses the 'reporterlist' section of a BASEfile.
This tag is used to display a selection list of items.
A selection query element.
An expression representing an already selected expression.
A factory class to create select expressions.
File name generator implementation that generates file names using
a simple numerical counter.
Exporter implementation that exports bioassay set data as a serial
BASEfile.
BFS exporter implementation that exports spot data in serial format.
Event handler that extracts spot intensity information from serial BFS
data files and inserts the values to a spot batcher.
Action for controlling services installed under the extensions system.
Utility class for starting and stopping services.
A special session control implementation used for services.
Flushes the given session before the transaction is committed.
Our own keyring containing the only permission:
Permission.ACT_AS_ANOTHER_USER.Event handler for managing services when new extension are added
or existing extension are updated or deleted.
Utility class for the "services" extension point.
An extension to the
ExportOutputStream class which
directs the output to the response stream of a
HttpServletResponse object.Loads servlet definitions from an XML file.
A wrapper class for servlets defined by extensions.
Key implementation used to identify servlets.
A session represents the time between login and logout for a single
user.
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.
This class handles user sessions.
Internal class to hold information about the logged in user.
Represents a main context for which a "current" subcontext can be
assigned.
Internal class to hold information about a setting
Class for storing temporary device information for a user
that has been authenticated but before a device has been
verified.
This class holds information about a session.
Deprecated.
Wrapper around Hibernate sessions that includes a query cache.
This is the base class for all setting items.
Class for keeping settings for the extensions system.
Severity levels for a validation rule.
A shareable item is an item which can be shared to other users,
groups or projects.
Utility methods that will make it easier to implement
the
Shareable interface, including data validation.This class extends the
OwnedData class and implements the
ShareableData interface.A special restriction that works on
Shareable items.Database-independent writer implementation that writes short
values from a result set.
A signal sender implementation that is used by the system when
shutting down.
Represents a signal that can be sent to a class implementing the
SignalTarget interface.Base class for all signal exceptions.
A signal handler is an object that is able to receive and act on signals.
This exception can be thrown by signal handlers when one or more
signal has been received.
A signal receiver is a class that knows how to receive a
Signal from a
SignalTransporter and how to distribute this to a SignalHandler.This is a request handler for the
signal commands.A signal sender is responsible for sending a signal to
a signal handler.
This interface should be implemented by classes that are able
to receive
Signal:s.A signal transporter is a class that knows how to send a signal to a
specific
SignalReceiver implementation.This is a simple implementation of the
AbsoluteProgressReporter interface,
which simply remembers that last values.Represents an exported data field.
A simple error handler that either ignores all errors or
re-throws them.
Export plugin for exporting data from table listings in the web client.
A simple base class for registering a JEP function by name and number
of parameters.
This is a simple implementation of the
ProgressReporter interface,
which simply remembers that last values.This class can be used to report progress and hold signal receiver
for those export plugins that download immediately.
A signal sender implementation that sends a specific signal
to all handlers that supports it.
A simple string detector implementation that works with two strings.
A filter implementation that enables a single extension and
disables all other.
Base class for validators that works on single files
of a known data file type.
Action for adding skins to BASE.
Represents a slot that has been assigned to a job.
A slot manager is responsible for slot assigment to jobs.
Manager for annotation snapshots.
A signal receiver implementation that listens on a socket for incoming signals.
This class contains some useful methods when working with sockets.
This class is used to represent individual software items
and information about them.
This class holds information about a software.
Node loader implementation for software.
Validator implementation for software.
Implementations are responsible for transforming a set of source item
ID:s into a set of related target item ID:s.
Chains together one or more source item transformers.
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().This is a wrapper transformer factory that can be applied to any other
factory in order to provide support for caching.
A special HQL query implementation that can return almost any kind of object.
Batcher class for per-spot intensity values for bioassaysets.
Batcher class for per-spot extra values.
A spot intensity parser is responsible for parsing and extracting
spot intensity data on a row-by-row basis from a BASEfile.
An expression representing the column in a
database tabe: alias.column.
This is a query that is using SQL as the query language.
This interface represents a single row in the results of
a
SqlQuery.Return the result of a
SqlQuery as an iterator.Convert
SquareRoot function
to a Query API Expression.Utility class for working with SSL connections.
Default field converter implementation that works mainly by
checking names and/or external id values of formulas, extra
values, experimental factors etc.
Action for selecting the start page that should be displayed after
logging in to BASE.
A simple bean-like implementation of the
StartPageAction
interface.This is a request handler for the
start command.A renderer that starts the service of a
ServiceControllerAction.Servlet listener for starting BASE when the web server is started and
stopping BASE when the web server is stopped.
Wrapper around stateless Hibernate sessions that includes a query cache.
A cache for storing data to files on the file system.
A timer task that clean up the cache when it is executed.
Keeps track of a locked cached entry.
A lock-safe input stream that releases the associated
read lock when the stream is closed.
A lock-safe output stream that releases the associated
write lock when the stream is closed.
Inner class for performing the actual release of locks and closing of streams (in/out).
A filter implementation that either rejects or accepts all
object (including null).
A key manager implementation that always selects a specified keystore entry.
This is a request handler for the
stop command.A renderer that stops the service of a
ServiceControllerAction.Caches the contents of a stream to a local temporary file.
Convert strings to other data types.
Convert a
String constant
to a Query API Expression.Interface for checking if a text line in a file seems to be decoded correctly
with the current character set.
Format a string for output on a web page.
A comparator implementation for strings that sorts them according
to their length.
A wrapper class for fuzzy string matching using the SecondString package.
Wrapper that holds information about a fuzzy match.
This class represent a parameter type that is a string.
String parameter value.
This exception is thrown when an item's field or a parameter
which must be shorter than a specified length exceeds that length.
Utility methods that will make it easier to implement
data validation for string attributes.
Generic tag class for tags that want to support
id, class and style of the main html object they
use.
Tag for creating <link> tags to stylesheets
from a
JspContext.Helper class for changing the current subcontext.
This tag defines a menu item inside a drop-down menu.
Expression that returns the result of a query as it's value.
Convert
Subtract function
to a Query API Expression.Subtract one expression from another: e1 - e2.
A subtypable item is an item that can have a subtype.
A subtypable item is an item that can have a subtype.
Annotation that can be used by
Subtypable items to tell
about related items.Filter implementation that accept (annotatable) items of a given subtype.
This tag defines a selectable list of subtypes.
File name generator implementation that uses the suggested file name.
Calculates the sum of an expression: SUM(e)
Annotation (java) that can be used by
Subtypable items to
enable/disable support for pushing annotations (BASE) to parent
items.Holds information about a synchronization filter used
by an item list.
A parser that synchronizes the parsing of multiple underlying
data parsers and a master reporter annotations parser.
This class holds information that is sent to the event
handler when
SynchronizedSpotDataParser.DATA_EVENT:s are
sent.A system item is an item which has an
additional id in the form of string.
A
SystemItem is an item which has an
additional systemwide unique id in the form of string.This class is used to map the system id of all
SystemData items to the numerical internal
id in the current installation.This tag defines the title and contents of a single tab inside a tab control.
Action that inserts a new tab in a tabcontrol.
A simple bean-like implementation of the TabAction
interface.
This is the main tag for the tab control.
Symmetrical encoder/decoder implementation that replaces newline, carriage return,
tab and backslash with \n, \r, \t and \\.
This is the main tag for the table.
Column properties class used to define table columns.
Example use in a jsp page:
Example use in a jsp page:
A work implementation that checks if a given table exists
in the database or not.
Holds minimal but useful information about a table in the database.
Holds information about a single column in a table.
Holds information about a foreign key of a table.
Holds information about an index in a table.
Holds information about the primary key of a table.
A work implementation that loads database metadata for a table
and returns it as a
TableInfo object.Wraps a writer stream and provides methods for easier writing
of tabular data.
This class represents a tag.
This represents a tag that is used to mark an extract so that
it can be tracked on physical bioassays.
Plug-in for importing tag items in a batch.
Node loader implementation for tags.
Validator implementation for tags.
This class packs files into a TAR archive.
A plugin for unpacking tar, gzipped tar and bzipped tar files to
the BASE file system.
Contains utility functions for TAR archives.
Text parameter value.
Generic writer implementation that writes string values
from a result set.
This is a job executor which executes jobs in the current thread.
An implementation of a signal handler that uses the
Thread class
to communicate signals back to the SignalTarget.Class for forcing the execution of a
TimerTask in
a new thread.Utility class for working with
Throwable:s.This class represent a parameter type that is a timestamp.
Date+time parameter value.
Generic writer implementation that writes timestamp values from a result
set.
Transformer factory implementation for transforming to biosources.
Get the date part of a date or timestamp epxression.
Transformer factory implementation for transforming to derived bioassays.
Transformer factory implementation for transforming to extracts.
This tag creates a toolbar.
A renderer for toolbar button actions, which displays the
action as a toolbar button.
Factory that create
ToolbarButtonRenderer objects
for rendering ButtonAction:s.Utility class for toolbar extension points.
Transformer factory implementation for transforming to physical bioassays.
Transformer factory implementation for transforming to raw bioassays.
Transformer factory implementation for transforming to samples.
Encoder implementation that replaces newline, carriage return,
tab and backslash with a space.
An implementation of the
Comparator interface which uses
the result of the toString method to compare the objects.A generic formatter that simply formats objects by calling the
toString() method.
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.
Enumeration constants used to tell the item what is going on in the core.
Interface that define hooks for callbacks during transaction commit
and rollback.
Holds information about the curren transaction, such as the logged in user,
the active project, the plug-in that is executing, etc.
A progress reporter implementation that has a "side-effect"
that limits the transfer rate.
A transformation represents an analysis step for an
Experiment.This class holds information about a transformation.
A simple cache implementation for holding the result of source item to target item transformation.
Transformation context that can be used to keep track of vital
information when doing multi-step transformations.
This class contains functionality to manage items that
have been marked for deletion.
Helper class for holding information about a single
item, other items using it and other information that is
relevant for resolving circular references.
Represents an entry for a node in the tree.
This class defines constants for supported value types in BASE.
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.
Convert
UMinus function
to a Query API Expression.File processor implementation that finalizes the uninstallation
of an extensions file by removing it from the settings.
Filter implementation that selects only those extensions that
was selected for uninstallation by the user in the gui.
This class is used to represent a specific unit that can be
used with annotations.
Helper class for optimized lookup of units by symbol.
Units are cached by (quantity,symbol) combination.
Interface for converting values between two units.
This class holds information units.
This class holds information the symbol that are used with units.
A utility class for working with
Unit:s.This exception can be thrown when the login is unknown
to the authentication server.
Extensions file processor implementation that unregisters all extension
points and extensions.
Annotation to be used on an
Action interface
to mark it as a possible candidate for generating unsafe inline
javascripts.This exception is thrown when trying to use an item that has not
been saved to the database in places where this is required.
Thrown when an import plug-in is forced to use a file that
is not of the correct format.
This exception is thrown by signal handlers and others that
doesn't support a given signal.
This class contains static methods used to update items already in the database.
Action that drops a column in a table.
Action that need to make some change to the database schem after the
main transaction in
Update.adjustExistingItems(ProgressReporter, int, String, String)
has finished.The upload servlet is used to handle single file uploads.
Objects of this class can be used to get information about
an uploaded file and save the file to a directory in the filesystem.
Holds metadata about the data referenced by given URI.
Utility interface for collecting information about
data file requirements when used on a certain platform/variant
or item subtype.
A special mapper for "Used quantity" values.
This class is used to represent a user in BASE.
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.
This class is used to represent a setting valid for a specific user
using a specific client application.
This class holds information about a user.
This class is used to represent a setting valid for a specific user
using any client application.
A user device represents a verified device a user may
use for accessing BASE.
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.
This class holds information about a verified user device.
Class for mapping the
UserGroups table.Class for mapping the
UserKeys table.This class is used to specify permissions to share an item to
users.
Class for mapping the
UserProjects table.Class for mapping the
UserRoles table.ResourceBundle.Control implementation that open property files in UTF-8 format
instead of ISO-8859-1 format.
Filter implementation for extension files that
allow valid and new or modified files to pass.
This interface is a tagging interface for items that needs case 2
validation.
This class is a proxy used for holding information about
a file set member that is currently undergoing validation.
Action for validating and metadata extraction from files in a file set.
Stores all validation options (ie. validator -- severity) combinations.
Renderer implementation for validating the members of a file set.
The same as a Validator.
Placeholder for a validation rule.
Interface for classes that wants to inspect/convert
parameters from the XML file before they are passed
to factory setter methods.
Utility class to handle the conversion between data objects and
item objects.
This class contains a set of static methods that may be useful
for handling strings, ints and other values.
Formatter implementation that converts an integer into it's Type
representation and the uses name() as the formatted value.
A value converter that can be used on all setter methods
that has been annotated with the
VariableSetter
annotation.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.Get information about the BASE version.
The key to a plugin configuration parameter.
Facotry for creating the "View" and "Download" actions in file lists.
This class is used to define columns in the virtual tables in the
dynamic part of the database that are storing analysed data.
A virtual database represents the set of tables in the dynamic database used
by a single experiment to store it's analysed data.
This class holds information about a virtual database in the
dynamic part of Base.
This enumeration defines constants that are used to specify different
virtual tables in the dynamic part of the database used for analysis.
Filter implementation that passes all extension files that
has been processed according to the information in the given
ProcessResults object.
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.
This exception can be thrown on any JSP page in BASE.
A well is located on a
Plate and contains a ReporterData.Formats an internal well coordinate to an external coordinate.
This class holds information about a well on a plate.
Create a WHEN statement to be used in a
CaseExpression.This is an extension to the
ConfigureByExample interface
that allows a plug-in to wrap an input stream with another stream.Excel formatter implementation that uses the value
from any parent formatter and creates a string cell
value.
An extension to the regular renderer interface
intended for renderers that wants to wrap an existing
renderer to give the result their own touch.
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).
This is a simple wrapper for the TableWriter class to make it
create an Excel workbook instead of a CSV file.
Template implementation that exports data to Excel format (xlsx).
Utility class for converting Excel worksheets to CSV-formatted InputStreams.
Loads extension points and extensions from extension definition
XML files.
A XML template that exports data in a simple one-level XML format.
This class contains some useful methods for handling
XML documents using JDOM2.
This class is used to handle callbacks from the XML parser.
This class packs files into a ZIP archive.
A plugin for unpacking zip and jar file on the BASE file system.
This class can be used to unpack zip files into the BASE directory structure.
This tag is used to make it easier to add zoom features on a BASE web page.
ServiceSessionControl.createSessionFactoryConfiguration(String, String, int, ClassLoader)instead