Uses of Interface
org.biojava3.core.sequence.template.Compound

Packages that use Compound

org.biojava3.core.sequence
org.biojava3.core.sequence.compound
org.biojava3.core.sequence.edits
org.biojava3.core.sequence.features
org.biojava3.core.sequence.io
org.biojava3.core.sequence.io.template
org.biojava3.core.sequence.io.util
org.biojava3.core.sequence.loader
org.biojava3.core.sequence.location
org.biojava3.core.sequence.location.template
org.biojava3.core.sequence.storage
org.biojava3.core.sequence.template
org.biojava3.core.sequence.transcription
org.biojava3.core.sequence.views

Uses of Compound in org.biojava3.core.sequence

Classes in org.biojava3.core.sequence with type parameters of type Compound

class	BasicSequence<C extends Compound> Bare bones version of the Sequence object to be used sparingly.
class	MultipleSequenceAlignment<S extends Sequence<C>,C extends Compound> Implements a minimal data structure for reading and writing a sequence alignment.

Uses of Compound in org.biojava3.core.sequence.compound

Classes in org.biojava3.core.sequence.compound that implement Compound

class	AminoAcidCompound Used to describe an Amino Acid.
class	CodonCompound Define a codon
class	NucleotideCompound

Methods in org.biojava3.core.sequence.compound with parameters of type Compound

boolean	AminoAcidCompound.equalsIgnoreCase(Compound compound)
boolean	NucleotideCompound.equalsIgnoreCase(Compound compound)
boolean	CodonCompound.equalsIgnoreCase(Compound compound)

Uses of Compound in org.biojava3.core.sequence.edits

Classes in org.biojava3.core.sequence.edits with type parameters of type Compound

interface	Edit<C extends Compound> Interface for carrying out edit operations on a Sequence.
static class	Edit.AbstractEdit<C extends Compound> Abstract class which defines all edit operations as a call to discover what 5' and 3' ends of an editing Sequence should be joined together with a target Sequence.
static class	Edit.Delete<C extends Compound> Implementation which allows for the deletion of bases from a Sequence
static class	Edit.Insert<C extends Compound> Edit implementation which allows us to insert a base at any position in a Sequence.
static class	Edit.Substitute<C extends Compound> Allows for the substitution of bases into an existing Sequence.

Uses of Compound in org.biojava3.core.sequence.features

Classes in org.biojava3.core.sequence.features with type parameters of type Compound

class	AbstractFeature<S extends AbstractSequence<C>,C extends Compound> A feature is currently any descriptive item that can be associated with a sequence position(s) A feature has a type and a source which is currently a string to allow flexibility for the user Ideally well defined features should have a class to describe attributes of that feature
interface	FeatureInterface<S extends AbstractSequence<C>,C extends Compound> Interface class to handle describing arbitrary features.
class	QuantityFeature<S extends AbstractSequence<C>,C extends Compound> It is common to have a numerical value or values associated with a feature.
class	TextFeature<S extends AbstractSequence<C>,C extends Compound> A implmentation of AbstractFeature

Uses of Compound in org.biojava3.core.sequence.io

Classes in org.biojava3.core.sequence.io with type parameters of type Compound

class	FastaReader<S extends Sequence<?>,C extends Compound> Use FastaReaderHelper as an example of how to use this class where FastaReaderHelper should be the primary class used to read Fasta files
class	FastaWriter<S extends Sequence<?>,C extends Compound> The FastaWriter writes a collection of sequences to an outputStream.
class	GenericFastaHeaderFormat<S extends AbstractSequence<?>,C extends Compound> We store the original header if the sequence is parsed from a fasta file and will use that exact sequence if we write out the sequences to a fasta file.
class	GenericFastaHeaderParser<S extends AbstractSequence<C>,C extends Compound> The default fasta header parser where some headers are well defined based on the source database which allows us to set the source of the protein sequence and the identifier that can be used in future implementations to load features from external sources If the user has a custom header with local data then they can create their own implementation of a FastaHeaderParserInterface GenBank gi|gi-number|gb|accession|locus ENA Data Library gi|gi-number|emb|accession|locus DDBJ, DNA Database of Japan gi|gi-number|dbj|accession|locus NBRF PIR pir||entry Protein Research Foundation prf||name SWISS-PROT sp|accession|name Brookhaven Protein Data Bank (1) pdb|entry|chain Brookhaven Protein Data Bank (2) entry:chain|PDBID|CHAIN|SEQUENCE PDB EBI PDB:1ECY_A mol:protein length:142 ECOTIN Patents pat|country|number GenInfo Backbone Id bbs|number General database identifier gnl|database|identifier NCBI Reference Sequence ref|accession|locus Local Sequence identifier lcl|identifier

Uses of Compound in org.biojava3.core.sequence.io.template

Classes in org.biojava3.core.sequence.io.template with type parameters of type Compound

interface	FastaHeaderFormatInterface<S extends Sequence<?>,C extends Compound>
interface	FastaHeaderParserInterface<S extends Sequence<?>,C extends Compound>
interface	SequenceCreatorInterface<C extends Compound>

Uses of Compound in org.biojava3.core.sequence.io.util

Methods in org.biojava3.core.sequence.io.util with type parameters of type Compound

static <S extends Sequence<C>,C extends Compound> int	IOUtils.getGCGChecksum(List<S> sequences) Calculates GCG checksum for entire list of sequences
static <S extends Sequence<C>,C extends Compound> int	IOUtils.getGCGChecksum(S sequence) Calculates GCG checksum for a given sequence
static <S extends Sequence<C>,C extends Compound> String	IOUtils.getGCGHeader(List<S> sequences) Assembles a GCG file header
static <C extends Compound> String	IOUtils.getGCGType(CompoundSet<C> cs) Determines GCG type
static <S extends Sequence<C>,C extends Compound> String	IOUtils.getIDFormat(List<S> sequences) Creates format String for accession IDs

Uses of Compound in org.biojava3.core.sequence.loader

Classes in org.biojava3.core.sequence.loader with type parameters of type Compound

class	ArrayListProxySequenceReader<C extends Compound>
class	SequenceFileProxyLoader<C extends Compound> This class represents the storage container of a sequence stored in a fasta file where the initial parsing of the file we store the offset and length of the sequence.
class	StringProxySequenceReader<C extends Compound> An example of a ProxySequenceReader that is created from a String.
class	UniprotProxySequenceReader<C extends Compound> Pass in a Uniprot ID and this ProxySequenceReader when passed to a ProteinSequence will get the sequence data and other data elements associated with the ProteinSequence by Uniprot.

Methods in org.biojava3.core.sequence.loader with parameters of type Compound

int	SequenceFileProxyLoader.countCompounds(C... compounds)
int	StringProxySequenceReader.countCompounds(C... compounds)
int	UniprotProxySequenceReader.countCompounds(C... compounds)

Uses of Compound in org.biojava3.core.sequence.location

Classes in org.biojava3.core.sequence.location with type parameters of type Compound

class

SequenceLocation<S extends AbstractSequence<C>,C extends Compound> A location in a sequence that keeps a reference to its parent sequence

Uses of Compound in org.biojava3.core.sequence.location.template

Methods in org.biojava3.core.sequence.location.template with type parameters of type Compound

protected <C extends Compound> boolean	AbstractLocation.canComplement(Sequence<C> sequence) Uses the Sequence's CompoundSet to decide if a compound can be assgined to ComplementCompound meaning it can complement
<C extends Compound> Sequence<C>	Location.getRelevantSubSequence(Sequence<C> sequence) Will return a SequenceReader object which offers a view of all resolved locations i.e. those locations which are not complex and define the true Sequence represented
<C extends Compound> Sequence<C>	AbstractLocation.getRelevantSubSequence(Sequence<C> sequence)
<C extends Compound> Sequence<C>	Location.getSubSequence(Sequence<C> sequence) Will return a SequenceReader object which represents the outer bounds of this Location
<C extends Compound> Sequence<C>	AbstractLocation.getSubSequence(Sequence<C> sequence) If circular this will return the sequence represented by the sub locations joined.
protected <C extends Compound> Sequence<C>	AbstractLocation.reverseSequence(Sequence<C> sequence) Reverses and (if possible) complements the Sequence so as to represent the reverse strand (if one exists).

Methods in org.biojava3.core.sequence.location.template that return types with arguments of type Compound

ProxySequenceReader<? extends Compound>

AccesionedLocation.getProxySequenceReader() Return the proxy reader used to get sequence for this location.

Uses of Compound in org.biojava3.core.sequence.storage

Classes in org.biojava3.core.sequence.storage with type parameters of type Compound

class	ArrayListSequenceReader<C extends Compound> Stores a Sequence as a collection of compounds in an ArrayList
class	BitSequenceReader<C extends Compound> An implementation of the popular bit encodings.
static class	BitSequenceReader.BitArrayWorker<C extends Compound> The logic of working with a bit has been separated out into this class to help developers create the bit data structures without having to put the code into an intermediate format and to also use the format without the need to copy this code.
class	FourBitSequenceReader<C extends Compound> Four bit encoding of the bit formats.
static class	FourBitSequenceReader.FourBitArrayWorker<C extends Compound> A four bit per compound implementation of the bit array worker code.
class	JoiningSequenceReader<C extends Compound> This reader actually proxies onto multiple types of sequence in order to allow a number of sequence objects to act as if they are one sequence.
class	SequenceAsStringHelper<C extends Compound> This is a common method that can be used across multiple storage/proxy implementations to handle Negative strand and other interesting elements of sequence data.
class	SingleCompoundSequenceReader<C extends Compound> An implementation of the SequenceReader interface which for every call will return only 1 compound (given to it during construction; a String is also valid but will require a CompoundSet).

Methods in org.biojava3.core.sequence.storage with parameters of type Compound

int	SingleCompoundSequenceReader.countCompounds(C... compounds) Delegates to SequenceMixin#countCompounds(org.biojava3.core.sequence.template.Sequence, C[])
int	BitSequenceReader.countCompounds(C... compounds) Counts the number of times a compound appears in this sequence store
int	ArrayListSequenceReader.countCompounds(C... compounds)
int	JoiningSequenceReader.countCompounds(C... compounds)

Uses of Compound in org.biojava3.core.sequence.template

Classes in org.biojava3.core.sequence.template with type parameters of type Compound

class	AbstractCompoundSet<C extends Compound>
class	AbstractCompoundTranslator<F extends Compound,T extends Compound>
class	AbstractCompoundTranslator<F extends Compound,T extends Compound>
class	AbstractSequence<C extends Compound> The base class for DNA, RNA and Protein sequences.
interface	CompoundSet<C extends Compound>
interface	CompoundTranslator<F extends Compound,T extends Compound>
interface	CompoundTranslator<F extends Compound,T extends Compound>
interface	LightweightProfile<S extends Sequence<C>,C extends Compound> Defines a minimal data structure for reading and writing a sequence alignment.
interface	ProxySequenceReader<C extends Compound>
interface	Sequence<C extends Compound> Main interface for defining a collection of Compounds and accessing them using biological indexes
static class	SequenceMixin.SequenceIterator<C extends Compound> A basic sequence iterator which iterates over the given Sequence by biological index.
class	SequenceProxyView<C extends Compound>
interface	SequenceReader<C extends Compound>
interface	SequenceView<C extends Compound>

Subinterfaces of Compound in org.biojava3.core.sequence.template

interface

ComplementCompound

Classes in org.biojava3.core.sequence.template that implement Compound

class

AbstractCompound The details of a Compound

Methods in org.biojava3.core.sequence.template with type parameters of type Compound

static <C extends Compound> String	SequenceMixin.checksum(Sequence<C> sequence) Performs a simple CRC64 checksum on any given sequence.
static <C extends Compound> int	SequenceMixin.countCompounds(Sequence<C> sequence, C... compounds) For the given vargs of compounds this method counts the number of times those compounds appear in the given sequence
static <C extends Compound> Iterator<C>	SequenceMixin.createIterator(Sequence<C> sequence) Creates a simple sequence iterator which moves through a sequence going from 1 to the length of the Sequence.
static <C extends Compound> SequenceView<C>	SequenceMixin.createSubSequence(Sequence<C> sequence, int start, int end) Creates a simple sub sequence view delimited by the given start and end.
static <C extends Compound> Map<C,Integer>	SequenceMixin.getComposition(Sequence<C> sequence) Does a linear scan over the given Sequence and records the number of times each base appears.
static <C extends Compound> Map<C,Double>	SequenceMixin.getDistribution(Sequence<C> sequence) Analogous to SequenceMixin.getComposition(Sequence) but returns the distribution of that Compound over the given sequence.
static <C extends Compound> int	SequenceMixin.indexOf(Sequence<C> sequence, C compound) Performs a linear search of the given Sequence for the given compound.
static <C extends Compound> SequenceView<C>	SequenceMixin.inverse(Sequence<C> sequence) A method which attempts to do the right thing when is comes to a reverse/reverse complement
static <C extends Compound> int	SequenceMixin.lastIndexOf(Sequence<C> sequence, C compound) Performs a reversed linear search of the given Sequence by wrapping it in a ReversedSequenceView and passing it into SequenceMixin.indexOf(Sequence, Compound).
static <C extends Compound> List<SequenceView<C>>	SequenceMixin.nonOverlappingKmers(Sequence<C> sequence, int kmer) Produces kmers of the specified size e.g.
static <C extends Compound> List<SequenceView<C>>	SequenceMixin.overlappingKmers(Sequence<C> sequence, int kmer) Used to generate overlapping k-mers such i.e.
static <C extends Compound> Sequence<C>	SequenceMixin.shuffle(Sequence<C> sequence) Implements sequence shuffling by first materializing the given Sequence into a List, applying Collections.shuffle(List) and then returning the shuffled elements in a new instance of SequenceBackingStore which behaves as a Sequence.
static <C extends Compound> List<C>	SequenceMixin.toList(Sequence<C> sequence) For the given Sequence this will return a List filled with the Compounds of that Sequence.
static <C extends Compound> String	SequenceMixin.toString(Sequence<C> sequence) Shortcut to SequenceMixin.toStringBuilder(org.biojava3.core.sequence.template.Sequence) which calls toString() on the resulting object.
static <C extends Compound> StringBuilder	SequenceMixin.toStringBuilder(Sequence<C> sequence) For the given Sequence this will return a StringBuilder object filled with the results of Compound#toString().
static <C extends Compound> void	SequenceMixin.write(Appendable appendable, Sequence<C> sequence) Used as a way of sending a Sequence to a writer without the cost of converting to a full length String and then writing the data out

Methods in org.biojava3.core.sequence.template with parameters of type Compound

protected void	AbstractCompoundSet.addCompound(C compound, C lowerCasedCompound, C... equivalents)
protected void	AbstractCompoundTranslator.addCompounds(F source, T... targets)
int	AbstractSequence.countCompounds(C... compounds)
int	SequenceProxyView.countCompounds(C... compounds)
int	Sequence.countCompounds(C... compounds) Returns the number of times we found a compound in the Sequence
static <C extends Compound> int	SequenceMixin.countCompounds(Sequence<C> sequence, C... compounds) For the given vargs of compounds this method counts the number of times those compounds appear in the given sequence
boolean	Compound.equalsIgnoreCase(Compound compound)

Uses of Compound in org.biojava3.core.sequence.transcription

Classes in org.biojava3.core.sequence.transcription that implement Compound

class	CaseInsensitiveCompound Attempts to wrap compounds so it is possible to view them in a case insensitive manner
static class	Table.Codon Instance of a Codon which is 3 NucleotideCompounds, its corresponding AminoAcidCompound and if it is a start or stop codon.

Methods in org.biojava3.core.sequence.transcription with parameters of type Compound

boolean	Table.Codon.equalsIgnoreCase(Compound compound)
boolean	CaseInsensitiveCompound.equalsIgnoreCase(Compound compound)

Uses of Compound in org.biojava3.core.sequence.views

Classes in org.biojava3.core.sequence.views with type parameters of type Compound

class	ReversedSequenceView<C extends Compound> For a given sequence this class will return the base at the reversed position i.e. in a sequence of size 10, if you request base 2 you will get back the base at position 9.
class	WindowedSequence<C extends Compound> A sliding window view of a sequence which does not implement any interfaces like Sequence because they do not fit how this works.