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.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)
           
 void RoundRectangularBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead renders features as a rectangle with rounded corners.
 void RectangularImapRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void RectangularBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead renders features as simple rectangle.
 void EllipticalBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead renders features as simple ellipse.
 void BeadFeatureRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead should implement rendering for this bead type only.
abstract  void AbstractBeadRenderer.renderBead(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderBead should be overridden by the concrete BeadRenderer.
 void CircularFeatureRenderer.renderFeature(Graphics2D g, Feature f, CircularRendererContext context)
           
 void ZiggyImapRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void ZiggyFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext context)
           
 void TickFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void StackedFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void SixFrameZiggyRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext context)
           
 void RectangularImapRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void GlyphFeatureRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext src)
           
 void FeatureRenderer.renderFeature(Graphics2D g2, Feature feat, SequenceRenderContext context)
           
 void FeatureLabelRenderer.renderFeature(Graphics2D g, Feature feat, SequenceRenderContext src)
           
 void BasicImapRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
           
 void BasicFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void ArrowedFeatureRenderer.renderFeature(Graphics2D g, Feature f, SequenceRenderContext src)
           
 void AbstractBeadRenderer.renderFeature(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderFeature draws a feature using the supplied graphics context.
 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.
 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 ImageMapRenderer.renderImageMap(Graphics2D g2, Feature f, SequenceRenderContext context)
          renderImageMap renders the Feature as set of image map hotspots.
 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.
 

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.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 XFFHelper.getFeatureID(Feature f)
           
 String BasicXFFHelper.getFeatureID(Feature f)
           
 void XFFHelper.writeDetails(XMLWriter xw, Feature f)
           
 void PropertyWriter.writeDetails(XMLWriter xw, Feature f)
           
 void BasicXFFHelper.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 SimpleAssembly.createFeature(Feature.Template temp)
           
 Feature NewSimpleAssembly.createFeature(Feature.Template temp)
           
 Feature LazyFeatureHolder.createFeature(Feature.Template template)
           
 Feature FeatureHolder.createFeature(Feature.Template ft)
          Create a new Feature, and add it to this FeatureHolder.
 Feature FeatureHolder.EmptyFeatureHolder.createFeature(Feature.Template f)
           
 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 AbstractFeatureHolder.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 SimpleAssembly.realizeFeature(FeatureHolder fh, Feature.Template temp)
           
 Feature RealizingFeatureHolder.realizeFeature(FeatureHolder parent, Feature.Template template)
          Realize a feature template.
 Feature NewSimpleAssembly.realizeFeature(FeatureHolder fh, Feature.Template temp)
           
 Feature SimpleFeatureRealizer.realizeFeature(Sequence seq, FeatureHolder parent, Feature.Template temp)
           
 Feature FeatureRealizer.realizeFeature(Sequence seq, FeatureHolder parent, Feature.Template template)
          Install a feature on the specified sequence.
 Feature RemoteFeature.Resolver.resolve(RemoteFeature rFeat)
          Resolve rFeat.
 

Methods in org.biojava.bio.seq that return types with arguments of type Feature
 Iterator<Feature> SimpleFeatureHolder.features()
           
 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 SimpleFeatureHolder.containsFeature(Feature f)
           
 boolean SimpleAssembly.containsFeature(Feature f)
           
 boolean NewSimpleAssembly.containsFeature(Feature f)
           
 boolean MergeFeatureHolder.containsFeature(Feature f)
           
 boolean LazyFeatureHolder.containsFeature(Feature f)
           
 boolean FeatureHolder.containsFeature(Feature f)
          Check if the feature is present in this holder.
 boolean FeatureHolder.EmptyFeatureHolder.containsFeature(Feature f)
           
 void SimpleFeatureHolder.removeFeature(Feature f)
           
 void SimpleAssembly.removeFeature(Feature f)
           
 void NewSimpleAssembly.removeFeature(Feature f)
           
 void LazyFeatureHolder.removeFeature(Feature f)
           
 void FeatureHolder.removeFeature(Feature f)
          Remove a feature from this FeatureHolder.
 void FeatureHolder.EmptyFeatureHolder.removeFeature(Feature f)
           
 void AbstractFeatureHolder.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 ViewSequence.createFeature(Feature.Template template)
           
 Feature SubSequence.createFeature(Feature.Template templ)
           
 Feature SimpleSequence.createFeature(Feature.Template template)
           
 Feature SimpleGappedSequence.createFeature(Feature.Template templ)
           
 Feature SimpleFeature.createFeature(Feature.Template temp)
           
 Feature RevCompSequence.createFeature(Feature.Template ft)
          createFeature() will call createFeature() on the underlying Sequence.
 Feature LazyFilterFeatureHolder.createFeature(Feature.Template temp)
           
 Feature DummySequence.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 ViewSequence.realizeFeature(FeatureHolder parent, Feature.Template template)
           
 Feature SimpleSequence.realizeFeature(FeatureHolder parent, Feature.Template template)
           
 Feature SimpleFeature.realizeFeature(FeatureHolder fh, Feature.Template templ)
           
 Feature SimpleRemoteFeature.DBResolver.resolve(RemoteFeature rFeat)
           
 Feature SubSequence.SubProjectedFeatureContext.revertFeature(Feature projFeat)
           
 

Methods in org.biojava.bio.seq.impl that return types with arguments of type Feature
 Iterator<Feature> SimpleSequence.features()
           
 Iterator<Feature> SimpleGappedSequence.features()
           
 

Methods in org.biojava.bio.seq.impl with parameters of type Feature
 boolean ViewSequence.containsFeature(Feature f)
           
 boolean SubSequence.containsFeature(Feature f)
           
 boolean SimpleSequence.containsFeature(Feature f)
           
 boolean SimpleGappedSequence.containsFeature(Feature f)
           
 boolean SimpleFeature.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 LazyFilterFeatureHolder.containsFeature(Feature f)
           
 boolean DummySequence.containsFeature(Feature feature)
           
 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 ViewSequence.removeFeature(Feature f)
          Remove a feature from this sequence.
 void SubSequence.removeFeature(Feature f)
           
 void SimpleSequence.removeFeature(Feature f)
          Remove a feature attached to this sequence.
 void SimpleGappedSequence.removeFeature(Feature f)
           
 void SimpleFeature.removeFeature(Feature f)
           
 void RevCompSequence.removeFeature(Feature f)
           
 void LazyFilterFeatureHolder.removeFeature(Feature f)
           
 void DummySequence.removeFeature(Feature feature)
           
 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 SwissprotFileFormer.formatLocation(Feature theFeature)
          Deprecated. Creates a string representation of the location of a feature
 String SeqFileFormer.formatLocation(Feature theFeature)
          Deprecated. Formats 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 ReparentContext.createFeature(Feature.Template projTempl)
           
 Feature ProjectionContext.createFeature(Feature.Template projTempl)
          Create a projected feature with properties matching the template.
 Feature ProjectedFeatureHolder.createFeature(Feature.Template templ)
           
 Feature ProjectedFeature.createFeature(Feature.Template temp)
           
 Feature ReparentContext.createFeature(Feature f, Feature.Template projTempl)
           
 Feature ProjectionContext.createFeature(Feature projParent, Feature.Template projTempl)
          Create a new projected feature.
 Feature Projection.getViewedFeature()
           
 Feature ProjectedFeature.getViewedFeature()
           
 Feature ReparentContext.projectFeature(Feature feat)
          Create a single projected feature using the rules of this ProjectedFeatureHolder.
 Feature ProjectionContext.projectFeature(Feature feat)
          Project a single feature.
 Feature ProjectionEngine.projectFeature(Feature f, ProjectionContext ctx)
          Return a projection of Feature f into the system defined by a given ProjectionContext.
 Feature ReparentContext.revertFeature(Feature feat)
           
 Feature ProjectionContext.revertFeature(Feature projFeat)
          Unproject a feature.
 

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

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 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)
           
 boolean BioSQLAcceptNoneFilter.accept(Feature f)
           
 boolean BioSQLAcceptAllFilter.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 ThinRichSequence.createFeature(Feature.Template ft)
          Create a new Feature, and add it to this FeatureHolder.
 Feature SimpleRichFeature.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> ThinRichSequence.getFeatureSet()
          The features for this sequence.
 Set<Feature> RichSequence.getFeatureSet()
          The features for this sequence.
 

Methods in org.biojavax.bio.seq with parameters of type Feature
 boolean ThinRichSequence.containsFeature(Feature f)
          Check if the feature is present in this holder.
 boolean SimpleRichFeature.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 ThinRichSequence.removeFeature(Feature f)
          Remove a feature from this FeatureHolder.
 void SimpleRichFeature.removeFeature(Feature f)
          Remove a feature from this FeatureHolder.
 

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



Copyright © 2012 BioJava. All Rights Reserved.