Uses of Interface
org.biojava.bio.seq.Feature

Packages that use Feature
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.gff GFF manipulation. 
org.biojava.bio.program.xff Event-driven parsing system for the Extensible Feature Format (XFF). 
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.biojavax.bio.db.biosql Interface between biojava and biosql databases 
org.biojavax.bio.seq Rich implementations of Sequences, Locations and Features. 
 

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

Methods in org.biojava.bio.gui.sequence with parameters of type Feature
 String FeatureLabelRenderer.LabelMaker.makeLabel(Feature f)
           
 String FeatureLabelRenderer.SourceLabelMaker.makeLabel(Feature f)
           
 String FeatureLabelRenderer.TypeLabelMaker.makeLabel(Feature f)
           
 String FeatureLabelRenderer.AnnotationLabelMaker.makeLabel(Feature feat)
           
abstract  void AbstractBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead should be overridden by the concrete BeadRenderer.
 void BeadFeatureRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead should implement rendering for this bead type only.
 void EllipticalBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead renders features as simple ellipse.
 void RectangularBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead renders features as simple rectangle.
 void RectangularImapRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void RoundRectangularBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead renders features as a rectangle with rounded corners.
 void CircularFeatureRenderer.renderFeature(Graphics2D g, Feature f, CircularRendererContext context)
           
 void AbstractBeadRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderFeature draws a feature using the supplied graphics context.
 void ArrowedFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void BasicFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void BasicImapRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void FeatureLabelRenderer.renderFeature(Graphics2D g, Feature feat, SequenceRenderContext src)
           
 void FeatureRenderer.renderFeature(Graphics2D g2, Feature feat, SequenceRenderContext context)
           
 void GlyphFeatureRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext src)
           
 void RectangularImapRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void SixFrameZiggyRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext context)
           
 void StackedFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void TickFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void ZiggyFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext context)
           
 void ZiggyImapRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void BasicImapRenderer.renderImageMap(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderImageMap writes a set of image map coordinates corresponding to the rectangle sections drawn by the renderer.
 void ImageMapRenderer.renderImageMap(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderImageMap renders the Feature as set of image map hotspots.
 void RectangularImapRenderer.renderImageMap(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderImageMap writes a set of image map coordinates corresponding to the rectangle drawn by the renderer.
 void ZiggyImapRenderer.renderImageMap(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderImageMap writes a set of image map coordinates corresponding to the rectangle sections drawn by the renderer.
 

Uses of Feature in org.biojava.bio.molbio
 

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

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

Methods in org.biojava.bio.program.das that return Feature
 Feature DASSequence.createFeature(Feature.Template temp)
           
 Feature DASSequence.realizeFeature(FeatureHolder dest, Feature.Template temp)
           
 

Methods in org.biojava.bio.program.das with parameters of type Feature
 boolean DASSequence.containsFeature(Feature f)
           
 void DASSequence.removeFeature(Feature f)
           
 

Uses of Feature in org.biojava.bio.program.gff
 

Methods in org.biojava.bio.program.gff with parameters of type Feature
protected  SimpleGFFRecord SequencesAsGFF.createGFFRecord(Feature feature, String id)
          Internal method to create a GFFRecord from an individual Feature.
protected  void SequencesAsGFF.doProcessFeature(Feature feature, GFFDocumentHandler handler, String id)
          Internal method to process an individual Feature.
 

Uses of Feature in org.biojava.bio.program.xff
 

Methods in org.biojava.bio.program.xff with parameters of type Feature
 String BasicXFFHelper.getFeatureID(Feature f)
           
 String XFFHelper.getFeatureID(Feature f)
           
 void BasicXFFHelper.writeDetails(XMLWriter xw, Feature f)
           
 void PropertyWriter.writeDetails(XMLWriter xw, Feature f)
           
 void XFFHelper.writeDetails(XMLWriter xw, Feature f)
           
 

Uses of Feature in org.biojava.bio.seq
 

Subinterfaces of Feature in org.biojava.bio.seq
 interface ComponentFeature
          Feature which represents a component in an assembly (contig).
 interface FramedFeature
          Title: FramedFeature.
 interface RemoteFeature
          A feature that indicates that there is some remote feature that can't be represented entirely on a single Sequence.
 interface StrandedFeature
          Adds the concept of 'strand' to features.
 

Methods in org.biojava.bio.seq that return Feature
 Feature AbstractFeatureHolder.createFeature(Feature.Template temp)
           
 Feature CircularView.createFeature(Feature.Template template)
          Over rides ViewSequence to allow the use of locations that have coordinates outside of the sequence length (which are needed to describe locations that overlap the origin of a circular sequence).
 Feature FeatureHolder.createFeature(Feature.Template ft)
          Create a new Feature, and add it to this FeatureHolder.
 Feature FeatureHolder.EmptyFeatureHolder.createFeature(Feature.Template f)
           
 Feature LazyFeatureHolder.createFeature(Feature.Template template)
           
 Feature NewSimpleAssembly.createFeature(Feature.Template temp)
           
 Feature SimpleAssembly.createFeature(Feature.Template temp)
           
 Feature FeatureFilter.ByFeature.getFeature()
           
 Feature RemoteFeature.getRemoteFeature()
          Retrieve the Feature on some assembly Sequence that can represent this RemoteFeature properly.
 Feature NewSimpleAssembly.realizeFeature(FeatureHolder fh, Feature.Template temp)
           
 Feature RealizingFeatureHolder.realizeFeature(FeatureHolder parent, Feature.Template template)
          Realize a feature template.
 Feature SimpleAssembly.realizeFeature(FeatureHolder fh, Feature.Template temp)
           
 Feature FeatureRealizer.realizeFeature(Sequence seq, FeatureHolder parent, Feature.Template template)
          Install a feature on the specified sequence.
 Feature SimpleFeatureRealizer.realizeFeature(Sequence seq, FeatureHolder parent, Feature.Template temp)
           
 Feature RemoteFeature.Resolver.resolve(RemoteFeature rFeat)
          Resolve rFeat.
 

Methods in org.biojava.bio.seq that return types with arguments of type Feature
 Iterator<Feature> FeatureHolder.features()
          Iterate over the features in no well defined order.
 Iterator<Feature> FeatureHolder.EmptyFeatureHolder.features()
           
 

Methods in org.biojava.bio.seq with parameters of type Feature
 boolean FeatureFilter.accept(Feature f)
          This method determines whether a feature is to be accepted.
 boolean FeatureFilter.Not.accept(Feature f)
           
 boolean FeatureFilter.And.accept(Feature f)
           
 boolean FeatureFilter.Or.accept(Feature f)
           
 boolean FeatureFilter.ByType.accept(Feature f)
          Returns true if the feature has a matching type property.
 boolean FeatureFilter.BySource.accept(Feature f)
           
 boolean FeatureFilter.ByClass.accept(Feature f)
           
 boolean FeatureFilter.StrandFilter.accept(Feature f)
          Accept the Feature if it is an instance of StrandedFeature and matches the value of getStrand().
 boolean FeatureFilter.BySequenceName.accept(Feature f)
           
 boolean FeatureFilter.ContainedByLocation.accept(Feature f)
          Returns true if the feature is within this filter's location.
 boolean FeatureFilter.OverlapsLocation.accept(Feature f)
          Returns true if the feature overlaps this filter's location.
 boolean FeatureFilter.ShadowOverlapsLocation.accept(Feature f)
          Returns true if the feature overlaps this filter's location.
 boolean FeatureFilter.ShadowContainedByLocation.accept(Feature f)
          Returns true if the feature is within this filter's location.
 boolean FeatureFilter.ByAnnotationType.accept(Feature f)
           
 boolean FeatureFilter.ByParent.accept(Feature f)
           
 boolean FeatureFilter.ByAncestor.accept(Feature f)
           
 boolean FeatureFilter.OnlyChildren.accept(Feature f)
           
 boolean FeatureFilter.OnlyDescendants.accept(Feature f)
           
 boolean FeatureFilter.ByChild.accept(Feature f)
           
 boolean FeatureFilter.ByDescendant.accept(Feature f)
           
 boolean FeatureFilter.FrameFilter.accept(Feature f)
          Accept the Feature if it is an instance of FramedFeature and matches the value of getFrame().
 boolean FeatureFilter.ByPairwiseScore.accept(Feature f)
          Accept a Feature if it is an instance of SimilarityPairFeature and its score is <= filter's minimum score and >= filter's maximum score.
 boolean FeatureFilter.ByComponentName.accept(Feature f)
           
 boolean FeatureFilter.ByFeature.accept(Feature f)
           
 void SimpleFeatureHolder.addFeature(Feature f)
          Add a feature to the featureholder
 boolean FeatureHolder.containsFeature(Feature f)
          Check if the feature is present in this holder.
 boolean FeatureHolder.EmptyFeatureHolder.containsFeature(Feature f)
           
 boolean LazyFeatureHolder.containsFeature(Feature f)
           
 boolean MergeFeatureHolder.containsFeature(Feature f)
           
 boolean NewSimpleAssembly.containsFeature(Feature f)
           
 boolean SimpleAssembly.containsFeature(Feature f)
           
 boolean SimpleFeatureHolder.containsFeature(Feature f)
           
 void AbstractFeatureHolder.removeFeature(Feature f)
           
 void FeatureHolder.removeFeature(Feature f)
          Remove a feature from this FeatureHolder.
 void FeatureHolder.EmptyFeatureHolder.removeFeature(Feature f)
           
 void LazyFeatureHolder.removeFeature(Feature f)
           
 void NewSimpleAssembly.removeFeature(Feature f)
           
 void SimpleAssembly.removeFeature(Feature f)
           
 void SimpleFeatureHolder.removeFeature(Feature f)
           
 

Constructors in org.biojava.bio.seq with parameters of type Feature
FeatureFilter.ByFeature(Feature f)
           
 

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

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

Classes in org.biojava.bio.seq.impl that implement Feature
 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 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.
 

Methods in org.biojava.bio.seq.impl that return Feature
 Feature DummySequence.createFeature(Feature.Template template)
           
 Feature LazyFilterFeatureHolder.createFeature(Feature.Template temp)
           
 Feature RevCompSequence.createFeature(Feature.Template ft)
          createFeature() will call createFeature() on the underlying Sequence.
 Feature SimpleFeature.createFeature(Feature.Template temp)
           
 Feature SimpleGappedSequence.createFeature(Feature.Template templ)
           
 Feature SimpleSequence.createFeature(Feature.Template template)
           
 Feature SubSequence.createFeature(Feature.Template templ)
           
 Feature ViewSequence.createFeature(Feature.Template template)
           
 Feature SimpleSequence.createFeature(FeatureHolder fh, Feature.Template template)
          Deprecated. Please use new 1-arg createFeature instead.
 Feature RevCompSequence.getFeatureFromOriginal(Feature f)
          getFeatureFromOriginal() Since you can not create a feature on a projectedFeature at this time, I am including this method so that you can get the corresponding feature from the original sequence.
 Feature SimpleRemoteFeature.getRemoteFeature()
           
 Feature SubSequence.SubProjectedFeatureContext.projectFeature(Feature origFeat)
           
 Feature SimpleFeature.realizeFeature(FeatureHolder fh, Feature.Template templ)
           
 Feature SimpleSequence.realizeFeature(FeatureHolder parent, Feature.Template template)
           
 Feature ViewSequence.realizeFeature(FeatureHolder parent, Feature.Template template)
           
 Feature SimpleRemoteFeature.DBResolver.resolve(RemoteFeature rFeat)
           
 Feature SubSequence.SubProjectedFeatureContext.revertFeature(Feature projFeat)
           
 

Methods in org.biojava.bio.seq.impl with parameters of type Feature
 boolean DummySequence.containsFeature(Feature feature)
           
 boolean LazyFilterFeatureHolder.containsFeature(Feature f)
           
 boolean RevCompSequence.containsFeature(Feature f)
          containsFeature() will return true if this seq contains the feature in question, or if if the original (non reverse complement) sequence contains the feature;
 boolean SimpleFeature.containsFeature(Feature f)
           
 boolean SimpleGappedSequence.containsFeature(Feature f)
           
 boolean SimpleSequence.containsFeature(Feature f)
           
 boolean SubSequence.containsFeature(Feature f)
           
 boolean ViewSequence.containsFeature(Feature f)
           
 Feature RevCompSequence.getFeatureFromOriginal(Feature f)
          getFeatureFromOriginal() Since you can not create a feature on a projectedFeature at this time, I am including this method so that you can get the corresponding feature from the original sequence.
static Feature.Template TemplateUtils.instantiateTemplate(Feature feat)
          This attempts to divine the 'best' template class for a feature and return a new instance readly for pupulating.
static Feature.Template TemplateUtils.makeTemplate(Feature feat)
           
static void TemplateUtils.populate(Feature.Template templ, Feature feat)
          This attempts to populate the fields of a template using the publically accessible information in a feature.
 FeatureHolder SubSequence.SubProjectedFeatureContext.projectChildFeatures(Feature f, FeatureHolder parent)
           
 Feature SubSequence.SubProjectedFeatureContext.projectFeature(Feature origFeat)
           
 void DummySequence.removeFeature(Feature feature)
           
 void LazyFilterFeatureHolder.removeFeature(Feature f)
           
 void RevCompSequence.removeFeature(Feature f)
           
 void SimpleFeature.removeFeature(Feature f)
           
 void SimpleGappedSequence.removeFeature(Feature f)
           
 void SimpleSequence.removeFeature(Feature f)
          Remove a feature attached to this sequence.
 void SubSequence.removeFeature(Feature f)
           
 void ViewSequence.removeFeature(Feature f)
          Remove a feature from this sequence.
 Feature SubSequence.SubProjectedFeatureContext.revertFeature(Feature projFeat)
           
 

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

Methods in org.biojava.bio.seq.io with parameters of type Feature
 String SeqFileFormer.formatLocation(Feature theFeature)
          Deprecated. Formats the location of a feature.
 String SwissprotFileFormer.formatLocation(Feature theFeature)
          Deprecated. Creates a string representation of the location of a feature
 

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

Methods in org.biojava.bio.seq.io.agave with parameters of type Feature
protected  void StAXFeatureHandler.realizeSubFeatures(Feature feature)
          recursively attach children features to parent
 

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

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

Methods in org.biojava.bio.seq.projection that return Feature
 Feature ProjectedFeature.createFeature(Feature.Template temp)
           
 Feature ProjectedFeatureHolder.createFeature(Feature.Template templ)
           
 Feature ProjectionContext.createFeature(Feature.Template projTempl)
          Create a projected feature with properties matching the template.
 Feature ReparentContext.createFeature(Feature.Template projTempl)
           
 Feature ProjectionContext.createFeature(Feature projParent, Feature.Template projTempl)
          Create a new projected feature.
 Feature ReparentContext.createFeature(Feature f, Feature.Template projTempl)
           
 Feature ProjectedFeature.getViewedFeature()
           
 Feature Projection.getViewedFeature()
           
 Feature ProjectionContext.projectFeature(Feature feat)
          Project a single feature.
 Feature ReparentContext.projectFeature(Feature feat)
          Create a single projected feature using the rules of this ProjectedFeatureHolder.
 Feature ProjectionEngine.projectFeature(Feature f, ProjectionContext ctx)
          Return a projection of Feature f into the system defined by a given ProjectionContext.
 Feature ProjectionContext.revertFeature(Feature projFeat)
          Unproject a feature.
 Feature ReparentContext.revertFeature(Feature feat)
           
 

Methods in org.biojava.bio.seq.projection with parameters of type Feature
 void ProjectionContext.addChangeListener(Feature projFeat, ChangeListener cl, ChangeType ct)
          Add a ChangeListener to a projected feature.
 void ReparentContext.addChangeListener(Feature f, ChangeListener cl, ChangeType ct)
           
 boolean ProjectedFeature.containsFeature(Feature f)
           
 boolean ProjectedFeatureHolder.containsFeature(Feature f)
           
 Feature ProjectionContext.createFeature(Feature projParent, Feature.Template projTempl)
          Create a new projected feature.
 Feature ReparentContext.createFeature(Feature f, Feature.Template projTempl)
           
 FeatureHolder ProjectionContext.getParent(Feature projFeat)
           
 FeatureHolder ReparentContext.getParent(Feature f)
           
 FeatureFilter ReparentContext.getSchema(Feature f)
           
 Sequence ProjectionContext.getSequence(Feature projFeat)
          Get the sequence for a feature.
 Sequence ReparentContext.getSequence(Feature f)
           
 FeatureHolder ProjectionContext.projectChildFeatures(Feature feature, FeatureHolder parent)
          Project all features that are children of feature so that they become children of parent.
 FeatureHolder ReparentContext.projectChildFeatures(Feature f, FeatureHolder parent)
           
 Feature ProjectionContext.projectFeature(Feature feat)
          Project a single feature.
 Feature ReparentContext.projectFeature(Feature feat)
          Create a single projected feature using the rules of this ProjectedFeatureHolder.
 Feature ProjectionEngine.projectFeature(Feature f, ProjectionContext ctx)
          Return a projection of Feature f into the system defined by a given ProjectionContext.
 void ProjectionContext.removeChangeListener(Feature projFeat, ChangeListener cl, ChangeType ct)
          Remove a ChangeListener from a projected feature.
 void ReparentContext.removeChangeListener(Feature f, ChangeListener cl, ChangeType ct)
           
 void ProjectedFeature.removeFeature(Feature f)
           
 void ProjectedFeatureHolder.removeFeature(Feature dyingChild)
           
 void ProjectionContext.removeFeature(Feature dyingChild)
          Remove the dying child.
 void ReparentContext.removeFeature(Feature dyingChild)
           
 void ProjectionContext.removeFeature(Feature projParent, Feature dyingChild)
          Remove the dying child.
 void ReparentContext.removeFeature(Feature f, Feature f2)
           
 Feature ProjectionContext.revertFeature(Feature projFeat)
          Unproject a feature.
 Feature ReparentContext.revertFeature(Feature feat)
           
 

Constructors in org.biojava.bio.seq.projection with parameters of type Feature
ProjectedFeature(Feature f, ProjectionContext ctx)
           
 

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

Methods in org.biojavax.bio.db.biosql with parameters of type Feature
 boolean BioSQLAcceptAllFilter.accept(Feature f)
           
 boolean BioSQLAcceptNoneFilter.accept(Feature f)
           
 boolean BioSQLFeatureFilter.Not.accept(Feature f)
           
 boolean BioSQLFeatureFilter.And.accept(Feature f)
           
 boolean BioSQLFeatureFilter.Or.accept(Feature f)
           
 boolean BioSQLFeatureFilter.ByName.accept(Feature f)
          Returns true if the feature has a matching type property.
 boolean BioSQLFeatureFilter.ByRank.accept(Feature f)
          Returns true if the feature has a matching type property.
 boolean BioSQLFeatureFilter.ByTypeTerm.accept(Feature f)
          Returns true if the feature has a matching type property.
 boolean BioSQLFeatureFilter.BySourceTerm.accept(Feature f)
          Returns true if the feature has a matching source property.
 boolean BioSQLFeatureFilter.ByTypeTermName.accept(Feature f)
          Returns true if the feature has a matching type property.
 boolean BioSQLFeatureFilter.BySourceTermName.accept(Feature f)
          Returns true if the feature has a matching source property.
 boolean BioSQLFeatureFilter.BySequenceName.accept(Feature f)
           
 boolean BioSQLFeatureFilter.ContainedByRichLocation.accept(Feature f)
          Returns true if the feature is within this filter's location.
 boolean BioSQLFeatureFilter.ByStrand.accept(Feature f)
          Returns true if the feature overlaps this filter's location.
 boolean BioSQLFeatureFilter.OverlapsRichLocation.accept(Feature f)
          Returns true if the feature overlaps this filter's location.
 boolean BioSQLFeatureFilter.ByNote.accept(Feature f)
           
 boolean BioSQLFeatureFilter.ByNoteTermOnly.accept(Feature f)
           
 

Uses of Feature in org.biojavax.bio.seq
 

Subinterfaces of Feature 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.
 

Classes in org.biojavax.bio.seq that implement Feature
 class SimpleRichFeature
          A simple implementation of RichFeature.
 

Methods in org.biojavax.bio.seq that return Feature
 Feature SimpleRichFeature.createFeature(Feature.Template ft)
          Create a new Feature, and add it to this FeatureHolder.
 Feature ThinRichSequence.createFeature(Feature.Template ft)
          Create a new Feature, and add it to this FeatureHolder.
 

Methods in org.biojavax.bio.seq that return types with arguments of type Feature
 Iterator<Feature> ThinRichSequence.features()
          Iterate over the features in no well defined order.
 Set<Feature> RichSequence.getFeatureSet()
          The features for this sequence.
 Set<Feature> ThinRichSequence.getFeatureSet()
          The features for this sequence.
 

Methods in org.biojavax.bio.seq with parameters of type Feature
 boolean SimpleRichFeature.containsFeature(Feature f)
          Check if the feature is present in this holder.
 boolean ThinRichSequence.containsFeature(Feature f)
          Check if the feature is present in this holder.
static RichFeature RichFeature.Tools.enrich(Feature f)
          Takes a normal Feature and attempts to convert it into a RichFeature.
 void SimpleRichFeature.removeFeature(Feature f)
          Remove a feature from this FeatureHolder.
 void ThinRichSequence.removeFeature(Feature f)
          Remove a feature from this FeatureHolder.
 

Method parameters in org.biojavax.bio.seq with type arguments of type Feature
 void RichSequence.setFeatureSet(Set<Feature> features)
          Sets the features of this sequence.
 void ThinRichSequence.setFeatureSet(Set<Feature> features)
          Sets the features of this sequence.