## Uses of Interface
org.biojava.utils.Changeable

Packages that use Changeable
org.biojava.bio: The core classes that will be used throughout the bio packages.
org.biojava.bio.alignment: Classes to generate and describe sequence alignments.
org.biojava.bio.dist: Probability distributions over Alphabets.
org.biojava.bio.dp: HMM and Dynamic Programming Algorithms.
org.biojava.bio.gui.sequence: Graphical displays of biological sequences and associated annotations.
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.das: Development client for the Distributed Annotation System.
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.homologene: Support classes for Homologene data.
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.db: Collections of biological sequence data.
org.biojava.bio.seq.db.biofetch: Client for the OBDA BioFetch protocol.
org.biojava.bio.seq.db.biosql: General purpose Sequence storage in a relational database.
org.biojava.bio.seq.db.flat: Support for OBDA flatfile databases.
org.biojava.bio.seq.distributed: Sequences and SequenceDBs which are composed from data taken from a number of data sources.
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.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.biojava.utils: Miscellaneous utility classes used by other BioJava components.
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.db: Interactions between biojavax objects and a DB.
org.biojavax.bio.db.biosql: Interface between biojava and biosql databases
org.biojavax.bio.db.ncbi: Interfaces to NCBI data.
org.biojavax.bio.seq: Rich implementations of Sequences, Locations and Features.
org.biojavax.bio.taxa: Objects that model the NCBI taxonomy schema as described in the BioSQL schema.
org.biojavax.ga: Classes to provide a genetic algorithm framework
org.biojavax.ga.functions: GA functions
org.biojavax.ga.impl: Default implementations and abstract classes.
org.biojavax.ontology: Extensions to the biojava ontology model that represent BioSQL ontology.

Uses of Changeable in org.biojava.bio

Subinterfaces of Changeable in org.biojava.bio
`interface` `Annotatable` Indicates that an object has an associated annotation.
`interface` `Annotation` Arbitrary annotation associated with one or more objects.

Classes in org.biojava.bio that implement Changeable
`class` `AbstractAnnotation` A utility class to ease the problem of implementing an Annotation to that of providing an apropreate implementation of Map.
`class` `AnnotationChanger` `AnnotationChanger` remaps the values of an `Annotation` to new values specified by a `ValueChanger`.
`class` `AnnotationRenamer` `AnnotationRenamer` remaps the keys of an `Annotation` to new keys specified by a `TagMapper`.
`class` `BeanAsAnnotation` Create an Annotation with properties matching those of a JavaBean instance.
`class` `MergeAnnotation` Merged view onto a list of underlying Annotation objects.
`class` `OverlayAnnotation` Annotation implementation which allows new key-value pairs to be layered on top of an underlying Annotation.
`class` `SimpleAnnotation` A no-frills implementation of Annotation that is just a wrapper around a `LinkedHashMap`.
`class` `SmallAnnotation` Annotation that is optimized for memory usage.

Uses of Changeable in org.biojava.bio.alignment

Subinterfaces of Changeable in org.biojava.bio.alignment
`interface` `ARAlignment` ARAlignment is an interface that defines methods for adding and removing seqeunces from an Alignment.
`interface` `UnequalLengthAlignment` UnequalLengthAlignment has the following behavior.

Classes in org.biojava.bio.alignment that implement Changeable
`class` `AbstractULAlignment`
`class` `AbstractULAlignment.SubULAlignment`
`class` `FlexibleAlignment` 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.

Uses of Changeable in org.biojava.bio.dist

Subinterfaces of Changeable in org.biojava.bio.dist
`interface` `Count` An encapsulation of a count over the Symbols within an alphabet.
`interface` `Distribution` An encapsulation of a probability distribution over the Symbols within an alphabet.
`interface` `OrderNDistribution` Provides an N'th order distribution.

Classes in org.biojava.bio.dist that implement Changeable
`class` `AbstractDistribution` An abstract implementation of Distribution.
`class` `AbstractOrderNDistribution` Simple base class for OrderNDistributions.
`class` `GapDistribution` This distribution emits gap symbols.
`class` `IndexedCount` An encapsulation of a count over the Symbols within a FiniteAlphabet using an AlphabetIndex object.
`class` `PairDistribution` Class for pairing up two independant distributions.
`class` `SimpleDistribution` A simple implementation of a distribution, which works with any finite alphabet.
`class` `TranslatedDistribution` A translated view of some underlying distribution.
`class` `UniformDistribution` An implementation of an uniform distribution
`class` `UntrainableDistribution` A distribution which does not interact with the training framework.

Uses of Changeable in org.biojava.bio.dp

Subinterfaces of Changeable in org.biojava.bio.dp
`interface` `DotState` A Dot state.
`interface` `EmissionState` A state in a markov process that has an emission spectrum.
`interface` `MarkovModel` A markov model.
`interface` `ModelInState` A state that contains an entire sub-model.
`interface` `State` A state in a markov process.
`interface` `StatePath` 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.

Classes in org.biojava.bio.dp that implement Changeable
`class` `MagicalState` Start/end state for HMMs.
`class` `ProfileHMM`
`class` `SimpleDotState` A Dot state that you can make and use.
`class` `SimpleEmissionState`
`class` `SimpleMarkovModel`
`class` `SimpleModelInState`
`class` `SimpleStatePath` A no-frills implementation of StatePath.
`class` `WMAsMM` Wraps a weight matrix up so that it appears to be a very simple HMM.

Uses of Changeable in org.biojava.bio.gui.sequence

Classes in org.biojava.bio.gui.sequence that implement Changeable
`class` `AbiTraceRenderer` Renders an ABI trace file as a chromatogram graph.
`class` `AbstractBeadRenderer` `AbstractBeadRenderer` is a an abstract base class for the creation of `FeatureRenderer`s which use a 'string of beads' metaphor for displaying features.
`class` `AbstractPeptideDigestRenderer` A SequenceRenderer that renders a set of Features that match a FeatureFilter in such a way that they do not overlap in the display.
`class` `AlignmentRenderer`
`class` `BasicFeatureRenderer`
`class` `BumpedRenderer`
`class` `CrosshairRenderer` `CrosshairRenderer` draws a crosshair, optionally with coordinates.
`class` `EllipticalBeadRenderer` `EllipticalBeadRenderer` renders features as simple ellipses.
`class` `FeatureBlockSequenceRenderer` `FeatureBlockSequenceRenderer` forms a bridge between `Sequence` rendering and `Feature` rendering.
`class` `FeatureLabelRenderer`
`class` `FilteringRenderer`
`class` `GappedRenderer` A renderer that will display a gapped sequence as a discontinuous series of regions.
`class` `GlyphFeatureRenderer` A FeatureRenderer that renders a particular Glyph for Features accepted by a particular FeatureFilter
`class` `LabelledSequenceRenderer` Renderer which draws a track of sequence with a textual label.
`class` `MultiLineRenderer` `MultiLineRenderer` is a `SequenceRenderer` which collects a number of other `SequenceRenderer`s each of which render their own view of a `Sequence`.
`class` `OffsetRulerRenderer` OffsetRulerRenderer can render the ruler starting from an arbitrary offset from the sequence.
`class` `OverlayRendererWrapper` 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.
`class` `PaddingRenderer` A renderer that adds padding before and after a delegate renderer.
`class` `PairwiseDiagonalRenderer` `PairwiseDiagonalRenderer` renders a region of similarity between two sequences as a straight line.
`class` `PairwiseFilteringRenderer` `PairwiseFilteringRenderer` wraps a `PairwiseSequenceRenderer` and filters the `PairwiseRenderContext`s passed to it.
`class` `PairwiseOverlayRenderer` `PairwiseOverlayRenderer` allows a list of other `PairwiseSequenceRenderer`s to superimpose their output.
`class` `PairwiseSequencePanel` 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).
`class` `PeptideDigestRenderer` A concrete AbstractPeptideDigestRenderer.
`class` `RectangularBeadRenderer` `RectangularBeadRenderer` renders features as simple rectangles.
`class` `RoundRectangularBeadRenderer` `RoundRectangularBeadRenderer` renders features as rectangles with rounded corners.
`class` `SecondaryStructureFeatureRenderer` A GlyphRenderer subclass that specificatlly handles Features pertaining to Secondary Structure (Helices, Turns and Strands).
`class` `SequencePanel` A panel that displays a Sequence.
`class` `SequencePoster` Deprecated. This doesn't handle loads of stuff. Use SequencePoster.
`class` `SequenceRendererWrapper` An implementation of SequenceRenderer that delegates rendering to another renderer.
`class` `SimpleLabelRenderer`
`class` `SixFrameRenderer` Class that handles drawing in six frames for other classes.
`class` `SixFrameZiggyRenderer` A feature renderer that computes the data necessary to render multi-exon transcripts without CDS data.
`class` `StackedFeatureRenderer` 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.
`class` `TickFeatureRenderer`
`class` `TranslatedSequencePanel` `TranslatedSequencePanel` is a panel that displays a Sequence.
`class` `ZiggyFeatureRenderer` A feature renderer that draws non-contiguous features as a set of boxes joined by zig-zags.

Uses of Changeable in org.biojava.bio.molbio

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

Uses of Changeable in org.biojava.bio.program.das

Classes in org.biojava.bio.program.das that implement Changeable
`class` `DAS` A collection of DAS datasources.
`class` `DASSequence` Sequence reflecting a DAS reference sequence, possibly decorated with one of more annotation sets.
`class` `DASSequenceDB` Collection of sequences retrieved from the DAS network.
`class` `ReferenceServer` Reflects a reference server on the DAS network.

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

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

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

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

Classes in org.biojava.bio.program.hmmer that implement Changeable
`class` `FullHmmerProfileHMM` This is a class for representing the full HMMER generated Profile HMM (including loop states N and C terminal looping states).
`class` `HmmerProfileHMM` This is a class for representing HMMER generated Profile HMM.
`class` `ProfileEmissionState` A state in a HMMer model.

Uses of Changeable in org.biojava.bio.program.homologene

Classes in org.biojava.bio.program.homologene that implement Changeable
`class` `AbstractOrthologueSet`
`class` `AbstractOrthoPairSet` represents the Homologene Group.
`class` `SimpleOrthologueSet`
`class` `SimpleOrthoPairSet` a no-frills implementation of a Homologene Group

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

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

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

Subinterfaces of Changeable in org.biojava.bio.program.unigene
`interface` `UnigeneCluster` A single unigene cluster.
`interface` `UnigeneDB` A database of Unigene clusters.

Uses of Changeable in org.biojava.bio.search

Subinterfaces of Changeable 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 Changeable
`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 Changeable in org.biojava.bio.seq

Subinterfaces of Changeable 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.
`interface` `FeatureHolder` The interface for objects that contain features.
`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` `RealizingFeatureHolder` Interface for `FeatureHolder` objects which know how to instantiate new child Features.
`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 Changeable
`class` `AbstractFeatureHolder` An abstract implementation of FeatureHolder.
`class` `CircularView` A circular view onto another Sequence object.
`static class` `FeatureHolder.EmptyFeatureHolder`
`static class` `FeatureTypes.RepositoryImpl` A simple implementation of a Repository.
`class` `LazyFeatureHolder` Wrapper implementation of FeatureHolder which calls a method to create a contained FeatureHolder on demand.
`class` `MergeFeatureHolder` FeatureHolder which exposes all the features in a set of sub-FeatureHolders.
`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.
`class` `SimpleFeatureHolder` A no-frills implementation of FeatureHolder.

Uses of Changeable in org.biojava.bio.seq.db

Subinterfaces of Changeable in org.biojava.bio.seq.db
`interface` `SequenceDB` A database of sequences with accessible keys and iterators over all sequences.
`interface` `SequenceDBLite` A database of sequences.

Classes in org.biojava.bio.seq.db that implement Changeable
`class` `AbstractSequenceDB` An abstract implementation of SequenceDB that provides the sequenceIterator method.
`class` `AnnotatedSequenceDB` SequenceDB implementation which lazily applies a SequenceAnnotator to sequences retrieved from a SequenceDB.
`class` `CachingSequenceDB` SequenceDB implementation that caches the results of another SequenceDB.
`class` `DummySequenceDB` `DummySequenceDB` is an implementation which contains only a `DummySequence`.
`class` `HashSequenceDB` An implementation of SequenceDB that uses an underlying HashMap to store the sequence objects.
`class` `IndexedSequenceDB` This class implements SequenceDB on top of a set of sequence files and sequence offsets within these files.
`class` `NCBISequenceDB`
`class` `SequenceDBWrapper` An abstract implementation of SequenceDB that wraps up another database.
`class` `SubSequenceDB`
`class` `ViewingSequenceDB` SequenceDB implementation that returns new SequenceView instances wrapping the sequences in an underlying database.
`class` `WebSequenceDB` Functions for access to a web based database that returns sequences in a variety of formats.

Uses of Changeable in org.biojava.bio.seq.db.biofetch

Classes in org.biojava.bio.seq.db.biofetch that implement Changeable
`class` `BioFetchSequenceDB` Simple SequenceDB implementation backed by a BioFetch (HTTP) server.

Uses of Changeable in org.biojava.bio.seq.db.biosql

Classes in org.biojava.bio.seq.db.biosql that implement Changeable
`class` `BioSQLSequenceDB` Deprecated. Use hibernate and org.biojavax.bio.db.*

Uses of Changeable in org.biojava.bio.seq.db.flat

Classes in org.biojava.bio.seq.db.flat that implement Changeable
`class` `FlatSequenceDB` `FlatSequenceDB` is an OBDA flatfile sequence databank implementation.

Uses of Changeable in org.biojava.bio.seq.distributed

Classes in org.biojava.bio.seq.distributed that implement Changeable
`class` `DistributedSequenceDB` Sequence database from the meta-DAS system.

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

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

Classes in org.biojava.bio.seq.homol that implement Changeable
`static class` `SimilarityPairFeature.EmptyPairwiseAlignment` `EmptyPairwiseAlignment` empty pairwise alignment which has labels to empty symbol lists.
`class` `SimpleHomology` A no-frills implementation of Homology.

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

Classes in org.biojava.bio.seq.impl that implement Changeable
`class` `AssembledSymbolList` Support class for applications which need to patch together sections of sequence into a single SymbolList.
`class` `DummySequence` A Sequence implementation that has a name and URI but no features, and a zero length symbol list.
`class` `LazyFilterFeatureHolder` FeatureHolder which lazily applies a specified filter to another FeatureHolder.
`class` `NewAssembledSymbolList` Support class for applications which need to patch together sections of sequence into a single SymbolList.
`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 Changeable in org.biojava.bio.seq.io

Subinterfaces of Changeable 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 Changeable
`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` `ReferenceAnnotation` Deprecated. Use org.biojavax.bio.seq.io framework instead
`class` `SubIntegerTokenization`
`class` `WordTokenization` Base class for tokenizations which accept whitespace-separated `words'.

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

Classes in org.biojava.bio.seq.projection that implement Changeable
`class` `ProjectedFeature` Internal class used by ProjectionEngine to wrap Feature objects.
`class` `ProjectedFeatureHolder` Helper class for projecting Feature objects into an alternative coordinate system.

Uses of Changeable in org.biojava.bio.symbol

Subinterfaces of Changeable in org.biojava.bio.symbol
`interface` `Alignment` An alignment containing multiple SymbolLists.
`interface` `Alphabet` The set of AtomicSymbols which can be concatenated together to make a SymbolList.
`interface` `AlphabetIndex` Map between Symbols and index numbers.
`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` `GappedSymbolList` This extends SymbolList with API for manipulating, inserting and deleting gaps.
`interface` `Symbol` A single symbol.
`interface` `SymbolList` A sequence of symbols that belong to an alphabet.

Classes in org.biojava.bio.symbol that implement Changeable
`class` `AbstractAlphabet` An abstract implementation of `Alphabet`.
`class` `AbstractSymbol` The base-class for Symbol implementations.
`class` `AbstractSymbolList` Abstract helper implementation of the SymbolList core interface.
`class` `ChunkedSymbolList` SymbolList implementation using constant-size chunks.
`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` `DummySymbolList` Symbol list which just consists of non-informative 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` `PackedSymbolList` A SymbolList that stores symbols as bit-patterns in an array of longs.
`class` `RelabeledAlignment` An alignment that relabels another alignment.
`class` `SimpleAlignment` A simple implementation of an Alignment.
`class` `SimpleAlphabet` A simple no-frills implementation of the FiniteAlphabet interface.
`class` `SimpleAtomicSymbol` A basic implementation of AtomicSymbol.
`class` `SimpleCodonPref` a simple no-frills implementation of the CodonPref object that encapsulates codon preference data.
`class` `SimpleGappedSymbolList` This implementation of GappedSymbolList wraps a SymbolList, allowing you to insert gaps.
`class` `SimpleSymbolList` Basic implementation of SymbolList.
`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 Changeable in org.biojava.bio.taxa

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

Classes in org.biojava.bio.taxa that implement Changeable
`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 Changeable in org.biojava.ontology

Subinterfaces of Changeable in org.biojava.ontology
`interface` `Ontology` An 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 Changeable
`class` `AbstractTerm` Abstract implementation of term This provides basic change-forwarding functionality from the annotation and ontology properties.
`class` `IntegerOntology`
`class` `IntegerOntology.IntTerm`
`static class` `Ontology.Impl` A basic in-memory implementation of an ontology
`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 Changeable in org.biojava.utils

Classes in org.biojava.utils that implement Changeable
`class` `AbstractChangeable` Useful base-class for objects implementing Changeable
`class` `Unchangeable` This is a utility implementation of Changeable that doesn't fire any events or keep references to any listeners.

Uses of Changeable in org.biojavax

Subinterfaces of Changeable in org.biojavax
`interface` `Comment` A simple ranked comment designed to be used for BioEntry comments in BioSQL.
`interface` `CrossRef` Represents a cross reference to another database.
`interface` `DocRef` Represents a documentary reference.
`interface` `DocRefAuthor` Represents an author of a documentary reference.
`interface` `Namespace` The namespace of an entry in a database schema.
`interface` `Note` Note is a generic class intended to hold a term describing the note, a value to associate with that term, and a rank.
`interface` `RankedCrossRef` Allows cross-references to other databases to be ranked.
`interface` `RankedCrossRefable` Defines an object as being able to have ranked cross references associated with it.
`interface` `RankedDocRef` Represents a documentary reference.
`interface` `RichAnnotatable` Annotatable objects that can have rich annotations.
`interface` `RichAnnotation` An annotation collection which stores annotations as Note objects.

Classes in org.biojavax that implement Changeable
`class` `EmptyRichAnnotation` A place holder for a RichAnnotation that prevents null having to be used
`class` `SimpleComment` An implementaion of Comment.
`class` `SimpleCrossRef` A basic CrossRef implementation.
`class` `SimpleDocRef` A basic DocRef implementation.
`class` `SimpleDocRefAuthor` Represents an author of a documentary reference.
`class` `SimpleNamespace` A basic Namespace implemenation.
`class` `SimpleNote` Simple implementation of Note.
`class` `SimpleRankedCrossRef` Simple implementation of RankedCrossRef.
`class` `SimpleRankedDocRef` Represents a documentary reference.
`class` `SimpleRichAnnotation` Simple annotation wrapper.

Uses of Changeable in org.biojavax.bio

Subinterfaces of Changeable in org.biojavax.bio
`interface` `BioEntry` This class relates to the bioentry table in BioSQL.
`interface` `BioEntryRelationship` Represents the relation between two bioentries.

Classes in org.biojavax.bio that implement Changeable
`class` `SimpleBioEntry` Reference implementation of a BioEntry object which has no features or sequence.
`class` `SimpleBioEntryRelationship` Represents a relationship between two bioentries that is described by a term and given a rank.

Uses of Changeable in org.biojavax.bio.db

Subinterfaces of Changeable in org.biojavax.bio.db
`interface` `RichSequenceDB` A database of RichSequences with accessible keys and iterators over all sequences.
`interface` `RichSequenceDBLite` A database of RichSequences.

Classes in org.biojavax.bio.db that implement Changeable
`class` `AbstractBioEntryDB` An abstract implementation of BioEntryDB that provides the getBioEntryIterator method.
`class` `AbstractRichSequenceDB` An abstract implementation of RichSequenceDB that provides the getRichSequenceIterator method.
`class` `HashBioEntryDB` An implementation of RichSequenceDB that uses an underlying HashMap to store the RichSequence objects.
`class` `HashRichSequenceDB` An implementation of RichSequenceDB that uses an underlying HashMap to store the RichSequence objects.

Uses of Changeable in org.biojavax.bio.db.biosql

Classes in org.biojavax.bio.db.biosql that implement Changeable
`class` `BioSQLBioEntryDB`
`class` `BioSQLRichSequenceDB`

Uses of Changeable in org.biojavax.bio.db.ncbi

Classes in org.biojavax.bio.db.ncbi that implement Changeable
`class` `GenbankRichSequenceDB` This class contains functions accessing DNA sequences in Genbank format.
`class` `GenpeptRichSequenceDB` This class contains functions accessing Peptide sequences in Genpept format.

Uses of Changeable in org.biojavax.bio.seq

Subinterfaces of Changeable 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` `RichFeatureRelationship` Represents the relation between two features.
`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 Changeable
`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` `InfinitelyAmbiguousSymbolList` A symbol list that is `Integer.MAX_VALUE`long, never gives index out of bounds and always returns ambiguity symbols for everything.
`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` `SimpleRichFeatureRelationship` Represents a relationship between two features that is described by a term.
`class` `SimpleRichLocation` A simple implementation of RichLocation.
`class` `SimpleRichSequence` A simple implementation of RichSequence.
`class` `ThinRichSequence` A simple implementation of RichSequence.

Uses of Changeable in org.biojavax.bio.taxa

Subinterfaces of Changeable in org.biojavax.bio.taxa
`interface` `NCBITaxon` Represents an NCBI Taxon entry, a combination of the taxon and taxon_name tables in BioSQL.

Classes in org.biojavax.bio.taxa that implement Changeable
`class` `SimpleNCBITaxon` Reference implementation of NCBITaxon.

Uses of Changeable in org.biojavax.ga

Subinterfaces of Changeable in org.biojavax.ga
`interface` `GeneticAlgorithm` The class that runs the cycles of reproduction, evolution and selection, potentially on multiple `Population`s
`interface` `Organism` A GA 'organism' contains one or more Chromosomes
`interface` `Population` A collection of GA organisms

Uses of Changeable in org.biojavax.ga.functions

Subinterfaces of Changeable in org.biojavax.ga.functions
`interface` `CrossOverFunction` Crosses two chromosomes.
`interface` `MutationFunction` A class that mutates a `SymbolList`

Classes in org.biojavax.ga.functions that implement Changeable
`class` `AbstractCrossOverFunction` Abstract implementation of `CrossOverFunction`.
`class` `AbstractMutationFunction` Abstract implementation of `MutationFunction` all custom implementations should inherit from here.
`static class` `CrossOverFunction.NoCross` A place holder CrossOverFunction that doesn't perform cross overs
`static class` `MutationFunction.NoMutation` Place Holder class that doesn't mutate its SymbolLists
`class` `OrderCrossover` This does a 2-point-crossover on two chromosomes keeping the Symbols in each chromosome constant.
`class` `SimpleCrossOverFunction` Simple Implementation of the `CrossOverFunction` interface
`class` `SimpleMutationFunction` Simple no frills Implementation of the MutationFunction interface
`class` `SwapMutationFunction` This class does a sort of mutation by exchanging two positions on the chromosome.

Uses of Changeable in org.biojavax.ga.impl

Classes in org.biojavax.ga.impl that implement Changeable
`class` `AbstractGeneticAlgorithm` Base class from which most implementations of GeneticAlgorithm will inherit.
`class` `AbstractOrganism` Abstract implementation of Organism.
`class` `AbstractPopulation` Most Population implementations will want to inherit from here.
`class` `SimpleGeneticAlgorithm` A simple implementation of the `GeneticAlgorithm` interface it is not intended that this class be overidden, hence it is final.
`class` `SimpleOrganism` A Simple Haploid Organism implementation
`class` `SimplePopulation` Simple concrete implementation of the `Population` interface

Uses of Changeable in org.biojavax.ontology

Subinterfaces of Changeable in org.biojavax.ontology
`interface` `ComparableOntology` An Ontology that can be compared to another.
`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 Changeable
`class` `SimpleComparableOntology` Represents an ontology that can be compared to other ontologies.
`class` `SimpleComparableTerm` A Term object that can be compared and thus sorted.
`class` `SimpleComparableTriple` Basic comparable triple, BioSQL style.