## 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.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 into alternate coordinate systems.
org.biojava.bio.seq.ragbag: The Ragbag package is a set of classes for setting up a virtual sequence contig without the need for writing Biojava code.
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.

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.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.
`class` `DummySequence`
`static class` `FeatureTypes.RepositoryImpl` A simple implementation of a Repository.
`class` `SimpleAssembly` A Sequence which is assembled from other sequences contained in a set of ComponentFeature objects.
`class` `SimpleGappedSequence` Simple implementation of GappedSequence.
`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.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` `RevCompSequence` A reverse complement view onto `Sequence` interface.
`class` `SimpleFeature` A no-frills implementation of a feature.
`class` `SimpleFramedFeature` Title: SimpleFramedFeature.
`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.

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` `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` `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.writeContig(Annotatable seq)`
`protected void` `AgaveWriter.writeAssembly(Annotatable seq)`
`protected void` `AgaveWriter.writeBioSequence(Annotatable seq)`
`protected void` `AgaveWriter.writeSequenceMap(Annotatable seq)` group sequence_map by getSource()
`protected void` `AgaveWriter.writeClassification(Annotatable seq)`
`protected void` `AgaveWriter.writeSequenceMap2(Annotatable f)` Write SequenceMap XML
`protected void` `AgaveWriter.writeGene(Annotatable f)`
`protected void` `AgaveWriter.writeTranscript(Annotatable f)`
`protected void` `AgaveWriter.writeSeqFeature(Annotatable f)` Write SeqFeature XML
`protected void` `AgaveWriter.writeCompResult(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.
`class` `ProjectedStrandedFeature` Internal class used by ProjectedFeatureHolder to wrap StrandedFeatures.

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

Classes in org.biojava.bio.seq.ragbag that implement Annotatable
`(package private) class` `org.biojava.bio.seq.ragbag.RagbagAbstractSequence` object that instantiates a sequence in Ragbag.
`class` `RagbagAssembly` object that instantiates a sequence when given a Ragbag directory.

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.
`(package private) class` `org.biojava.bio.symbol.SimpleBasisSymbol` A basic implementation of BasisSymbol.
`(package private) class` `org.biojava.bio.symbol.SimpleSymbol` A basic implementation of Symbol.
`class` `SingletonAlphabet` An alphabet that contains a single atomic symbol.

Uses of Annotatable in org.biojava.bio.taxa

Subinterfaces of Annotatable in org.biojava.bio.taxa
`interface` `Taxon` A taxon within a classification.

Classes in org.biojava.bio.taxa that implement Annotatable
`class` `AbstractTaxon` An abstract implementation of Taxon.
`class` `SimpleTaxon` A no-frills implementatation of Taxon.
`class` `WeakTaxon` An implementation of Taxon that keeps only weak references to children, but full references to parents.