## Uses of Interface
org.biojava.bio.Annotatable

Packages that use Annotatable
org.biojava.bio.dp: HMM and Dynamic Programming Algorithms.
org.biojava.bio.molbio: The classes and interfaces in this package cover common molecular biological techniques such as restriction digests and PCR.
org.biojava.bio.program.gff3: Support for reading and writing GFF3.
org.biojava.bio.program.hmmer: Tools for working with profile Hidden Markov Models from the HMMer package.
org.biojava.bio.program.phred: Parser for Phred output
org.biojava.bio.program.unigene: Objects for representing Unigene clusters.
org.biojava.bio.search: Interfaces and classes for representing sequence similarity search results.
org.biojava.bio.seq: Classes and interfaces for defining biological sequences and informatics objects.
org.biojava.bio.seq.homol: The classes and interfaces for defining sequence similarity and honology.
org.biojava.bio.seq.impl: Standard in-memory implementations of `Sequence` and `Feature`.
org.biojava.bio.seq.io: Classes and interfaces for processing and producing flat-file representations of sequences.
org.biojava.bio.seq.io.agave: Classes for converting between AGAVE XML and BioJava objects.
org.biojava.bio.seq.projection: Code for projecting Feature objects and systematically altering their properties.
org.biojava.bio.symbol: Representation of the Symbols that make up a sequence, and locations within them.
org.biojava.bio.taxa: Taxonomy object for representing species information.
org.biojava.ontology: A general-purpose API for ontologies.
org.biojavax: The Biojava extensions packages, classes that extend the core biojava functionality
org.biojavax.bio: Classes to represent biological entities and their relationships.
org.biojavax.bio.seq: Rich implementations of Sequences, Locations and Features.
org.biojavax.ontology: Extensions to the biojava ontology model that represent BioSQL ontology.

Uses of Annotatable in org.biojava.bio.dp

Subinterfaces of Annotatable in org.biojava.bio.dp
`interface` `DotState` A Dot state.
`interface` `EmissionState` A state in a markov process that has an emission spectrum.
`interface` `ModelInState` A state that contains an entire sub-model.
`interface` `State` A state in a markov process.

Classes in org.biojava.bio.dp that implement Annotatable
`class` `MagicalState` Start/end state for HMMs.
`class` `SimpleDotState` A Dot state that you can make and use.
`class` `SimpleEmissionState`
`class` `SimpleModelInState`

Uses of Annotatable in org.biojava.bio.molbio

Subinterfaces of Annotatable in org.biojava.bio.molbio
`interface` `RestrictionSite` `RestrictionSite` represents the recognition site of a restriction enzyme.

Uses of Annotatable in org.biojava.bio.program.gff3

Subinterfaces of Annotatable in org.biojava.bio.program.gff3
`interface` `GFF3Record` A record in a GFF3 formatted file.

Classes in org.biojava.bio.program.gff3 that implement Annotatable
`static class` `GFF3Record.Impl`

Uses of Annotatable in org.biojava.bio.program.hmmer

Classes in org.biojava.bio.program.hmmer that implement Annotatable
`class` `ProfileEmissionState` A state in a HMMer model.

Uses of Annotatable in org.biojava.bio.program.phred

Classes in org.biojava.bio.program.phred that implement Annotatable
`class` `PhredSequence` PhredSequence is an extension of SimpleSequence that implements Qualitative to hold Phred quality scores.

Uses of Annotatable in org.biojava.bio.program.unigene

Subinterfaces of Annotatable in org.biojava.bio.program.unigene
`interface` `UnigeneCluster` A single unigene cluster.

Uses of Annotatable in org.biojava.bio.search

Subinterfaces of Annotatable in org.biojava.bio.search
`interface` `SeqSimilaritySearchHit` Objects of this type represent one particular hit (sequence and associated information) from a sequence similarity search.
`interface` `SeqSimilaritySearchResult` Objects of this type represent one particular result of a sequence similarity search.
`interface` `SeqSimilaritySearchSubHit` 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.

Classes in org.biojava.bio.search that implement Annotatable
`class` `SequenceDBSearchHit` Deprecated. SimpleSeqSimilaritySearchHit has been made Annotatable and is now functionally identical.
`class` `SequenceDBSearchResult` Deprecated. SimpleSeqSimilaritySearchResult has been made Annotatable and is now functionally identical.
`class` `SequenceDBSearchSubHit` Deprecated. SimpleSeqSimilaritySearchSubHit has been made Annotatable and is now functionally identical.
`class` `SimpleSeqSimilaritySearchHit` `SimpleSeqSimilaritySearchHit` objects represent a similarity search hit of a query sequence to a sequence referenced in a SequenceDB object.
`class` `SimpleSeqSimilaritySearchResult` `SimpleSeqSimilaritySearchResult` objects represent a result of a search of a `SymbolList` against the sequences within a `SequenceDB` object.
`class` `SimpleSeqSimilaritySearchSubHit` `SimpleSeqSimilaritySearchSubHit` objects represent sub-hits which make up a hit.

Uses of Annotatable in org.biojava.bio.seq

Subinterfaces of Annotatable in org.biojava.bio.seq
`interface` `ComponentFeature` Feature which represents a component in an assembly (contig).
`interface` `Feature` A feature within a sequence, or nested within another feature.
`static interface` `FeatureTypes.Repository` A named collection of Types.
`static interface` `FeatureTypes.Type` A type of feature.
`interface` `FramedFeature` Title: FramedFeature.
`interface` `GappedSequence` Extension of GappedSymbolList which also projects features into the gapped coordinate system.
`interface` `RemoteFeature` A feature that indicates that there is some remote feature that can't be represented entirely on a single Sequence.
`interface` `Sequence` A biological sequence.
`interface` `StrandedFeature` Adds the concept of 'strand' to features.

Classes in org.biojava.bio.seq that implement Annotatable
`class` `CircularView` A circular view onto another Sequence object.
`static class` `FeatureTypes.RepositoryImpl` A simple implementation of a Repository.
`class` `NewSimpleAssembly` A Sequence which is assembled from other sequences contained in a set of ComponentFeature objects.
`class` `SimpleAssembly` A Sequence which is assembled from other sequences contained in a set of ComponentFeature objects.

Uses of Annotatable in org.biojava.bio.seq.homol

Subinterfaces of Annotatable in org.biojava.bio.seq.homol
`interface` `HomologyFeature`
`interface` `SimilarityPairFeature` `SimilarityPairFeature` describes a pairwise similarity between two nucleotide sequences (as it extends `StrandedFeature`).

Uses of Annotatable in org.biojava.bio.seq.impl

Classes in org.biojava.bio.seq.impl that implement Annotatable
`class` `DummySequence` A Sequence implementation that has a name and URI but no features, and a zero length symbol list.
`class` `RevCompSequence` A reverse complement view onto `Sequence` interface.
`class` `SimpleFeature` A no-frills implementation of a feature.
`class` `SimpleFramedFeature` Title: SimpleFramedFeature.
`class` `SimpleGappedSequence` Simple implementation of GappedSequence.
`class` `SimpleHomologyFeature`
`class` `SimpleRemoteFeature` A no-frills implementation of a remote feature.
`class` `SimpleRestrictionSite` `SimpleRestrictionSite` represents the recognition site of a restriction enzyme.
`class` `SimpleSequence` A basic implementation of the `Sequence` interface.
`class` `SimpleSimilarityPairFeature` `SimpleSimilarityPairFeature` represents a similarity between a query sequence and a subject sequence as produced by a search program.
`class` `SimpleStrandedFeature` A no-frills implementation of StrandedFeature.
`class` `SubSequence` View a sub-section of a given sequence object, including all the features intersecting that region.
`class` `ViewSequence` A view onto another Sequence object.

Uses of Annotatable in org.biojava.bio.seq.io

Subinterfaces of Annotatable in org.biojava.bio.seq.io
`interface` `SymbolTokenization` Encapsulate a mapping between BioJava Symbol objects and some string representation.

Classes in org.biojava.bio.seq.io that implement Annotatable
`class` `AlternateTokenization` Implementation of SymbolTokenization which binds symbols to strings of characters.
`class` `CharacterTokenization` Implementation of SymbolTokenization which binds symbols to single unicode characters.
`class` `CrossProductTokenization` Tokenization for cross-product alphabets.
`class` `DoubleTokenization`
`class` `IntegerTokenization`
`class` `NameTokenization` Simple implementation of SymbolTokenization which uses the `name' field of the symbols.
`class` `SubIntegerTokenization`
`class` `WordTokenization` Base class for tokenizations which accept whitespace-separated `words'.

Uses of Annotatable in org.biojava.bio.seq.io.agave

Methods in org.biojava.bio.seq.io.agave with parameters of type Annotatable
`protected void` `AgaveWriter.writeAssembly(Annotatable seq)`
`protected void` `AgaveWriter.writeBioSequence(Annotatable seq)`
`protected void` `AgaveWriter.writeClassification(Annotatable seq)`
`protected void` `AgaveWriter.writeCompResult(Annotatable f)`
`protected void` `AgaveWriter.writeContig(Annotatable seq)`
`protected void` `AgaveWriter.writeGene(Annotatable f)`
`protected void` `AgaveWriter.writeSeqFeature(Annotatable f)` Write SeqFeature XML
`protected void` `AgaveWriter.writeSequenceMap(Annotatable seq)` group sequence_map by getSource()
`protected void` `AgaveWriter.writeSequenceMap2(Annotatable f)` Write SequenceMap XML
`protected void` `AgaveWriter.writeTranscript(Annotatable f)`

Uses of Annotatable in org.biojava.bio.seq.projection

Classes in org.biojava.bio.seq.projection that implement Annotatable
`class` `ProjectedFeature` Internal class used by ProjectionEngine to wrap Feature objects.

Uses of Annotatable in org.biojava.bio.symbol

Subinterfaces of Annotatable in org.biojava.bio.symbol
`interface` `Alphabet` The set of AtomicSymbols which can be concatenated together to make a SymbolList.
`interface` `AtomicSymbol` A symbol that is not ambiguous.
`interface` `BasisSymbol` A symbol that can be represented as a string of Symbols.
`interface` `FiniteAlphabet` An alphabet over a finite set of Symbols.
`interface` `Symbol` A single symbol.

Classes in org.biojava.bio.symbol that implement Annotatable
`class` `AbstractAlphabet` An abstract implementation of `Alphabet`.
`class` `AbstractSymbol` The base-class for Symbol implementations.
`class` `DoubleAlphabet` An efficient implementation of an Alphabet over the infinite set of double values.
`static class` `DoubleAlphabet.DoubleRange` A range of double values.
`static class` `DoubleAlphabet.DoubleSymbol` A single double value.
`static class` `DoubleAlphabet.SubDoubleAlphabet` A class to represent a contiguous range of double symbols.
`class` `FundamentalAtomicSymbol` An atomic symbol consisting only of itself.
`class` `IntegerAlphabet` An efficient implementation of an Alphabet over the infinite set of integer values.
`static class` `IntegerAlphabet.IntegerSymbol` A single int value.
`static class` `IntegerAlphabet.SubIntegerAlphabet` A class to represent a finite contiguous subset of the infinite IntegerAlphabet
`class` `SimpleAlphabet` A simple no-frills implementation of the FiniteAlphabet interface.
`class` `SimpleAtomicSymbol` A basic implementation of AtomicSymbol.
`class` `SingletonAlphabet` An alphabet that contains a single atomic symbol.
`class` `SoftMaskedAlphabet` Soft masking is usually displayed by making the masked regions somehow different from the non masked regions.
`class` `SoftMaskedAlphabet.CaseSensitiveTokenization` This `SymbolTokenizer` works with a delegate to softmask symbol tokenization as appropriate.

Uses of Annotatable in org.biojava.bio.taxa

Subinterfaces of Annotatable in org.biojava.bio.taxa
`interface` `Taxon` Deprecated. replaced by classes in `org.biojavax.bio.taxa`

Classes in org.biojava.bio.taxa that implement Annotatable
`class` `AbstractTaxon` Deprecated. replaced by classes in `org.biojavax.bio.taxa`
`class` `SimpleTaxon` Deprecated. replaced by classes in `org.biojavax.bio.taxa`
`class` `WeakTaxon` Deprecated. replaced by classes in `org.biojavax.bio.taxa`

Uses of Annotatable in org.biojava.ontology

Subinterfaces of Annotatable in org.biojava.ontology
`interface` `OntologyTerm` A term in an ontology which identifies another ontology.
`interface` `RemoteTerm` A term in another ontology.
`interface` `Term` A term in an ontology.
`interface` `Triple` A triple in an ontology.
`interface` `Variable`

Classes in org.biojava.ontology that implement Annotatable
`class` `AbstractTerm` Abstract implementation of term This provides basic change-forwarding functionality from the annotation and ontology properties.
`class` `IntegerOntology.IntTerm`
`static class` `OntologyTerm.Impl` Simple in-memory implementation of a remote ontology term.
`static class` `RemoteTerm.Impl` Simple in-memory implementation of a remote ontology term.
`static class` `Term.Impl` Simple in-memory implementation of an ontology term.
`static class` `Triple.Impl` Basic in-memory implementation of a Triple in an ontology This can be used to implement Ontology.createTriple
`static class` `Variable.Impl`

Uses of Annotatable in org.biojavax

Subinterfaces of Annotatable in org.biojavax
`interface` `CrossRef` Represents a cross reference to another database.
`interface` `RichAnnotatable` Annotatable objects that can have rich annotations.

Classes in org.biojavax that implement Annotatable
`class` `SimpleCrossRef` A basic CrossRef implementation.

Uses of Annotatable in org.biojavax.bio

Subinterfaces of Annotatable in org.biojavax.bio
`interface` `BioEntry` This class relates to the bioentry table in BioSQL.

Classes in org.biojavax.bio that implement Annotatable
`class` `SimpleBioEntry` Reference implementation of a BioEntry object which has no features or sequence.

Uses of Annotatable in org.biojavax.bio.seq

Subinterfaces of Annotatable in org.biojavax.bio.seq
`interface` `RichFeature` Represents a feature that can be given name and rank and be moved from one sequence to another.
`interface` `RichLocation` Describes locations, and adds the concepts of circularity, fuzziness, annotations, and cross-references to other databases.
`interface` `RichSequence` A rich sequence is a combination of a org.biojavax.bio.Bioentry and a Sequence.

Classes in org.biojavax.bio.seq that implement Annotatable
`class` `CompoundRichLocation` An implementation of RichLocation which covers multiple locations, but on the same strand of the same (optionally circular) sequence.
`class` `EmptyRichLocation` An Empty implementation of RichLocation.
`class` `MultiSourceCompoundRichLocation` An implementation of RichLocation which possibly covers multiple locations, on different strands, different circular lengths, or different sequences.
`class` `SimpleRichFeature` A simple implementation of RichFeature.
`class` `SimpleRichLocation` A simple implementation of RichLocation.
`class` `SimpleRichSequence` A simple implementation of RichSequence.
`class` `ThinRichSequence` A simple implementation of RichSequence.

Uses of Annotatable in org.biojavax.ontology

Subinterfaces of Annotatable in org.biojavax.ontology
`interface` `ComparableTerm` Makes Term objects comparable properly and adds some extra features to them.
`interface` `ComparableTriple` Comparable triples, obviously.

Classes in org.biojavax.ontology that implement Annotatable
`class` `SimpleComparableTerm` A Term object that can be compared and thus sorted.
`class` `SimpleComparableTriple` Basic comparable triple, BioSQL style.