java.lang.Object
- org.biojava.nbio.core.sequence.template.AbstractSequence<C>

Type Parameters:

C -

All Implemented Interfaces:

Iterable<C>, Accessioned, Sequence<C>

Direct Known Subclasses:

BasicSequence, DNASequence, ProteinSequence, RNASequence
```
public abstract class AbstractSequence<C extends Compound>
extends Object
implements Sequence<C>
```
The base class for DNA, RNA and Protein sequences.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class AbstractSequence.AnnotationType

Constructor Summary

Constructors
Constructor	Description
`AbstractSequence()`
`AbstractSequence(String seqString, CompoundSet<C> compoundSet)`	Create a Sequence from a simple string where the values should be found in compoundSet
`AbstractSequence(SequenceReader<C> proxyLoader, CompoundSet<C> compoundSet)`	A ProxySequenceReader allows abstraction of both the storage of the sequence data and the location of the sequence data.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addFeature(int bioStart, int bioEnd, FeatureInterface<AbstractSequence<C>,C> feature)`	Method to help set the proper details for a feature as it relates to a sequence where the feature needs to have a location on the sequence
`void`	`addFeature(FeatureInterface<AbstractSequence<C>,C> feature)`	Add a feature to this sequence.
`void`	`addNote(String note)`	Add notes about this sequence that will get exported for GFF3
`int`	`countCompounds(C... compounds)`	Returns the number of times we found a compound in the Sequence
`boolean`	`equals(Object o)`
`AccessionID`	`getAccession()`	Returns the AccessionID this location is currently bound with
`AbstractSequence.AnnotationType`	`getAnnotationType()`
`List<C>`	`getAsList()`	Returns the Sequence as a List of compounds
`Integer`	`getBioBegin()`
`Integer`	`getBioEnd()`
`List<String>`	`getComments()`
`C`	`getCompoundAt(int position)`	Returns the Compound at the given biological index
`CompoundSet<C>`	`getCompoundSet()`	Gets the compound set used to back this Sequence
`DatabaseReferenceInterface`	`getDatabaseReferences()`
`String`	`getDescription()`
`FeatureRetriever`	`getFeatureRetriever()`
`List<FeatureInterface<AbstractSequence<C>,C>>`	`getFeatures()`
`List<FeatureInterface<AbstractSequence<C>,C>>`	`getFeatures(int bioSequencePosition)`	Return features at a sequence position
`List<FeatureInterface<AbstractSequence<C>,C>>`	`getFeatures(String featureType, int bioSequencePosition)`	Return features at a sequence position by type
`List<FeatureInterface<AbstractSequence<C>,C>>`	`getFeaturesByType(String type)`
`FeaturesKeyWordInterface`	`getFeaturesKeyWord()`
`int`	`getIndexOf(C compound)`	Scans through the Sequence looking for the first occurrence of the given compound
`SequenceView<C>`	`getInverse()`	Does the right thing to get the inverse of the current Sequence.
`int`	`getLastIndexOf(C compound)`	Scans through the Sequence looking for the last occurrence of the given compound
`int`	`getLength()`	Returns the length of the Sequence
`ArrayList<String>`	`getNotesList()`
`String`	`getOriginalHeader()`
`AbstractSequence<?>`	`getParentSequence()`
`SequenceReader<C>`	`getProxySequenceReader()`
`List<AbstractReference>`	`getReferences()`
`String`	`getSequenceAsString()`	Default case is to assume strand is positive because only CDSSequence can be either positive or negative Strand.
`String`	`getSequenceAsString(Integer bioStart, Integer bioEnd, Strand strand)`
`Double`	`getSequenceScore()`	Provide place holder for a metric that indicate a score associated with the sequence
`String`	`getSource()`	Added support for the source of this sequence for GFF3 export If a sub sequence doesn't have source then check for parent source
`SequenceView<C>`	`getSubSequence(Integer bioStart, Integer bioEnd)`	Returns a portion of the sequence from the different positions.
`TaxonomyID`	`getTaxonomy()`
`Collection<Object>`	`getUserCollection()`	Provided for convince if the developer needs to associate data with a sequence
`int`	`hashCode()`
`protected void`	`initSequenceStorage(String seqString)`
`Iterator<C>`	`iterator()`
`void`	`removeFeature(FeatureInterface<AbstractSequence<C>,C> feature)`	Remove a feature from the sequence
`void`	`removeNote(String note)`
`void`	`setAccession(AccessionID accession)`
`void`	`setAnnotationType(AbstractSequence.AnnotationType annotationType)`
`void`	`setBioBegin(Integer bioBegin)`
`void`	`setBioEnd(Integer bioEnd)`
`void`	`setComments(List<String> comments)`	Set comments.
`void`	`setCompoundSet(CompoundSet<C> compoundSet)`
`void`	`setDatabaseReferences(DatabaseReferenceInterface databaseReferences)`
`void`	`setDescription(String description)`
`void`	`setFeatureRetriever(FeatureRetriever featureRetriever)`
`void`	`setFeaturesKeyWord(FeaturesKeyWordInterface featuresKeyWord)`
`void`	`setNotesList(ArrayList<String> notesList)`
`void`	`setOriginalHeader(String originalHeader)`
`void`	`setParentSequence(AbstractSequence<?> parentSequence)`
`void`	`setProxySequenceReader(SequenceReader<C> proxyLoader)`	Very important method that allows external mappings of sequence data and features.
`void`	`setReferences(List<AbstractReference> references)`	Set the list of `AbstractReference`
`void`	`setSequenceScore(Double sequenceScore)`
`void`	`setSource(String source)`	Added support for the source of this sequence for GFF3 export
`void`	`setTaxonomy(TaxonomyID taxonomy)`
`void`	`setUserCollection(Collection<Object> userCollection)`
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - AbstractSequence
```
public AbstractSequence()
```
  - AbstractSequence
```
public AbstractSequence(String seqString,
                        CompoundSet<C> compoundSet)
                 throws CompoundNotFoundException
```
    Create a Sequence from a simple string where the values should be found in compoundSet
    
    Parameters:
    
    seqString -
    
    compoundSet -
    
    Throws:
    
    CompoundNotFoundException
  - AbstractSequence
```
public AbstractSequence(SequenceReader<C> proxyLoader,
                        CompoundSet<C> compoundSet)
```
    A ProxySequenceReader allows abstraction of both the storage of the sequence data and the location of the sequence data. A variety of use cases are possible. A ProxySequenceReader that knows the offset and of the sequence in a large fasta file. A ProxySequenceReader that can pull Sequence data from UniProt, NCBI or a custom database. If the ProxySequenceReader implements various interfaces then the sequence will set those interfaces so that calls to various methods will be valid.
    
    Parameters:
    
    proxyLoader -
    
    compoundSet -
- Method Detail
  - initSequenceStorage
```
protected void initSequenceStorage(String seqString)
                            throws CompoundNotFoundException
```
    Throws:
    
    CompoundNotFoundException
  - setProxySequenceReader
```
public void setProxySequenceReader(SequenceReader<C> proxyLoader)
```
    Very important method that allows external mappings of sequence data and features. This method will gain additional interface inspection that allows external data sources with knowledge of features for a sequence to be supported.
    
    Parameters:
    
    proxyLoader -
  - getProxySequenceReader
```
public SequenceReader<C> getProxySequenceReader()
```
  - getBioBegin
```
public Integer getBioBegin()
```
    Returns:
    
    the bioBegin
  - setBioBegin
```
public void setBioBegin(Integer bioBegin)
```
    Parameters:
    
    bioBegin - the bioBegin to set
  - getBioEnd
```
public Integer getBioEnd()
```
    Returns:
    
    the bioEnd
  - setBioEnd
```
public void setBioEnd(Integer bioEnd)
```
    Parameters:
    
    bioEnd - the bioEnd to set
  - getUserCollection
```
public Collection<Object> getUserCollection()
```
    Provided for convince if the developer needs to associate data with a sequence
    
    Returns:
  - setUserCollection
```
public void setUserCollection(Collection<Object> userCollection)
```
    Parameters:
    
    userCollection -
  - getAnnotationType
```
public AbstractSequence.AnnotationType getAnnotationType()
```
    Returns:
    
    the annotation
  - setAnnotationType
```
public void setAnnotationType(AbstractSequence.AnnotationType annotationType)
```
    Parameters:
    
    annotationType - the annotation to set
  - getDescription
```
public String getDescription()
```
    Returns:
    
    the description
  - setDescription
```
public void setDescription(String description)
```
    Parameters:
    
    description - the description to set
  - getOriginalHeader
```
public String getOriginalHeader()
```
    Returns:
    
    the originalHeader
  - setOriginalHeader
```
public void setOriginalHeader(String originalHeader)
```
    Parameters:
    
    originalHeader - the originalHeader to set
  - getParentSequence
```
public AbstractSequence<?> getParentSequence()
```
    Returns:
    
    the parentSequence
  - setParentSequence
```
public void setParentSequence(AbstractSequence<?> parentSequence)
```
    Parameters:
    
    parentSequence - the parentSequence to set
  - getSource
```
public String getSource()
```
    Added support for the source of this sequence for GFF3 export If a sub sequence doesn't have source then check for parent source
    
    Returns:
    
    the source
  - setSource
```
public void setSource(String source)
```
    Added support for the source of this sequence for GFF3 export
    
    Parameters:
    
    source - the source to set
  - addNote
```
public void addNote(String note)
```
    Add notes about this sequence that will get exported for GFF3
    
    Parameters:
    
    note -
  - removeNote
```
public void removeNote(String note)
```
  - getNotesList
```
public ArrayList<String> getNotesList()
```
    Returns:
    
    the notesList
  - setNotesList
```
public void setNotesList(ArrayList<String> notesList)
```
    Parameters:
    
    notesList - the notesList to set
  - getSequenceScore
```
public Double getSequenceScore()
```
    Provide place holder for a metric that indicate a score associated with the sequence
    
    Returns:
    
    the sequenceScore
  - setSequenceScore
```
public void setSequenceScore(Double sequenceScore)
```
    Parameters:
    
    sequenceScore - the sequenceScore to set
  - getReferences
```
public List<AbstractReference> getReferences()
```
    Returns:
    
    the list of AbstractReference
    
    Since:
    
    5.0.0
  - setReferences
```
public void setReferences(List<AbstractReference> references)
```
    Set the list of AbstractReference
    
    Parameters:
    
    references -
    
    Since:
    
    5.0.0
  - getFeatures
```
public List<FeatureInterface<AbstractSequence<C>,C>> getFeatures(String featureType,
                                                                       int bioSequencePosition)
```
    Return features at a sequence position by type
    
    Parameters:
    
    featureType -
    
    bioSequencePosition -
    
    Returns:
  - getFeatures
```
public List<FeatureInterface<AbstractSequence<C>,C>> getFeatures(int bioSequencePosition)
```
    Return features at a sequence position
    
    Parameters:
    
    bioSequencePosition -
    
    Returns:
  - getFeatures
```
public List<FeatureInterface<AbstractSequence<C>,C>> getFeatures()
```
    Returns:
  - addFeature
```
public void addFeature(int bioStart,
                       int bioEnd,
                       FeatureInterface<AbstractSequence<C>,C> feature)
```
    Method to help set the proper details for a feature as it relates to a sequence where the feature needs to have a location on the sequence
    
    Parameters:
    
    bioStart -
    
    bioEnd -
    
    feature -
  - addFeature
```
public void addFeature(FeatureInterface<AbstractSequence<C>,C> feature)
```
    Add a feature to this sequence. The feature will be added to the collection where the order is start position and if more than one feature at the same start position then longest is added first. This helps on doing feature layout for displaying features in SequenceFeaturePanel
    
    Parameters:
    
    feature -
  - removeFeature
```
public void removeFeature(FeatureInterface<AbstractSequence<C>,C> feature)
```
    Remove a feature from the sequence
    
    Parameters:
    
    feature -
  - getFeaturesByType
```
public List<FeatureInterface<AbstractSequence<C>,C>> getFeaturesByType(String type)
```
    Parameters:
    
    type -
    
    Returns:
  - getComments
```
public List<String> getComments()
```
    Returns:
    
    comments
  - setComments
```
public void setComments(List<String> comments)
```
    Set comments.
    
    Parameters:
    
    comments -
  - getFeaturesKeyWord
```
public FeaturesKeyWordInterface getFeaturesKeyWord()
```
    Returns:
    
    the featuresKeyWord
  - setFeaturesKeyWord
```
public void setFeaturesKeyWord(FeaturesKeyWordInterface featuresKeyWord)
```
    Parameters:
    
    featuresKeyWord - the featuresKeyWord to set
  - getDatabaseReferences
```
public DatabaseReferenceInterface getDatabaseReferences()
```
    Returns:
    
    the databaseReferences
  - setDatabaseReferences
```
public void setDatabaseReferences(DatabaseReferenceInterface databaseReferences)
```
    Parameters:
    
    databaseReferences - the databaseReferences to set
  - getFeatureRetriever
```
public FeatureRetriever getFeatureRetriever()
```
  - setFeatureRetriever
```
public void setFeatureRetriever(FeatureRetriever featureRetriever)
```
  - getAccession
```
public AccessionID getAccession()
```
    Description copied from interface: Accessioned
    
    Returns the AccessionID this location is currently bound with
    
    Specified by:
    
    getAccession in interface Accessioned
    
    Returns:
    
    the accession
  - setAccession
```
public void setAccession(AccessionID accession)
```
    Parameters:
    
    accession - the accession to set
  - getTaxonomy
```
public TaxonomyID getTaxonomy()
```
    Returns:
    
    the species
  - setTaxonomy
```
public void setTaxonomy(TaxonomyID taxonomy)
```
    Parameters:
    
    taxonomy - the species to set
  - getCompoundSet
```
public CompoundSet<C> getCompoundSet()
```
    Description copied from interface: Sequence
    
    Gets the compound set used to back this Sequence
    
    Specified by:
    
    getCompoundSet in interface Sequence<C extends Compound>
  - setCompoundSet
```
public void setCompoundSet(CompoundSet<C> compoundSet)
```
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getSequenceAsString
```
public String getSequenceAsString(Integer bioStart,
                                  Integer bioEnd,
                                  Strand strand)
```
    Parameters:
    
    bioStart -
    
    bioEnd -
    
    strand -
    
    Returns:
  - getSequenceAsString
```
public String getSequenceAsString()
```
    Default case is to assume strand is positive because only CDSSequence can be either positive or negative Strand.
    
    Specified by:
    
    getSequenceAsString in interface Sequence<C extends Compound>
    
    Returns:
  - getAsList
```
public List<C> getAsList()
```
    Description copied from interface: Sequence
    
    Returns the Sequence as a List of compounds
    
    Specified by:
    
    getAsList in interface Sequence<C extends Compound>
    
    Returns:
  - getCompoundAt
```
public C getCompoundAt(int position)
```
    Description copied from interface: Sequence
    
    Returns the Compound at the given biological index
    
    Specified by:
    
    getCompoundAt in interface Sequence<C extends Compound>
    
    Parameters:
    
    position - The 1-indexed position of the amino acid
    
    Returns:
  - getIndexOf
```
public int getIndexOf(C compound)
```
    Description copied from interface: Sequence
    
    Scans through the Sequence looking for the first occurrence of the given compound
    
    Specified by:
    
    getIndexOf in interface Sequence<C extends Compound>
    
    Parameters:
    
    compound -
    
    Returns:
    
    The first index of compound in this sequence (1-based)
  - getLastIndexOf
```
public int getLastIndexOf(C compound)
```
    Description copied from interface: Sequence
    
    Scans through the Sequence looking for the last occurrence of the given compound
    
    Specified by:
    
    getLastIndexOf in interface Sequence<C extends Compound>
    
    Parameters:
    
    compound -
    
    Returns:
    
    The last index of compound in this sequence (1-based)
  - getLength
```
public int getLength()
```
    Description copied from interface: Sequence
    
    Returns the length of the Sequence
    
    Specified by:
    
    getLength in interface Sequence<C extends Compound>
    
    Returns:
  - getSubSequence
```
public SequenceView<C> getSubSequence(Integer bioStart,
                                      Integer bioEnd)
```
    Description copied from interface: Sequence
    
    Returns a portion of the sequence from the different positions. This is indexed from 1
    
    Specified by:
    
    getSubSequence in interface Sequence<C extends Compound>
    
    Parameters:
    
    bioStart -
    
    bioEnd -
    
    Returns:
  - iterator
```
public Iterator<C> iterator()
```
    Specified by:
    
    iterator in interface Iterable<C extends Compound>
    
    Returns:
  - countCompounds
```
public int countCompounds(C... compounds)
```
    Description copied from interface: Sequence
    
    Returns the number of times we found a compound in the Sequence
    
    Specified by:
    
    countCompounds in interface Sequence<C extends Compound>
    
    Parameters:
    
    compounds -
    
    Returns:
  - getInverse
```
public SequenceView<C> getInverse()
```
    Description copied from interface: Sequence
    
    Does the right thing to get the inverse of the current Sequence. This means either reversing the Sequence and optionally complementing the Sequence.
    
    Specified by:
    
    getInverse in interface Sequence<C extends Compound>
    
    Returns:

Class AbstractSequence<C extends Compound>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

AbstractSequence

AbstractSequence

AbstractSequence

Method Detail

initSequenceStorage

setProxySequenceReader

getProxySequenceReader

getBioBegin

setBioBegin

getBioEnd

setBioEnd

getUserCollection

setUserCollection

getAnnotationType

setAnnotationType

getDescription

setDescription

getOriginalHeader

setOriginalHeader

getParentSequence

setParentSequence

getSource

setSource

addNote

removeNote

getNotesList

setNotesList

getSequenceScore

setSequenceScore

getReferences

setReferences

getFeatures

getFeatures

getFeatures

addFeature

addFeature

removeFeature

getFeaturesByType

getComments

setComments

getFeaturesKeyWord

setFeaturesKeyWord

getDatabaseReferences

setDatabaseReferences

getFeatureRetriever

setFeatureRetriever

getAccession

setAccession

getTaxonomy

setTaxonomy

getCompoundSet

setCompoundSet

equals

hashCode

toString

getSequenceAsString

getSequenceAsString

getAsList

getCompoundAt

getIndexOf

getLastIndexOf

getLength

getSubSequence

iterator

countCompounds

getInverse