## org.biojava.bio.seq.io
Class SequenceBuilderFilter

    java.lang.Object
      org.biojava.bio.seq.io.SequenceBuilderFilter

All Implemented Interfaces:
  SeqIOListener, SequenceBuilder

Direct Known Subclasses:
  EmblProcessor, FastaDescriptionLineParser, GenbankProcessor, OrganismParser, SwissprotProcessor

    public class SequenceBuilderFilter

extends Object
implements SequenceBuilder

Base-class for builders that pass filtered events onto another builder.

Since:
  1.1
Author:
  Matthew Pocock
See Also:
  `RichSeqIOAdapter`

Constructor Summary
`SequenceBuilderFilter(SequenceBuilder delegate)` Create a new SeqIOFilter that will forward events on to another listener.

Method Summary
`void` `addFeatureProperty(Object key, Object value)` Notify the listener of a feature property.
`void` `addSequenceProperty(Object key, Object value)` Notify the listener of a sequence-wide property.
`void` `addSymbols(Alphabet alpha, Symbol[] syms, int start, int length)` Notify the listener of symbol data.
`void` `endFeature()` Mark the end of data associated with one specific feature.
`void` `endSequence()` Notify the listener that processing of the sequence is complete.
`SequenceBuilder` `getDelegate()` Retrieve the delegate that is wrapped.
`Sequence` `makeSequence()` Return the Sequence object which has been constructed by this builder.
`void` `setName(String name)` Notify the listener that the current sequence is generally known by a particular name.
`void` `setURI(String uri)` Notify the listener of a URI identifying the current sequence.
`void` `startFeature(Feature.Template templ)` Notify the listener that a new feature object is starting.
`void` `startSequence()` Start the processing of a sequence.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### SequenceBuilderFilter

    public SequenceBuilderFilter(SequenceBuilder delegate)

  Create a new SeqIOFilter that will forward events on to another listener.

  Parameters:
    `delegate` - the SequenceBuilder to wrap

Method Detail

### getDelegate

    public SequenceBuilder getDelegate()

  Retrieve the delegate that is wrapped.

  Returns:
    the SequenceBuilder delegate

### startSequence

    public void startSequence()
                       throws ParseException

  Description copied from interface: `SeqIOListener`
  Start the processing of a sequence. This method exists primarily to enforce the life-cycles of SeqIOListener objects.

  Specified by:
    `startSequence` in interface `SeqIOListener`
  Throws:
    `ParseException`

### endSequence

    public void endSequence()
                     throws ParseException

  Description copied from interface: `SeqIOListener`
  Notify the listener that processing of the sequence is complete.

  Specified by:
    `endSequence` in interface `SeqIOListener`
  Throws:
    `ParseException`

### setName

    public void setName(String name)
                 throws ParseException

  Description copied from interface: `SeqIOListener`
  Notify the listener that the current sequence is generally known by a particular name.

  Specified by:
    `setName` in interface `SeqIOListener`
  Parameters:
    `name` - the String that should be returned by getName for the sequence being parsed
  Throws:
    `ParseException`

### setURI

    public void setURI(String uri)
                throws ParseException

  Description copied from interface: `SeqIOListener`
  Notify the listener of a URI identifying the current sequence.

  Specified by:
    `setURI` in interface `SeqIOListener`
  Throws:
    `ParseException`

### addSymbols

    public void addSymbols(Alphabet alpha,
                           Symbol[] syms,
                           int start,
                           int length)
                    throws IllegalAlphabetException

  Description copied from interface: `SeqIOListener`
  Notify the listener of symbol data. All symbols passed to this method are guarenteed to be contained within the specified alphabet. Generally all calls to a given Listener should have the same alphabet -- if not, the listener implementation is likely to throw an exception

  Specified by:
    `addSymbols` in interface `SeqIOListener`
  Parameters:
    `alpha` - The alphabet of the symbol data
    `syms` - An array containing symbols
    `start` - The start offset of valid data within the array
    `length` - The number of valid symbols in the array
  Throws:
    `IllegalAlphabetException` - if we can't cope with this alphabet.

### addSequenceProperty

    public void addSequenceProperty(Object key,
                                    Object value)
                             throws ParseException

  Description copied from interface: `SeqIOListener`
  Notify the listener of a sequence-wide property. This might be stored as an entry in the sequence's annotation bundle.

  Specified by:
    `addSequenceProperty` in interface `SeqIOListener`
  Throws:
    `ParseException`

### startFeature

    public void startFeature(Feature.Template templ)
                      throws ParseException

  Description copied from interface: `SeqIOListener`
  Notify the listener that a new feature object is starting. Every call to startFeature should have a corresponding call to endFeature. If the listener is concerned with a hierarchy of features, it should maintain a stack of `open' features.

  Specified by:
    `startFeature` in interface `SeqIOListener`
  Throws:
    `ParseException`

### endFeature

    public void endFeature()
                    throws ParseException

  Description copied from interface: `SeqIOListener`
  Mark the end of data associated with one specific feature.

  Specified by:
    `endFeature` in interface `SeqIOListener`
  Throws:
    `ParseException`

### addFeatureProperty

    public void addFeatureProperty(Object key,
                                   Object value)
                            throws ParseException

  Description copied from interface: `SeqIOListener`
  Notify the listener of a feature property.

  Specified by:
    `addFeatureProperty` in interface `SeqIOListener`
  Throws:
    `ParseException`

### makeSequence

    public Sequence makeSequence()
                          throws BioException

  Description copied from interface: `SequenceBuilder`
  Return the Sequence object which has been constructed by this builder. This method is only expected to succeed after the endSequence() notifier has been called.

  Specified by:
    `makeSequence` in interface `SequenceBuilder`
  Throws:
    `BioException`