All Classes and Interfaces

Class
Description
Symbol property table based on the Amino Acid Index Database.
Iterator over AAindex objects that are stored in a stream in the AAindex1 file format.
An implementation of Chromatogram to encapulsulate chromatogram data extracted from the files produced by ABI sequencers, such as the the 377 and the 3700.
A general base parser for files produced by ABI software.
Concatenation of the Seekable and DataInput interfaces.
An aggregate immutable type for an ABIF tagged data record.
Useful functionality for working with fasta files where the quality of the DNA is encoded as upper and lower case DNA characters.
Title: ABITrace

ABITrace is a class for managing ABI file information, it is capable of opening an ABI file and storing the most important fields, which can be recalled as simple java types.
Renders an ABI trace file as a chromatogram graph.
Abstract implementation of AlignmentStyler, contains utility methods for generating a set of HTML styles from a list of RGB colours.
An abstract implementation of Alphabet.
A utility class to ease the problem of implementing an Annotation to that of providing an apropreate implementation of Map.
AbstractBeadRenderer is a an abstract base class for the creation of FeatureRenderers which use a 'string of beads' metaphor for displaying features.
An abstract implementation of BioEntryDB that provides the getBioEntryIterator method.
Useful base-class for objects implementing Changeable
A basic, abstract implementation of Chromatogram.
Abstract implementation of CrossOverFunction.
An abstract implementation of Distribution.
An abstract implementation of FeatureHolder.
Base class from which most implementations of GeneticAlgorithm will inherit.
An abstract implementation of Location.
Abstract Location decorator (wrapper).
an abstract class implementing basic functionality of a translation table that translates Symbols from one Alphabet to another.
 
Abstract implementation of MutationFunction all custom implementations should inherit from here.
Simple base class for OrderNDistributions.
Abstract implementation of Organism.
 
An abstract implementation of the OrthoPairCollection interface.
represents the Homologene Group.
A SequenceRenderer that renders a set of Features that match a FeatureFilter in such a way that they do not overlap in the display.
Most Population implementations will want to inherit from here.
Base class for simple contiguous Location implementations.
an abstract class implementing basic functionality of a translation table that translates Symbols from one Alphabet to another.
An abstract implementation of RichSequenceDB that provides the getRichSequenceIterator method.
An abstract implementation of SequenceDB that provides the sequenceIterator method.
Abstract implementation of SVMClassifierModel.
An abstract implementation of an SVMModel.
The base-class for Symbol implementations.
Abstract helper implementation of the SymbolList core interface.
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Abstract implementation of term This provides basic change-forwarding functionality from the annotation and ontology properties.
An abstract implementation of TrainingAlgorithm that provides a framework for plugging in per-cycle code for parameter optimization.
 
An abstract TagValueWrapper that does nothing!
AcnumHitReader reads the "acnum.hit" file of an EMBL CD-ROM format binary index.
AcnumTrgReader reads the "acnum.trg" file of an EMBL CD-ROM format binary index.
Interface for object which monitor long-running activities.
Dumping the data from biojava with source of agave into agave format
Deals with alternate sequence IDs
 
This interface defines mapping from BioJava into AGAVE format.
 
 
An interface that can be tested for by nested handlers when trying to do a callback.
Handles the AGAVE <bio_sequence> element
Handles the AGAVE <bio_sequence> element
An interface that can be tested for by nested handlers when trying to do a callback.
Handles the AGAVE <cds> element
An interface that can be tested for by nested handlers when trying to do a callback.
Handles the AGAVE <chromosome> element
 
 
 
An interface that can be tested for by nested handlers when trying to do a callback.
Handles the AGAVE <contig> element
 
this is the interface implemented by several classes
 
Deals with database crossreferences
Deals with database crossreferences
 
 
 
 
An interface that can be tested for by nested handlers when trying to do a callback.
 
 
 
Handles the root AGAVE element modified for agave format
 
 
 
Deals with AGAVE keywords
 
 
 
 
Deals with match_align
Deals with match_desc
match_region
Deals with match_region
Handles the AGAVE <mrna> element
Deals with note
Handles the AGAVE <predicted_protein> element
 
 
 
 
 
 
 
 
sci_property
seq_feature
seq_location
sequence_map
Deals with sequence code
transcript
unordered_fragments
Moves view attributes into annotation properties.
Writes Sequence into AGAVE XML document.
xref
 
handle AGAVE xref
xref_property
xrefs
Deals with database crossreferences (xrefs)
Joins multipel values into single values.
AlignIOConstants contains constants used to identify sequence formats, alphabets etc, in the context of reading and writing alignments.
An alignment containing multiple SymbolLists.
Iterator implementation looping over symbol lists in an alignment using the labels.
This Interface provides methods for the alignment of bio-sequences.
AlignmentElement is a class which represents a SymbolList and its location within an Alignment This is for use in UnequalLengthAlignments and ARAlignments.
 
Class to do simple HTML colouring of sequence alignments.
This class stores the result of an alignment procedure that creates a pairwise alignment of two sequences.
 
AlignmentStAXHandler handles the BlastLikeAlignment element of BioJava BlastLike XML.
The set of AtomicSymbols which can be concatenated together to make a SymbolList.
Map between Symbols and index numbers.
Utility methods for working with Alphabets.
AlphabetResolvers are helpers which determine which type of sequence Alphabet to expect from a search result.
Thrown to indicate that a term or triple can't be added to an ontology because it is already present.
Implementation of SymbolTokenization which binds symbols to strings of characters.
Indicates that an object has an associated annotation.
Deprecated.
use new ChangeForwarder.Retyper(source, cs, Annotation.PROPERTY) instead
SequenceDB implementation which lazily applies a SequenceAnnotator to sequences retrieved from a SequenceDB.
Arbitrary annotation associated with one or more objects.
Builds an Annotation tree from TagValue events using an AnnotationType to work out which fields are of what type.
AnnotationChanger remaps the values of an Annotation to new values specified by a ValueChanger.
A database of Annotation instances.
AnnotationFactory is a utility class for making Annotations from Maps.
AnnotationRenamer remaps the keys of an Annotation to new keys specified by a TagMapper.
AnnotationTools is a set of static utility methods for manipulating Annotations and AnnotationTypes.
A set of constraints on the data contained in an Annotation.
An abstract base class useful for implementing AnnotationType instances.
An implementation of AnnotationType.
Hello world!
Create a bean from an XML file, then attempt to enter it.
 
 
ARAlignment is an interface that defines methods for adding and removing seqeunces from an Alignment.
 
A Feature Renderer that paints the Feature as a right facing arrow Based heavily on BasicFeatureRenderer
A Glyph that paints an arrow shape within the bounds.
Support class for applications which need to patch together sections of sequence into a single SymbolList.
An unchecked exception representing an Assertion failure.
A symbol that is not ambiguous.
An exception thrown by classes of this package.
 
A backpointer.
A logo painter that paints in bars.
Base XMLWriter class for writing XML representations of Java Value Objects with bespoke architectures.
 
BasicImapRenderer is a decorator for BasicFeatureRenderer which adds the ability to create HTML image map coordinates which correspond to the feature rendering produced by the BasicFeatureRenderer.
 
A symbol that can be represented as a string of Symbols.
Train a hidden markov model using a sampling algorithm.
Train a hidden markov model using maximum likelihood.
BeadFeatureRenderers use a 'string of beads' metaphor for displaying features.
Create an Annotation with properties matching those of a JavaBean instance.
 
Between view onto an underlying Location instance.
It represents an article.
It represents a book.
It represents a book article.
The criteria define how the matching or ordering should be done during queries.
It represents an account of the content of the cited resource.
It defines information related to the citation itself rather than to the cited resource.
A class describing journals.
It represents a journal article.
It represents an organisation dealing with the bibliographic resources.
It represents a patent.
It represents a person dealing with the bibliographic resources.
It represents a conference proceeding.
This class and its sub-classes define active participants of the process of creation and dissemination of the bibliographic resources.
It represent an extent or scope of the content of the cited resource.
It represents a service dealing with the bibliographic resources.
It represents the topic of the content of the cited resource.
It represents a technical report.
It represents a thesis.
It represents a WWW resource.
This class is a core class of the bibliographic data model - it represents a bibliographic reference, a citation.
An exception raised when communciation with the BibRef APIs fails.
The interface BibRefQuery is a fundamental part of the Bibliographic Query Service.
This interface defines supporting utilities for working with bibliographic repositories.
solves y = f(x) = 0 by binary search.
This class relates to the bioentry table in BioSQL.
.
A database of BioEntrys.
Essentially the same as SequenceIterator.
Represents the relation between two bioentries.
A nestable biological error.
A nestable biological exception.
Simple SequenceDB implementation backed by a BioFetch (HTTP) server.
Directory-services plugin for biofetch databases.
The original object for indexing sequence files.
Interface for things that perform matches.
 
A nestable biological exception.
The class that accepts all features.
The class that accepts no features.
 
A simple implementation of CrossReferenceResolver
A filter for accepting or rejecting a feature.
A filter that returns all features accepted by both child filter.
Construct one of these to filter features by display name.
A filter that returns all features that have the given note, and the value and rank is checked as well.
A filter that returns all features that have a note with the given term.
Construct one of these to filter features by rank.
Accept features that reside on a sequence with a particular name.
Construct one of these to filter features by source.
Construct one of these to filter features by source (name only - parent ontology is ignored).
A filter that returns all features having locations on a given strand.
Construct one of these to filter features by type.
Construct one of these to filter features by type (name only - parent ontology is ignored).
A filter that returns all features contained within a location.
A filter for Hibernate-BioSQL filters to extend.
A filter that returns all features not accepted by a child filter.
A filter that returns all features accepted by at least one child filter.
A filter that returns all features overlapping a location.
A class representing some useful stuff you can do with BioSQLFeatureFilters, for instance converting plain FeatureFilters into a their BioSQLFeatureFilter equivalents (where possible).
Takes requests for RichObjects and sees if it can load them from a Hibernate database.
 
A handler which loads sequence data from a BioSQL database, caching it where possible.
Deprecated.
Use hibernate and org.biojavax.bio.db
Deprecated.
Use hibernate and org.biojavax.bio.db
BioStores represent directory and file structures which index flat files according to the OBDA specification.
BioStoreFactory creates BioStore instances.
Takes a SAX event stream and a HTMLRenderer to produce a HTML Blast like program report.
BlastLikeHomologyBuilder populates a List with Homology instances created from SAX events supplied via a SeqSimilarityAdapter.
A facade class allowing for direct SAX2-like parsing of the native output from Blast-like bioinformatics software.
BlastLikeSearchBuilder will create SeqSimilaritySearchResults from SAX events via a SeqSimilarityAdapter.
A SearchContentHandler class that implements filtering in chains of SearchContentHandler instances.
 
 
Applies test to the value specified by the key in hit properties.
Applies test to the value specified by the key in search properties.
Applies test to the value specified by the key in subhit properties.
 
 
 
A class that converts the raw output from a variety of bioinformatics software and converts it to XML that will validate against the biojava:BlastLikeDataSetCollection DTD.
This class parses NCBI Blast XML output.
A facade class that wraps the NCBI Blast XML parsing framework in a more user-friendly form.
 
StAX handler for any element which just contains a string representation of an boolean.
 
 
A Comparator similar to Feature.ByLocationComparator except that the min and max positions of the location are both compared
Comparator that compares the min and max positions of Features Required by org.biojava.bio.gui.sequence.AbstractPeptideDigestRenderer instances.
Factory for objects which encapsulate individual Java bytecode instructions.
StAX handler for any element which just contains a string representation of a byte.
Interface for managing caches of objects.
Interface for managing caches of objects fetchable by key.
Interface for a reference to an object, analogous to java.lang.ref.Referencce, but more flexible.
A wrapper around InputStream that provides in-memory caching of the input data.
Caches the results of a nested kernel so that k(a, b) need only be calculated once.
SequenceDB implementation that caches the results of another SequenceDB.
This is a basic container for a vocabulary entry.
 
This interface is a main entry point to a set of controlled vocabularies.
This interface defines functionality of a controlled vocabulary.
A constraint on the number of values a property can have.
A single cell in the DP matrix.
The interface for all functions that can calculate the 'scores' array for a given cell.
 
The interface for all functions that can calculate the 'scores' array for a given cell.
This is a flag interface that defines the common add/remove listener methods for classes and interfaces that wish to indicate that they are sources of ChangeEvents.
A cache that clears values as the keys fire ChangeEvents of a given type.
This is a ChangeListener that ignores everything.
Event which encapsulates a change in any mutable BioJava object.
This is a ChangeListener that is designed to adapt events of one type from one source to events of another type emitted by another source.
A ChangeForwarder that systematically uses a given type and wraps the old event.
Interface implemented by ChangeHubs, i.e.
Interface for objects which listen to ChangeEvents.
An implementation that always vetoes everything.
A listener that remembers the ChangeEvent of the last change.
A listener that writes information about the event stream to a PrintStream.
A utility class to provide management for informing ChangeListeners of ChangeEvents.
A mapping between keys and actions to turn old values into new values.
An implementation of Changer that applies a list of Changer instances to the value in turn.
Callback used to produce a new value from an old one.
Callback used to produce a list of values from a single old one.
Class for all constants which are used to indicate change types.
Exception which is thrown when a ChangeListener does not wish a change to take place.
Represents Nexus characters blocks.
Builds Nexus characters blocks.
Listens to events that represent Nexus characters blocks.
Parses Nexus characters blocks.
Implementation of SymbolTokenization which binds symbols to single unicode characters.
StAX handler for any element which just contains a string representation of a char.
Encapsulates the basic information you would want from a chromatogram.
A factory that creates Chromatogram objects from files or streams.
Encapsulates a configurable method for drawing a Chromatogram into a graphics context.
A typesafe enumeration of the options available for configuring the behavior of a ChromatogramGraphic instance.
Provides the mechanism whereby a ChromatogramGraphic can display a Chromatogram with a non-linear horizontal scale.
The default scaler that displays the chromatogram 1:1.
Utility class for dealing with Chromatograms.
SymbolList implementation using constant-size chunks.
class that makes ChunkedSymbolLists with the chunks implemented as SymbolLists themselves.
 
 
 
Circular view onto an underlying Location instance.
Renders multiple renderers, each in their own concentric rings.
 
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Render information from a CircularRendererContext onto a graphics context.
A context providing information for rendering sequences into circular coordinate systems.
Renders a sequence as a circle using a CircularRenderer.
A circular view onto another Sequence object.
A simple toy example that allows you to put points on a canvas, and find a polynomial hyperplane to seperate them.
An extention of JComponent that contains the points invalid input: '&' encapsulates the classifier.
 
Utility methods for manipulating class objects and resources.
A SAX2 parser for dealing with a multiple sequence alignment as produced by ClustalW outputing .aln format.
Interface for Java classes within the bytecode generation framework.
Interface which encapsulates the stream to which Java bytecode can be written.
An exception indicating that something went wrong generating byte code.
Wrap up details about a field in a Java class file.
Interface for an object which can produce Java bytecode.
Wrap up details about a method in a Java class file
Utility code for things you will frequently need.
 
 
 
 
 
An utility class for codon preferences
Used by AnnotationType to represent the constraint on the collection of values in a property-slot.
CollectionConstraint which validates all members of a Collection.
A collection constraint that accpepts collections iff they are accepted by both child constraints.
CollectionConstraint which validates a portion of a Collection.
A collection constraint that accepts items iff they are accepted by either child constraints.
Interface for specifying whether a particular pair of residues/bases should be coloured.
A simple ranked comment designed to be used for BioEntry comments in BioSQL.
Implementations of Commitable support atomic changes from one known state to another via commit/rollback semantics.
 
An implementation of DataStore that will map onto a file using the NIO constructs.
Builder for a data store that is backed by a java.nio.MappedByteBuffer.
An Ontology that can be compared to another.
Makes Term objects comparable properly and adds some extra features to them.
Comparable triples, obviously.
Feature which represents a component in an assembly (contig).
Template for constructing a new ComponentFeature.
Computes composition statistics about a SymbolList.
An implementation of RichLocation which covers multiple locations, but on the same strand of the same (optionally circular) sequence.
interface for classes that return a single double precision value for a single double precision argument.
Build a Java class file constant pool.
Some usefull constants for working with binary files.
An encapsulation of a count over the Symbols within an alphabet.
 
Utility class that calculates a CRC64 checksum on a stream of bytes.
CrosshairRenderer draws a crosshair, optionally with coordinates.
Crosses two chromosomes.
A place holder CrossOverFunction that doesn't perform cross overs
Tokenization for cross-product alphabets.
Represents a cross reference to another database.
An exception that indicates that an attempt to resolve a CrossRef has failed.
This interface returns symbols or sequence for a given cross-reference.
Takes a database ID and some configuration properties ( such as base URL ) and returns either a URL or a full anchor tag.
Represents Nexus data blocks.
Builds Nexus characters blocks.
Listens to events that represent Nexus data blocks.
Parses Nexus data blocks.
A repository that can be searched with a sequence.
Builder for a data store.
Deprecated.
Use hibernate and org.biojavax.bio.db
 
 
 
This is purely for debugging purposes.
Default implementation of OntologyOps.
A simple default URLGeneratorFactory which returns a single NcbiDatabaseURLGenerator instance.
Interface which exposes delegation services offered by a StAX event source.
Interface which exposes delegation services offered by a StAX event source.
 
Adds a class specific constant to k(x, x).
Caches the leading diagonal of a kernel matrix.
This class contains methods for calculating the results of proteolytic digestion of a protein sequence this class is not designed to be thread safe
 
Represents Nexus distances blocks.
Builds Nexus distances blocks.
Listens to events that represent Nexus distances blocks.
Parses Nexus distances blocks.
Object which contributes data to a DistributedSequenceDB.
Sequence database from the meta-DAS system.
An encapsulation of a probability distribution over the Symbols within an alphabet.
Deprecated.
use new ChangeForwarder.Retyper(this, cs, Annotation.PROPERTY) instead
A thing that can make Distributions.
The default DistributionFactory implementation.
The GUI component for rendering a DistributionLogo.
A class to hold static methods for calculations and manipulations using Distributions.
An object that can be used to train a distribution up.
A context within a group of DistributionTrainers can be trained together.
DivisionLkpReader reads the "division.lkp" file of an EMBL CD-ROM format binary index.
Packing utility class for DNA.
Computes composition statistics about a DNA SymbolList.
A Packing implementation which handles the DNA alphabet, without any support for ambiguity symbols.
A simple implementation of SymbolStyle optimized for DNA.
Useful functionality for processing DNA sequences.
Represents a documentary reference.
Represents an author of a documentary reference.
Useful tools for working with authors.
A Dot state.
An efficient implementation of an Alphabet over the infinite set of double values.
A range of double values.
A single double value.
A class to represent a contiguous range of double symbols.
StAX handler for any element which just contains a string representation of a double.
 
Objects that can perform dymamic programming operations upon sequences with HMMs.
 
This is an implementation of CellCalculatorFactoryMaker that compiles the HMM object down to Java byte-code that is equivalent in behaviour to the interpreter.
Encapsulates the dynamic programmming matrix, and the context within algorithms work.
The interface for objects that can generate a DP object for a MarkovModel.
 
 
 
 
A simple implementation of CrossReferenceResolver.
 
A Sequence implementation that has a name and URI but no features, and a zero length symbol list.
DummySequenceDB is an implementation which contains only a DummySequence.
DummySequenceDBInstallation is an implementation which returns the same DummySequenceDB instance regardless of the identifier used to retrieve a database.
Symbol list which just consists of non-informative symbols.
 
Simple URL generator for EMBL at the EBI.
Deprecated.
replaced by classes in org.biojavax.bio.taxa
A simple listener that just echoes events back to the console.
An ec (enzyme classification) number.
A simple implementation of EcNumber.
Encapsulates an edit operation on a SymbolList.
EditableAlignment is an interface that defines methods for shifting bases within an Alignment.
Simple interface for filtering SAX/StAX startElement events.
This class is copied to agave package Simple interface for filtering SAX/StAX startElement events
Simple interface for filtering SAX/StAX startElement events
 
 
 
Filter elements by local name (not recommended).
Filter elements by local name (not recommended).
Filter elements by local name (not recommended).
Filter elements by name and namespace.
Filter elements by name and namespace.
Filter elements by name and namespace.
Filter elements on the existence of a specified attribute.
Filter elements on the existence of a specified attribute.
Filter elements on the existence of a specified attribute.
EllipticalBeadRenderer renders features as simple ellipses.
 
Map EMBL data into AGAVE format
EmblCDROMIndexReader is an abstract class whose concrete subclasses read EMBL CD-ROM format indices from an underlying InputStream.
EmblCDROMIndexStores implement a read-only IndexStore backed by EMBL CD-ROM format binary indices.
EmblCDROMRandomAccess is an abstract class whose concrete subclasses can perform fast lookups in EMBL CD-ROM format index files.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Format reader for EMBL files.
Implements some EMBL-specific terms.
Deprecated.
Use org.biojavax.bio.seq.io.EMBLFormat instead
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Factory which wraps SequenceBuilders in an EmblProcessor
 
Format reader for EMBLxml files.
Implements some EMBLxml-specific terms.
Cache for columns of emission probabilities in pair-wise alignment algorithms.
A state in a markov process that has an emission spectrum.
A place holder for a RichAnnotation that prevents null having to be used
An Empty implementation of RichLocation.
EntryNamIdxReader reads the "entrynam.idx" file of an EMBL CD-ROM format binary index.
EntryNamRandomAccess objects provide random access to records within the "entrynam.idx" file of an EMBL CD-ROM format binary index.
 
Makes running external executables easier, optionally under a watched thread.
Utility class to execute an external process and to handle the STDOUT, STDERR and STDIN streams in multiple threads managed by a thread pool.
This class implements the AlignmentFormat interface to read FASTA alignments.
Deprecated.
Use org.biojavax.bio.seq.io.FastaFormat
Factory which wraps SequenceBuilders in a FastaDescriptionLineParser
Deprecated.
Use org.biojavax.bio.seq.io.FastaFormat
Format object representing FASTA files.
This class is used by FastaFormat to determine which fields are in the fasta header.
FastaSearchSAXParser is a SAX2 compliant parser for '-m 10' format output from the the Fasta search program (see the Fasta documentation for details of this format).
A SAX2 parser for dealing with multiple sequences in FASTA format.
FASTQ formatted sequence.
Fluent builder API for creating FASTQ formatted sequences.
Reader for FASTQ formatted sequences.
Utility methods for FASTQ formatted sequences.
FASTQ sequence format variant.
Writer for FASTQ formatted sequences.
Simple implementation of XMLWriter, optimized for speed.
A feature within a sequence, or nested within another feature.
ByLocationComparator compares Features by the minimum base position of their Location.
Template class for a plain feature.
FeatureBlockSequenceRenderer forms a bridge between Sequence rendering and Feature rendering.
A filter for accepting or rejecting a feature.
A filter that returns all features accepted by both child filter.
Retrieve features that contain a given annotation, and that the set of values contains the value given.
Filter by applying a nested FeatureFilter to all ancestor features.
Retrieve features that contain a given annotation with a given value.
A filter that returns all features that have an annotation bundle that is of a given annotation type.
Filter by applying a nested FeatureFilter to the child features.
Filter which accepts only those filters which are an instance of a specific Java class
Accepts features which are ComponentFeatures and have a componentSequenceName property of the specified value.
Filter by applying a nested FeatureFilter to all descendant features.
Accept only features which are equal to the specified feature
ByPairwiseScore is used to filter SimilarityPairFeatures by their score.
Filter by applying a nested FeatureFilter to the parent feature.
Accept features that reside on a sequence with a particular name.
Construct one of these to filter features by source.
Construct one of these to filter features by type.
A filter that returns all features contained within a location.
Accept features with a given reading frame.
Retrieve features that contain a given annotation with any value.
A filter that returns all features not accepted by a child filter.
Accepts features where all immediate children meet the supplied filter.
Accepts features where all descendants meet the supplied filter.
A filter that returns all features accepted by at least one child filter.
A filter that returns all features overlapping a location.
A filter that accepts all features whose shadow is contained by a specified Location.
A filter that accepts all features whose shadow overlaps a specified Location.
Accept features with a given strandedness.
StAX handler for the basic feature type of XFF.
The interface for objects that contain features.
 
This class intendes to provide some FeatureHolder utilities.
Wrap up default sets of Feature implementations.
 
 
 
 
 
Interface for translators which map from Feature.Template instances to real Feature objects.
 
A closure that allows AbstractPeptideDigestRenderer implementations to obtain the features of the rendered sequence.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
FeatureTree is GUI tree to display the features and annotations of the sequences in a SequenceDB Nested Features are displayed as expandable leaves.
Registry of known types of features.
A named collection of Types.
A simple implementation of a Repository.
A type of feature.
 
FileAsList creates a writable List implementation backed by a random access file.
 
 
Class for implementing tests with BlastLikeSearchFilter objects.
Tests that the value associated with the specified key is equal to the value supplied here by whatever criterion of equality appropriate to those objects.
Tests that the value associated with the specified key contains a part matched by the supplied regex.
Tests that the value associated with the specified key is greater than the specified threshold.
Tests that the value associated with the specified key is less than the specified threshold.
Tests that the value associated with the specified key is matched in its entirety by the supplied regex.
Base-class for visitors that re-write a filter tree.
A set of FeatureFilter algebraic operations.
An object able to transform some FeatureFilter instances sytematically into others.
An alphabet over a finite set of Symbols.
Class for modelling finite automata.
Calculates the fitness of an Organism in a Population of Organisms
A ChromatogramNonlinearScaler that scales all the base calls in a chromatogram to the same width in pixels, optionally biasing the peak of the call to the center.
Cache which stores up to limit Objects.
A cache that only remembers a given number of keys.
Provides a cache for storing multiple small files in memory.
A UnigeneFactory that will use flat-file indexing of the unigene ascii-art files.
FlatSequenceDB is an OBDA flatfile sequence databank implementation.
FlatSequenceDBProvider directory-services plugin for flatfile databases.
FlexibleAlignment is a class which implements UnequalLengthAlignment, ARAlignment and EditableAlignment It places no restriction on where any sequence can be in the alignment so there could be gaps in the alignment.
StAX handler for any element which just contains a string representation of a float.
A file format supported by the tag-value event-based parsing system.
This is intended as a repository for tag-value and AnnotationType information about common file formats.
 
Title: Frame.
Title: FramedFeature.
A singleton to hold the frame information
 
This is a class for representing the full HMMER generated Profile HMM (including loop states N and C terminal looping states).
An atomic symbol consisting only of itself.
A 'fuzzy' location a-la Embl fuzzy locations.
Determines how a FuzzyLocation should be treated when used as a normal Location.
FuzzyPointLocation represents two types of EMBL-style partially-defined locations.
Determines how a FuzzyPointLocation should be treated when used as a normal Location.
Holds the results of a CrossOver event, objects of this type are made by CrossOverFunctions
Holds the results of a CrossOver event, objects of this type are made by CrossOverFunctions
Handles the GAME <annotation> element
Handles the GAME <annotation> element
Handles the GAME <aspect> element
Handles the GAME <aspect> element
Handles the GAME <dbxref> element
Deals with database crossreferences
StAX handler for GAME <description> elements.
An interface that can be tested for by nested handlers when trying to do a callback.
Handles the <feature_set> element
Handles the GAME <feature_set> element this element is used to represent transcripts.
Handles the GAME element
Handles the <feature_span> element
Handles the GAME <feature_span> element
A rudimentary read-only GAME 1.2 Format object.
Handles the GAME <annotation> element
Handles the GAME <gene> element
Handles the root GAME element
Handles the root GAME element
Handles the GAME <map_position> element Currently, it just ignores it!
An interface that can be tested for by nested handlers when trying to do a callback.
StAX handler for the GAME <name> element.
Handles the GAME <dbxref> element
StAX handler for GAME <residues> elements.
Handles the GAME <seq> element
Handles the GAME <seq> element
Handles the GAME <> element
Handles the GAME <aspect> element
Handles the GAME <> element.
Handles the GAME <span> element Currently, it just ignores it!
An interface that can be tested for by nested handlers when trying to do a callback.
StAX handler for GAME <type> elements.
This distribution emits gap symbols.
A renderer that will display a gapped sequence as a discontinuous series of regions.
Extension of GappedSymbolList which also projects features into the gapped coordinate system.
This extends SymbolList with API for manipulating, inserting and deleting gaps.
Used by a GeneticAlgorithm.run() method to determine when the algorithm should stop
Simple Implementation of GAStoppingCriteria, signals a GeneticAlgorithm to stop after n generations
Utility methods for the GA library
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Deprecated.
Use org.biojavax.bio.seq.io.GenbankFormat
Format reader for GenBank files.
Implements some GenBank-specific terms.
Parses Genbank location strings into RichLocation objects.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Factory which wraps sequence builders in a GenbankProcessor
This class contains functions accessing DNA sequences in Genbank format.
This class contains functions accessing DNA sequences in Genbank format.
Deprecated.
Use org.biojavax.bio.seq.io.INSDseqFormat
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Deprecated.
Use org.biojavax.bio.seq.io framework instead
A class loader that actually produces real Java classes from GeneratedCodeClass instances.
A CodeClass implementation that is used to generate new classes.
A method that will be generated.
The class that runs the cycles of reproduction, evolution and selection, potentially on multiple Populations
Collects the references to translation methods in one place.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
This class contains functions accessing Peptide sequences in Genpept format.
 
The interface for things that listen to GFF event streams.
Parse a stream of GFF text into a stream of records and comments.
A record in a GFF3 formatted file.
 
Use a GFFEntrySet as a DataSource for adding annotation to sequences.
The interface for things that listen to GFF event streams.
A set of entries and comments as a representation of a GFF file.
Interface which captures any errors which occur when parsing a GFF stream.
 
 
An object that filters a stream of GFF, forwarding some GFFRecords to a listening GFFDocumentHandler, and dropping others.
Parse a stream of GFF text into a stream of records and comments.
A single GFF record.
A filter that will accept or reject a GFFEntry.
Implementation of GFFRecordFilter that accepts everything.
Implementation of GFFRecordFilter that accepts records based upon the feature field.
 
 
Implementation of GFFRecordFilter that accepts records based upon the sequence name.
Implementation of GFFRecordFilter that accepts records based upon the source field.
 
 
Listens to a stream of GFF events and writes the lines to a PrintWriter.
The Glyph interface for painting a shape within bounds
A FeatureRenderer that renders a particular Glyph for Features accepted by a particular FeatureFilter
Utils class used by Glyph implementors.
Simple parser for the Gene Ontology (GO) flatfile format.
 
An implementation of RichSequenceDB that uses an underlying HashMap to store the RichSequence objects.
Iterates over a Fasta file that is kept in memory for optimized access.
An implementation of RichSequenceDB that uses an underlying HashMap to store the RichSequence objects.
An implementation of SequenceDB that uses an underlying HashMap to store the sequence objects.
HeaderStAXHandler handles the Header element of BioJava BlastLike XML.
A stand-alone SequenceRenderContext to make it easy to render to an image.
A Glyph that paints a Helix within the bounds
A listener that merges overlapping hits and culls all hits under a given length.
AlignmentStAXHandler handles the Hit element of BioJava BlastLike XML.
This is a class for representing HMMER generated Profile HMM.
A class for parsing in Hmmer markov models from HMM_ls files generated by HMMER training note that this class is still currently experimental.
interface implemented by objects that train HMMs.
an interface for Homologene dataset Builders
Homologene is a NCBI dataset that curates sets of orthologues from the reference model organisms.
Homologene is a NCBI dataset that curates sets of orthologues from the reference model ogranisms.
Signifies that two or more features are homologous.
 
 
 
HSPStAXHandler handles the HSP element of BioJava BlastLike XML.
HSPSummaryStAXHandler handles the HSPSummary element of BioJava BlastLike XML.
Renders HTML version of blast-like output.
Deprecated.
Use hibernate and org.biojavax.bio.db
Marks an implementor as having a LifeScienceIdentifier.
Interface for objects that define how to make an ID for a sequence.
 
 
A CodeGenerator that provides something semanticaly identical to if.
A distribution trainer that just ignores all counts.
Ignore this record in the stream.
The usual reason for throwing an IllegalAlignmentEditException is that you are trying to shift a group of bases in such a way that it would require deleting bases.
The exception to indicate that an invalid alphabet has been used.
 
Indicates an invalid organism
The exception to indicate that a symbol is not valid within a context.
This exception indicates that there is no transition between two states.
Reader for FastqVariant.FASTQ_ILLUMINA formatted sequences.
Writer for FastqVariant.FASTQ_ILLUMINA formatted sequences.
ImageMap represents a collection of image map hotspots.
ClientSide represents a client-side style image map.
HotSpots represent an image map hotspot.
ServerSide represents a server-side style image map.
ImageMapRenderers create strings representing Features suitable for use in HTML image maps.
This defines an index entry for an individual sequence within a set of indexed files.
 
A database of Annotation instances backed by an indexed file set.
A factory for retrieving parsers and listeners.
An implementation of ParserListenerFactory that uses a static method.
implements Changeable support with a ChangeHub that stores ChangeListener by key.
An encapsulation of a count over the Symbols within a FiniteAlphabet using an AlphabetIndex object.
This class implements SequenceDB on top of a set of sequence files and sequence offsets within these files.
Listens to tag-value events and passes on indexing events to an IndexStore.
Listens to tag-value events and passes on indexing events to an IndexStore.
IndexStore is an interface for indexing flatfiles according to the OBDA specification.
This defines the objects that IndexedSequenceDB uses to store all of the database state, such as name, format, sequence builder and the actual file offsets.
IndexTools contains static utility methods for creating flatfile indices according to the OBDA standard.
A symbol list that is Integer.MAX_VALUElong, never gives index out of bounds and always returns ambiguity symbols for everything.
 
Interface to a threadable input handler for an external process.
A class that provides an InputStream from a File.
Format reader for INSDseq files.
Implements some INSDseq-specific terms.
Base class for java bytecode instructions.
A list of Instructions and/or other CodeGenerator objects.
An efficient implementation of an Alphabet over the infinite set of integer values.
A single int value.
A class to represent a finite contiguous subset of the infinite IntegerAlphabet
 
 
StAX handler for any element which just contains a string representation of an integer.
CodeClass instances that represent normal Java Class objects.
Thrown to indicate that an ontology term is not acceptable or appropriate in a given context
Class that computes isoelectric point for denaturated proteins.
A simple Object-double tuple.
Really simple connection pool for JDBC databases.
Returns a DataSource that implements connection pooling Uses Jakarta Commons DBCP and Pool packages.
Subclass of WeakReference which includes and extra field (the key) which can be used to help cleanup once this reference has been enqueued.
An object to find exact subsequences within a sequence.
A Label used to mark a position in byte code.
Renderer which draws a track of sequence with a textual label.
The interface for things that can render labels for a line of information about a sequence.
 
Wrapper arround MappedByteBuffers to allow long-indexed access to files larger than 2 gigs.
LayeredRenderer handles the lane offsets for MultiLineRenders.
Wrapper implementation of FeatureHolder which calls a method to create a contained FeatureHolder on demand.
An implementation of AnnotationDB that lazily applies a filter.
FeatureHolder which lazily applies a specified filter to another FeatureHolder.
An implementation of AnnotationDB that does a JIT search on another set.
Life Science Identifier (LSID).
Exception thrown in the event of an error in parsing a LSID-formatted string.
 
 
 
 
A LIGHT implementation of PairDPCursor.
Deprecated.
Just use SparseVector.kernel instead...
Encapsulates the rendering info for a single line of the display.
A parser that splits a line into tag/value at a given column number.
This kernel computes the sum of the dot products between items of two lists at corresponding indexes.
 
 
Maps one object to another.
A list that represents a series of values.
 
A local variable.
A set of integers, often used to represent positions on biological sequences.
Handler to the XFF location type.
Tools class containing a number of operators for working with Location objects.
 
The interface for something that will draw the sequence logo for a state.
StAX handler for any element which just contains a string representation of a long.
Start/end state for HMMs.
A translation table that will handle the many-to-one mappings that you see, for example, with genetic codes.
Builder for a data store that is backed by a java.nio.MappedByteBuffer.
A CodeGenerator that just marks a label that can be used for jumps.
A markov model.
MassCalc calculates the mass of peptides which for our purposes are SymbolLists which contain Symbolsfrom the protein Alphabet.
This class is analogous to java.util.Matcher except that it works on SymbolLists instead of Strings.
 
A BioMatcher class returned by MaxMismatchPattern.matcher() that implements searching of a SymbolList.
This class permits searching a SymbolList with another SymbolList while permitting a specified number of mismatches.
The results of a meme run.
Merged view onto a list of underlying Annotation objects.
FeatureHolder which exposes all the features in a set of sub-FeatureHolders.
Produced by LocationTools as a result of union operations.
An AnnotationDB that provides a merged view of a list of underlying DBs.
 
 
A state that contains an entire sub-model.
Encapsulates the training of an entire model.
MotifTools contains utility methods for sequence motifs.
 
MultiLineRenderer is a SequenceRenderer which collects a number of other SequenceRenderers each of which render their own view of a Sequence.
 
An implementation of RichLocation which possibly covers multiple locations, on different strands, different circular lengths, or different sequences.
Partician multiple values for a tag into their own tag groups.
A class that mutates a SymbolList
Place Holder class that doesn't mutate its SymbolLists
Deprecated.
Use hibernate and org.biojavax.bio.db
The namespace of an entry in a database schema.
Simple implementation of SymbolTokenization which uses the `name' field of the symbols.
Simple URL generator for Entrez at the NCBI.
 
Represents an NCBI Taxon entry, a combination of the taxon and taxon_name tables in BioSQL.
Implementors are able to load taxonomy files and generate sets of NCBITaxon objects that represent them.
Needleman and Wunsch defined the problem of global sequence alignments, from the first till the last symbol of a sequence.
Encapsulates a kernel that wraps another kernel up.
Support class for applications which need to patch together sections of sequence into a single SymbolList.
A Sequence which is assembled from other sequences contained in a set of ComponentFeature objects.
Represents a Nexus block.
 
Builds a Nexus block from listening to events.
This abstract version knows how to build and add comments.
Listens to events from NexusBlockParser objects to create objects.
Parses Nexus blocks.
All block parsers should derive from this abstract parser.
Represents a Nexus comment, possibly nested.
Represents Nexus files.
Builds a Nexus file by listening to events.
Reads/writes Nexus files and fires events at a NexusFileListener object.
Listens to events fired by the Nexus parser.
Example abstract implementation which all others should extend.
Represents general info about nexus objects.
Class for modelling non-deterministic finite automata.
 
This class caches a reference to all objects that it directs its delegate to make.
Builder for a datastore that has no practical file size limit.
Performs a normalization on the results of a nested kernel.
Note is a generic class intended to hold a term describing the note, a value to associate with that term, and a rank.
Useful functionality for processing nucleotide sequences.
 
 
This class encapsulates all the parsing of the OBDA registry configuration file.
Singleton class for parsers that understand OBDA URIs.
utility methods for implementing the equals() and hashCode() methods of Objects.
an interface for events that occur during parsing of .obo files
A file handler for .obo files
A class to parse the content of an OBO file.
 
Parses an OBO file.
OffsetRulerRenderer can render the ruler starting from an arbitrary offset from the sequence.
An ontology.
A basic in-memory implementation of an ontology
Thrown to indicate an error in an Ontology object
A factory for Ontology instances.
This is an interface for optimizing ontology operators.
A term in an ontology which identifies another ontology.
Simple in-memory implementation of a remote ontology term.
Tools for manipulating ontologies.
The interface for filters that can potentialy optimize themselves, and compare themselves with other filters.
Deprecated.
Use hibernate and org.biojavax.bio.db
This does a 2-point-crossover on two chromosomes keeping the Symbols in each chromosome constant.
Provides an N'th order distribution.
Default factory for Order-N distributions.
A GA 'organism' contains one or more Chromosomes
Deprecated.
Use org.biojavax.bio.taxa framework instead
Factory which wraps SequenceBuilders in an OrganismParser.
this entry contains data about the orthologue.
 
 
 
 
 
 
 
 
 
 
 
 
Interface for classes that store and manipulate orthologues.
An iterator for the contents of an OrthologueSet.
Each HomologeneEntry represents a single Homologene record that relates two presumptive orthologues.
Interface for a Set of OrthoPairSets
Iterator for a OrthoPairCollection
 
 
 
 
 
 
 
 
 
 
represents the Homologene Group.
 
 
 
all OrthoPairs must meet the requirement defined by filter.
 
 
 
 
 
at least one OrthoPair must meet the requirement defined by filter.
 
Interface to a threadable output handler for an external process.
Annotation implementation which allows new key-value pairs to be layered on top of an underlying Annotation.
Overlap one map onto another.
This is a dummy interface to permit identification of renderers whose output is to be overlaid along the lines of the Marker Interface pattern.
This class wraps SequenceRenderer classes to present an Overlay Marker interface that will indicate to LayeredRenderer that subsequent renderers should overdraw the same space as the wrapped renderer.
A SymbolList that stores symbols as bit-patterns in an array of longs.
This class makes PackedSymbolLists.
An encapsulation of the way symbols map to bit-patterns.
A factory that is used to maintain associations between alphabets and preferred bit-packings for them.
A renderer that adds padding before and after a delegate renderer.
Class for pairing up two independant distributions.
A cursor over a DP matrix.
Storage structure for intermediate values from a pairwise dynamic programming run.
PairwiseDiagonalRenderer renders a region of similarity between two sequences as a straight line.
Algorithms for dynamic programming (alignments) between pairs of SymbolLists.
PairwiseFilteringRenderer wraps a PairwiseSequenceRenderer and filters the PairwiseRenderContexts passed to it.
PairwiseOverlayRenderer allows a list of other PairwiseSequenceRenderers to superimpose their output.
PairwiseRenderContext encapsulates information required for the rendering of a pair of sequences.
A PairwiseSequencePanel is a panel that displays a pair of sequences; one sequence (the primary) may be either left-to-right (HORIZONTAL) or from top-to-bottom (VERTICAL).
PairwiseSequenceRenderers render information about the relationship between two sequences.
PairwiseRendererForwarder forward events to other renderers.
 
A template type.
Event which signals a bad line when parsing a record.
Listener for a ParseErrorEvent.
Source for a ParseErrorEvent.
ParseException should be thrown to indicate that there was a problem with parsing sequence information.
Low-level event based parser callback.
Encapsulate the parsing of lines from a buffered reader into tag-value events.
Exception thrown when an error occurs in document parsing.
ParserListener is an immutable pairing of a parser and listener.
 
A class analogous to java.util.regex.Pattern but for SymbolLists.
 
A class that creates Patterns for regex matching on SymbolLists of a specific Alphabet.
 
 
A SAX2 parser for dealing with native PDB files.
A class that converts Protein Data Bank (PDB) to XML that will validate against the biojava:MacromolecularStructure DTD.
A concrete AbstractPeptideDigestRenderer.
Format object representing Phred Quality files.
PhredSequence is an extension of SimpleSequence that implements Qualitative to hold Phred quality scores.
PhredTools contains static methods for working with phred quality data.
Builds a PHYLIP file by listening to events.
Reads PHYLIP interleaved alignment files and fires events at a PHYLIPFileListener object.
Listens to events fired by the PHYLIP parser.
A painter that just draws a block (or bar).
A simple implementation of SymbolStyle that just uses a single paint for outlines and a single paint for filling.
A location representing a single point.
This kernel computes all possible products of order features in feature space.
A collection of GA organisms
Holds info about base positions.
Resolves a position that is fuzzy or covers a range of bases by converting it to a single base.
The minimal resolver returns the base which provides the average range, halfway between maximal and minimal.
The maximal resolver returns the base which provides the largest possible range.
The minimal resolver returns the base which provides the smallest possible range.
 
 
Implementation of XMLWriter which emits nicely formatted documents to a PrintWriter.
Exception which is thrown if a child process managed by ProcessTools exceeds a specified time limit.
Deprecated.
preferable to use org.biojava.utils.ExecRunner or the org.biojava.utils.process package.
A state in a HMMer model.
 
Internal class used by ProjectionEngine to wrap Feature objects.
Helper class for projecting Feature objects into an alternative coordinate system.
Interface implemented by all projected feature objects.
Interface that defines the projection between original features and projected features.
Factory for proxy objects which project BioJava features into alternate coordinate systems.
Internal helper class.
This is an interface for things that project feature templates.
Some common things you want to do while projecting features.
StAX handler for xff:prop detail elements.
Interface for objects that change tag names or properties systematically.
PropertyConstraints describes a constraint applied to the members of an annotation bundle.
A property constraint that accpepts items iff they are accepted by both child constraints.
ByAnnotationType accepts a property value if it belongs to type defined by AnnotationType.
ByClass accepts a property value if it is an instance of a specific Java class.
Enumeration accepts a property if it is present in the specified set of values.
Matches properties if they have exactly this one value.
A property constraint that accepts items iff they are accepted by either child constraints.
 
A Selection function that determines the proportion of individuals in a new population proportionally to their fitness.
The protease class stores parameters needed by Digest to digest a protein sequence.
Registry and utility methods for Proteases.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Factory which wraps sequence builders in a ProteinRefSeqProcessor
The central port-of-call for all information and functionality specific to SymbolLists over the protein alphabet.
ProviderNotFoundException is thrown when a sequence database provider can not be located.
Qualitative is an interface for classes wanting to hold quality data in symbolic form such as Phred scores.
 
This kernel computes the radial base kernel that corresponds to a gausian distribution.
 
RandomAccessReader extends Reader to provide a means to create buffered Readers from RandomAccessFiles.
A simple implementation of Location that contains all points between getMin and getMax inclusive.
Allows cross-references to other databases to be ranked.
Defines an object as being able to have ranked cross references associated with it.
Represents a documentary reference.
Reader input handler that reads the input for an external process from a reader.
A multi threaded class which pipes the contents of an input reader to an output writer.
Interface for FeatureHolder objects which know how to instantiate new child Features.
Record represents a record within an indexed flat file databank as defined by the OBDA standard.
Impl is the default implementation of Record.
A Glyph that paints a rectangle shape within the bounds.
RectangularBeadRenderer renders features as simple rectangles.
RectangularImapRenderer is a decorator for RectangularBeadRenderer which adds the ability to create HTML image map coordinates which correspond to the feature rendering produced by the RectangularBeadRenderer.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
A ValueChanger.Changer that returns a specific match value using a regex Pattern.
An exception thrown by classes of this package.
 
A TagValueParser that splits a line based upon a regular expression.
A ValueChanger.Splitter that splits a line of text using a regular expression, returning one value per match.
Registry is a factory which gets implementations of the BioJava SequenceDBLite interface.
The BioDirectory Registry is a simple system for specifying where to find services which provide sequence databases.
A RegistryConfiguration that allows you to treat other configurations as providing important or default configuration information.
A simple implementation of RegistryConfiguration backed by a Map.
A RegistryException thrown when the registry cannot find an implementation of a requested SequenceDB.
An alignment that relabels another alignment.
A feature that indicates that there is some remote feature that can't be represented entirely on a single Sequence.
A tuple of Location and sequence ID.
The interface for objects that actually can take a RemoteFeature and return a Sequence object with the feature resolved into a real feature.
 
RemotePairwiseAlignmentOutputProperties: the simplest representation of an object capable of holding output formatting informations to be fed to a RemotePairwiseAlignmentService-implemented object.
RemotePairwiseAlignmentProperties is a interface that contains the barest of methods for setting and getting Alignment properties.
This interface specifies minimal information needed to execute a pairwise alignment on a remote service.
This class implements RemotePairwiseAlignmentProperties by specifying several convenient methods used to wrap the addition of Blast alignment parameters.
The RemoteQBlastOutputFormat enum acts like static fields for specifiying various values for certain output options.
The actual implementation of the RemotePairwiseAlignmentOutputProperties interface for the QBlast service.
RemoteQBlastService - A simple way of submitting BLAST request to the QBlast service at NCBI.
A term in another ontology.
Simple in-memory implementation of a remote ontology term.
A good base class to implement ProjectionContext from.
 
SAX EntityResolve which looks up system IDs as resources from a Java ClassLoader.
RestrictionEnzyme represents a restriction enzyme according to the REBASE standard.
RestrictionEnzymeManager manages collections of static RestrictionEnzyme instances.
RestrictionMapper is a class for annotating Sequences with Features which represent restriction sites.
RestrictionSite represents the recognition site of a restriction enzyme.
Template for construction of RestrictionSites.
A reverse complement view onto Sequence interface.
A translation table that can also translate from the target to source alphabet.
Annotatable objects that can have rich annotations.
An annotation collection which stores annotations as Note objects.
Represents a feature that can be given name and rank and be moved from one sequence to another.
Added-value extension of Feature.Template including bits we're interested in, eg. featureRelationshipSet for relationships with other features, and rankedCrossRefs for lookups into other databases.
Some useful tools for working with features.
Represents the relation between two features.
Holds feature relationships.
Describes locations, and adds the concepts of circularity, fuzziness, annotations, and cross-references to other databases.
This class represents a strand on which a location may lie.
Some useful tools for working with Locations.
This interface allows a class to generate Rich objects based on a class name and some parameters.
Runs a service that builds rich objects, and provides some default values for things like default ontology, default namespace, etc.
This class implements all methods of RichSeqIOListener and takes no action.
An interface for classes that listen to BioEntry or RichSequence I/O streams.
A rich sequence is a combination of a org.biojavax.bio.Bioentry and a Sequence.
A set of convenience methods for handling common file formats.
Used to iterate over a single rich sequence
Stores a number of useful terms used across many sequence formats for consistency's sake.
Some useful tools for working with RichSequence objects.
An interface for objects that can build RichSequences.
Simple factory for constructing new RichSequenceBuilder objects.
A database of RichSequences with accessible keys and iterators over all sequences.
A database of RichSequences.
Allows a file format to be read/written as RichSequences.
Provides a basic format with simple things like line-widths precoded.
Provides the basic implementation required for simple header/footer-less files such as Genbank.
An interface for classes that know how to handle subsequence operations.
Essentially the same as SequenceIterator.
Parses a stream into sequences.
Writes all of the sequences from a SequenceIterator to a stream with a particular format.
Useful functionality for processing DNA and RNA sequences.
RoundRectangularBeadRenderer renders features as rectangles with rounded corners.
RulerRenderer renders numerical scales in sequence coordinates.
Reader for FastqVariant.FASTQ_SANGER formatted sequences.
Writer for FastqVariant.FASTQ_SANGER formatted sequences.
Lightweight adaptor which translates SAX content events into StAX form, and provides delegation services.
Lightweight adaptor which translates SAX content events into StAX form, and provides delegation services.
A Chromatogram as loaded from an SCF v2 or v3 file.
This class computes the score that is used to be used in a DP optimisation.
In this class, calculateScore returns the probability of a Symbol being emitted by the null model.
In this class, calculateScore returns the odds ratio of a symbol being emitted.
In this class, calculateScore returns the probability of a Symbol being emitted.
A utility class to make searching a Sequence with many regex patterns easier.
Interface for a class that will recieve match information from this class.
The SearchBuilder interface is to be used by objects which accumulate state via a SearchContentHandler and then construct a SeqSimilaritySearchResult object.
An adapter for SearchContentHandler.
Filtering implementation of SearchContentHandler that by default passes all messages on to the next delegate in the chain.
SearchContentHandler is a notification interface for objects which listen to search stream parsers.
This class prints to a PrintStream calls to the SearchContentHandler interface in human readable form.
There has been some failure that prevents a search from completing.
The interface used to inform interested parties that some sequence has been searched and something found.
A SearchListener that prints events out to a PrintStream.
A simple listener that filters out all hits that are too short.
A SearchListener that passes events on to two delegate listeners.
A simple wrapper implementation.
A GlyphRenderer subclass that specificatlly handles Features pertaining to Secondary Structure (Helices, Turns and Strands).
This interface provides a collective name for IO classes that implement a seek function (e.g., RandomAccessFile).
Selects Organisms for Replication and returns the offspring.
 
Selects individuals who's fitness exceeds a threshold value.
A pattern that can be used to find regions with given sequence content.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Adapter class for SeqIOListener that has empty methods.
SeqIOConstants contains constants used to identify sequence formats, alphabets etc, in the context of reading and writing sequences.
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Base-class for listeners that pass filtered events onto another listener.
Notification interface for objects which listen to a sequence stream parser.
Deprecated.
use org.biojavax.bio.seq.RichSequence.IOTools
A SeqSimilarityAdapter converts SAX events into method calls on a SearchContentHandler implementation.
Objects of this type represent one particular installation (not just implementation) of a sequence similarity searcher such as BLASTP.
Objects of this type represent one particular hit (sequence and associated information) from a sequence similarity search.
ByScoreComparator compares SeqSimilaritySearchHits by their score.
BySubHitCountComparator compares SeqSimilaritySearchHits by their number of sub-hits.
Objects of this type represent one particular result of a sequence similarity search.
Objects of this type represent one particular sub-hit (one concrete sequence stretch within a sequence and associated information) from a sequence similarity search hit.
ByScoreComparator compares SeqSimilaritySearchSubHits by their score.
BySubjectStartComparator compares SeqSimilaritySearchSubHits by their start position on the subject sequence.
SeqSimilarityStAXAdapter is a handler for XML conforming to the BioJava BlastLike DTD.
SeqSimilarityStAXHandler is a base class for creating modular StAX handlers which send callbacks to a SeqSimilarityStAXAdapter.
A biological sequence.
A SAX2 parser for dealing with a sequence alignments.
An object which adds some additional information to a Sequence.
Interface for objects which accumulate state via SeqIOListener, then construct a Sequence object.
Basic SequenceBuilder implementation which accumulates all notified information.
Simple factory for constructing new SequenceBuilder objects.
Base-class for builders that pass filtered events onto another builder.
StAX handler for elements containing sequence
A database of sequences with accessible keys and iterators over all sequences.
Turn an entire SequenceDB instance into a DistDataSource.
A SequenceDBInstallation has the functionality of a factory for SequenceDB objects and additionally manages the SequenceDB objects created by itself such that the minimum number of SequenceDB objects is created by a particular SequenceDBInstallation object.
A database of sequences.
Interfaces for named resources that can provide sequences via a database given some configuration information as defined by the OBDA standard.
Deprecated.
SimpleSeqSimilaritySearchHit has been made Annotatable and is now functionally identical.
Deprecated.
SimpleSeqSimilaritySearchResult has been made Annotatable and is now functionally identical.
Deprecated.
SimpleSeqSimilaritySearchSubHit has been made Annotatable and is now functionally identical.
This SequenceBuilder has a variety of modes of operation.
An abstract implementation of SequenceDB that wraps up another database.
Deprecated.
use org.biojavax.bio.seq.io.RichSequenceBuilder or use org.biojavax.bio.seq.io.SequenceBuilder
Defines what a sequence format does.
mark interface
An iterator over a bag of sequences.
A panel that displays a Sequence.
Handles multiple SequencePanels and Ranges so that a Sequence can be wrapped over more than one line on screen.
Deprecated.
This doesn't handle loads of stuff.
A context within which sequence information may be rendered.
The metric object for the 'border' area - the area between the extent of the rendered area and the beginning or end of the sequence.
The interface for things that can render a line of information about a sequence.
 
An implementation of SequenceRenderer that delegates rendering to another renderer.
Turns a sequence database into a GFF event stream.
 
 
 
Methods for manipulating sequences.
An event indicating that a mouse gesture was recognised within a widget that renders sequences.
 
 
 
 
Utility methods for handling META-INF/services files
This kernel implements a three layer neural net.
SimilarityPairBuilder annotates query and subject Sequence with SimilarityPairFeatures created from SAX events supplied via a SeqSimilarityAdapter.
SimilarityPairFeature describes a pairwise similarity between two nucleotide sequences (as it extends StrandedFeature).
EmptyPairwiseAlignment empty pairwise alignment which has labels to empty symbol lists.
Template for construction of SimilarityPairFeatures.
Each HomologeneEntry represents a single Homologene record that relates two presumptive orthologues.
 
A simple implementation of an Alignment.
SimpleSimpleAlignment is a simple implementation of AlignmentElement.
Simple implementation for specifying markup styles.
A simple no-frills implementation of the FiniteAlphabet interface.
A no-frills implementation of Annotation that is just a wrapper around a LinkedHashMap.
A no-frills implementation of AnnotationDB.
Basic implementation of AGAVEAnnotFilter
A Sequence which is assembled from other sequences contained in a set of ComponentFeature objects.
Basic SequenceBuilder implementation which accumulates all notified information and creates a SimpleAssembly.
A basic implementation of AtomicSymbol.
Reference implementation of a BioEntry object which has no features or sequence.
Represents a relationship between two bioentries that is described by a term and given a rank.
A basic chromatogram implementation which provides public mutators for setting the various attributes of the chromatogram.
a simple no-frills implementation of the CodonPref object that encapsulates codon preference data.
An implementaion of Comment.
Represents an ontology that can be compared to other ontologies.
A Term object that can be compared and thus sorted.
Basic comparable triple, BioSQL style.
Simple Implementation of the CrossOverFunction interface
A basic CrossRef implementation.
A simple implementation of a distribution, which works with any finite alphabet.
Deprecated.
Distribution impls should be providing custom trainers.
A no-frills implementation of DistributionTrainerContext.
A basic DocRef implementation.
Represents an author of a documentary reference.
A Dot state that you can make and use.
 
A no-frills implementation of a feature.
A no-frills implementation of FeatureHolder.
FeatureRealizer which uses a lookup table to map template classes to implementations.
Title: SimpleFramedFeature.
Simple implementation of the GACross interface.
Simple implementation of GappedSequence.
This implementation of GappedSymbolList wraps a SymbolList, allowing you to insert gaps.
An aligned block.
A simple implementation of the GeneticAlgorithm interface it is not intended that this class be overidden, hence it is final.
A genetic code translation table representing a translation table in the DDBJ/EMBL/GenBank Feature Table (appendix V).
A no-frills implementation of a GFFRecord.
 
A simple no-frills implementation of the HomologeneBuilder interface.
 
A no-frills implementation of Homology.
 
This is a no-frills implementation of the Index interface.
Simple input handler that reads the input for an external process from an input stream.
A no-frills implementation of ItemValue.
 
A no-frills implementation of a translation table that maps between two alphabets.
 
 
 
Simple no frills Implementation of the MutationFunction interface
A basic Namespace implemenation.
Reference implementation of NCBITaxon.
Represents a name class plus name combination for an NCBITaxon object.
Loads NCBI taxon information from names.dmp and nodes.dmp, which are two of the files in the archive downloadable at ftp://ftp.ncbi.nih.gov/pub/taxonomy/ .
Simple implementation of Note.
A Simple Haploid Organism implementation
this entry contains data about the orthologue.
 
A no-frills implementation of the OrthoPair interface
 
a no-frills implementation of a Homologene Group
Simple output handler that pipes the output of an external process to an output stream.
Simple concrete implementation of the Population interface
A simple implementation of the Position interface.
Simple implementation of RankedCrossRef.
Represents a documentary reference.
A no-frills implementation of a remote feature.
 
SimpleRestrictionSite represents the recognition site of a restriction enzyme.
A no-frills implementation of TranslationTable that uses a Map to map from symbols in a finite source alphabet into a target alphabet.
Simple annotation wrapper.
A simple implementation of RichFeature.
Represents a relationship between two features that is described by a term.
A simple implementation of RichLocation.
Creates objects and returns them, and stores them in an internal map of singletons for reference.
A simple implementation of RichSequence.
Constructs BioEntry objects by listening to events.
Generates RichSequenceBuilder objects.
SimpleSeqSimilaritySearchHit objects represent a similarity search hit of a query sequence to a sequence referenced in a SequenceDB object.
SimpleSeqSimilaritySearchResult objects represent a result of a search of a SymbolList against the sequences within a SequenceDB object.
SimpleSeqSimilaritySearchSubHit objects represent sub-hits which make up a hit.
A basic implementation of the Sequence interface.
Basic SequenceBuilder implementation which accumulates all notified information and creates a SimpleSequence.
This class is an implementation of interface SequenceDBInstallation that manages a set of SequenceDB objects.
A no-frills implementation of SequenceFactory that produces SimpleSequence objects.
SimpleSimilarityPairFeature represents a similarity between a query sequence and a subject sequence as produced by a search program.
A no-frills implementation of StatePath.
A no-frills implementation of StrandedFeature.
A no-frills implementation of an SVM classifier model.
No-frills implementation of SVMTarget.
Basic implementation of SymbolList.
This class makes SimpleSymbolLists.
Class that implements the SymbolPropertyTable interface
A simple implementation of a symbol property table database.
A no-frills implementation of SymbolStyle.
Helper class to wrap one TagValueListener inside another one.
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Deprecated.
replaced by classes in org.biojavax.bio.taxa
SimpleThreadPool is a basic implementation of ThreadPool for use where we don't wish to introduce a dependency on a 3rd-party pool.
A TrackLayout implenentation that wraps the sequence smoothly after a set number of residues
A no-frills implementation of TranslationTable that uses a Map to map from symbols in a finite source alphabet into a target alphabet.
 
A simple XML DocumentHandler that processes SAX2 events to create a sensibly formatted XML as it parsed without populating objects with data.
An implementation of DP that aligns a single sequence against a single model.
The dynamic programming matrix for a single sequence.
An alphabet that contains a single atomic symbol.
 
Class that handles drawing in six frames for other classes.
A feature renderer that computes the data necessary to render multi-exon transcripts without CDS data.
Annotation that is optimized for memory usage.
Constant-memory implementation of single-head DP cursor.
Lightweight implementation of Map which uses little memory to store a small number of mappings, at the expense of scalability.
Lightweight implementation of Set which uses little memory to store a small number of items, at the expense of scalability.
Basic SequenceBuilder implementation which accumulates all notified information and chooses a sequence implementation suited to the size of the sequence.
Smith and Waterman developed an efficient dynamic programming algorithm to perform local sequence alignments, which returns the most conserved region of two sequences (longest common substring with modifications).
Train a regression support vector machine using the Sequential Minimal Optimization algorithm.
Train a support vector machine using the Sequential Minimal Optimization algorithm.
A in memory cache using soft references.
Soft masking is usually displayed by making the masked regions somehow different from the non masked regions.
Implementations will define how soft masking looks.
 
Cache which is cleared according to memory pressure.
Reader for FastqVariant.FASTQ_SOLEXA formatted sequences.
Writer for FastqVariant.FASTQ_SOLEXA formatted sequences.
An implementation of a sparse vector.
A version of the standard dot-product kernel that scales each column independently.
An implementatoin of UnigeneFactory that manages it's data in an SQL database.
Allows you to stack multiple feature renderers up (for example a label renderer and a beaded renderer) and have them treated as a single renderer for layout.
A logo painter that paints in stacked areas.
A state in a markov process.
This class implements a state machine for parsing events from the Parser class.
Interface implemented by State listeners that want notification when a transition leaves the State.
Interface for a State within this StateMachine
Class that produces StateMachineInstance objects.
 
Extends the Alignment interface so that it is explicitly used to represent a state path through an HMM, and the associated emitted sequence and likelihoods.
 
Interface for StAX content handlers.
Interface for StAX content handlers.
Simple implementation of the StAXContentHandler interface, with empty implementations for all the methods.
Simple implementation of the StAXContentHandler interface, with empty implementations for all the methods.
StAX handler shamelessly ripped off from Thomas Down's XFFFeatureSetHandler.
StAX handler shamelessly ripped off from Thomas Down's XFFFeatureSetHandler.
StAX handler shamelessly ripped off from Thomas Down's XFFFeatureSetHandler.
StAXHandlerBindings associates an ElementRecognizer with a factory which creates StAXContentHandlers for elements which it the ElementRecognizer accepts.
StAXHandlerFactory is an interface for factories producing StAXContentHandlers which are used by the SeqSimilarityStAXAdapter.
Factory for StAX content handlers.
Factory for StAX content handlers.
Factory for StAX content handlers.
StAX handler shamelessly ripped off from Thomas Down's XFFFeatureSetHandler.
StAX handler shamelessly ripped off from Thomas Down's XFFFeatureSetHandler.
A callback that is invoked during the training of an HMM.
Compute sites of stop codons.
Adds the concept of 'strand' to features.
Class to represent the 'strandedness' of a feature.
Template class for parameterizing the creation of a new StrandedFeature.
StAX handler for XFF strandedFeature type.
Process strings and return strand objects.
Event based parser callback.
Parse a stream of characters into BioJava symbols.
A multi threaded class which pipes the contents of an input stream to an output stream.
Parses a stream into sequences.
Writes all of the sequences from a SequenceIterator to a stream with a particular format.
StAX handler for any element which just contains a string.
Utility class for formatting strings into regular-sized blocks.
Simple access to protein seccondary structure assignments.
A renderer context that allows some or all properties of another context to be over-ridden.
 
SubPairwiseRenderContext is a rendering context which wraps a delegate context and effectively hides some of the delegate's properties with its own.
View a sub-section of a given sequence object, including all the features intersecting that region.
TargetContext that implements the mapping between the parent sequence and this sub-sequence.
 
Allows a new renderer to "wrap" another one, replacing one or more values.
This object is able to read a substitution matrix file and constructs a short matrix in memory.
Suffix tree implementation.
A node in the suffix tree.
Computes the dot-product of two suffix-trees as the sum of the products of the counts of all nodes they have in common.
Encapsulates the scale factor to apply at a given depth.
Scale using a multiple of two DepthScalers.
Scales by 4^depth - equivalent to dividing by a probablistic flatt prior null model
Scale using a BitSet to allow/disallow depths.
Scale all depths by 1.0
 
 
An SVM classifier model.
Kernel for support vector machines and related methods.
 
An SVM classifier model.
This class does a sort of mutation by exchanging two positions on the chromosome.
 
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Deprecated.
Use org.biojavax.bio.seq.io framework instead
Factory which wraps SequenceBuilders in a SwissprotProcessor
This class contains functions accessing sequences in swiss-prot.
A single symbol.
A sequence of symbols that belong to an alphabet.
SymbolListCharSequence is a CharSequence implementation which wraps a SymbolList.
This interface exists to hide implementational details of SymbolLists when making chunked symbol lists.
Tools class for constructing views of SymbolList objects.
class for maintaining properties associated with a symbol
Database of SymbolPropertyTable objects.
Iterator over SymbolPropertyTable objects.
Encapsulate a stream of Symbols being parsed from some input stream.
SymbolSequenceRenderer renders symbols of a SymbolList.
The interface for things that say how to paint a symbol.
Encapsulate a mapping between BioJava Symbol objects and some string representation.
 
 
A registry that loads up the standard biodirectory files.
Parse tab-delimited ontology files into Ontology objects.
Implements IndexStore as a serialized file for the java data and a tab-delimited file of offsets.
Pushes a new parser and listener, or delegate to a listener depending on the tag.
Silently drop all tags except those specified, and pass the rest onto a delegate.
TagMapper maps arbitrary object keys to new keys.
Rename tags using a TagMapper.
Utility class for representing tag-value pairs for TagValueParser implementors.
Communication interface between Parser and a TagValueListener that allows listeners to request that a parser/listener pair be pushed onto the stack to handle the current tag.
An object that wishes to be informed of events during the parsing of a file.
Tokenize single records (lines of text, objects) into a tag and a value.
Interface for TagValueListeners that wrap other TagValueListeners
Represents Nexus taxa blocks.
Builds Nexus taxa blocks.
Listens to events that represent Nexus taxa blocks.
Parses Nexus taxa blocks.
 
Deprecated.
replaced by classes in org.biojavax.bio.taxa
 
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Deprecated.
Use hibernate and org.biojavax.bio.db
Common things you may want to do with feature templates.
A term in an ontology.
Simple in-memory implementation of an ontology term.
A BlockPainter that renders letters in proportion to the size of the signal.
A logo painter that paints in stacked letters.
A simple implementation of RichSequence.
ThreadPool specifies basic thread-pooling operations such that third-party implementations may be used without requiring changes to BioJava.
 
Tournament Selection chooses the best organisms from n random subsets of a given population.
An interface for the handling of the layout of a WrappedSequencePanel.
 
Flags an object as being able to register itself with a model trainer.
This is a small and ugly class for storing a trainer and a transition.
 
 
 
 
 
This is a small and ugly class for storing a transition.
An object that can be used to train the transitions within a MarkovModel.
A translated view of some underlying distribution.
TranslatedSequencePanel is a panel that displays a Sequence.
A ProjectionContext that translates and optionaly flips features.
Encapsulates the mapping from a source to a destination alphabet.
Represents Nexus trees blocks.
A simple representation of a Newick tree as a single string.
Builds Nexus taxa blocks.
Listens to events that represent Nexus trees blocks.
Parses Nexus taxa blocks.
A triple in an ontology.
Basic in-memory implementation of a Triple in an ontology This can be used to implement Ontology.createTriple
Class that represents the tristate values possible in a logical operation: true, false and indeterminate.
A Glyph that paints a wide 'H' line within the bounds
A Glyph that paints a two headed arrow within the bounds
a sub-class of java.util.Properties that provides the same constructors, adds two convenient load methods to load the properties from files and, most importantly, adds getPropertyAsXXX() methods to get a property as an object of type XXX.
A suffix tree is an efficient method for encoding the frequencies of motifs in a sequence.
end Tree modification methods
This is a utility implementation of Changeable that doesn't fire any events or keep references to any listeners.
This class decompresses an input stream containing data compressed with the unix "compress" utility (LZC, a LZW variant).
UnequalLengthAlignment has the following behavior.
An implementation of an uniform distribution
A single unigene cluster.
A database of Unigene clusters.
Objects that can be used to produce a UnigeneDB instance given a URL.
Usefull tools for working with Unigene.
 
A class to describe events for alternative product comments.
A class to describe protein-protein interactions.
A class to describe isoforms for alternative product comments.
A class to describe seq caution entries.
Format reader for UniProt files.
Implements some UniProt-specific terms.
Parses UniProt location strings into RichLocation objects.
Format reader for UniProtXML files.
Implements some UniProtXML-specific terms.
Deprecated.
Use hibernate and org.biojavax.bio.db
Exception indicating that some provided data does not represent a supported chromatogram format.
A distribution which does not interact with the training framework.
URLFactory defines a means of obtaining a URL associated with an object.
Interface for a factory method to return a list of 0, 1 or more DatabaseURLGenerator instances.
An implementation of TrackLayout that that wraps a sequence over an arbitrary set of ranges
Just make the property follow the common case
Intercept the values associated with some tags and change them systematically.
 
 
SequenceDB implementation that returns new SequenceView instances wrapping the sequences in an underlying database.
A view onto another Sequence object.
ViewSequenceFactory is a base class for creating search handlers which create and cache views on the query and subject sequences.
Things that will be shown filters.
Objects that can walk over a filter expression, showing each element to a visitor.
 
A cache which retains weak references to objects
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Deprecated.
replaced by classes in org.biojavax.bio.taxa
Map implementation which keeps weak references to values.
Functions for access to a web based database that returns sequences in a variety of formats.
Inspred by the BioJava Distribution objects the WeightedSet is a map from a Key to a Weight.
A log odds weight matrix.
Annotates a sequence with hits to a weight-matrix.
Wraps a weight matrix up so that it appears to be a very simple HMM.
an object to return statistics about the frequency of the wobble base in a set of synonymous codons.
Base class for tokenizations which accept whitespace-separated `words'.
Simple output handler that writes the output of an external process to an writer.
StAX handler which converts and stream of parse events for an XFF featureSet element into BioJava SeqIO events.
 
Factory for StAX content handlers.
Common functionality for manipulating XFF.
Simple XFF writing code, ripped off from Dazzle 0.08.
StAX handler for parsing AnnotationTypes in FilterXML documents.
Handler for an individual CollectionConstraint in an AnnotationType.
Handler Factory for a CollectionConstraint in an AnnotationType.
Handler for an individual PropertyConstraint in an AnnotationType.
Handler Factory for a PropertyConstraint in an AnnotationType.
Main class for writing AnnotationTypes as XML.
Writer for types of CollectionConstraint.
Writer for types of PropertyConstraint.
Construct java beans from XML elements
A SAX parser that reads an XML representation of a Distribution from a file and recreates it as a Distribution Object.
Writes an OrderNDistribution or simple Distribution to an XML file.
Factory producing content handlers for parsing FilterXML elements.
StAXContentHandler for a particular type of FeatureFilter.
Factory of StAXContentHandlers for a particular type of FeatureFilter.
Write FeatureFilters in XML format.
Interface for an object which can write a FeatureFilter as XML.
 
Utility class for reading chunks of XML files and feeding them to SAX.
Object which knows how to represent itself as an XML element.
Simple interface for building XML documents.
A feature renderer that draws non-contiguous features as a set of boxes joined by zig-zags.
ZiggyImapRenderer is a decorator for ZiggyFeatureRenderer which adds the ability to create HTML image map coordinates which correspond to the feature rendering produced by the ZiggyFeatureRenderer.