## org.biojavax.bio.seq.io
Class DebuggingRichSeqIOListener

    java.lang.Object
      java.io.InputStream
          java.io.FilterInputStream
              java.io.BufferedInputStream
                  org.biojavax.bio.seq.io.DebuggingRichSeqIOListener

All Implemented Interfaces:
  Closeable, SeqIOListener, RichSeqIOListener

    public class DebuggingRichSeqIOListener

extends BufferedInputStream
implements RichSeqIOListener

This is purely for debugging purposes. Use it to wrap an input stream then pass it as a parameter to some format to listen for sequence generation events. It will dump out char-by-char what it reads, followed event-by-event the events it receives from the format.

Since:
  1.5
Author:
  Richard Holland, Mark Schreiber, Michael Heuer

Field Summary

Fields inherited from class java.io.BufferedInputStream
`buf, count, marklimit, markpos, pos`

Fields inherited from class java.io.FilterInputStream
`in`

Constructor Summary
`DebuggingRichSeqIOListener(InputStream inputStream)`

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.
`RichFeature` `getCurrentFeature()` Gets the feature currently being created.
`int` `read()`
`void` `setAccession(String accession)` Call back method so the event emitter can tell the listener the accession of the record being read.
`void` `setCircular(boolean circular)` Defined this sequence being parser as circular.
`void` `setComment(String comment)` Call back method so the event emitter can tell the listener about a comment in the record being read.
`void` `setDescription(String description)` Call back method so the event emitter can tell the listener the description of the record being read.
`void` `setDivision(String division)` Call back method so the event emitter can tell the listener the division of the record being read.
`void` `setIdentifier(String identifier)` Call back method so the event emitter can tell the listener the identifier of the record being read.
`void` `setName(String name)` Notify the listener that the current sequence is generally known by a particular name.
`void` `setNamespace(Namespace namespace)` Call back method so the event emitter can tell the listener the namespace of the record being read.
`void` `setRankedCrossRef(RankedCrossRef crossRef)` Call back method so the event emitter can tell the listener about a cross reference.
`void` `setRankedDocRef(RankedDocRef ref)` Call back method so the event emitter can tell the listener about a literature reference in the record being read.
`void` `setRelationship(BioEntryRelationship relationship)` Call back method so the event emitter can tell the listener about a relationship between the bioentry or sequence in the record being read and another bioentry.
`void` `setSeqVersion(String version)` Call back method so the event emitter can tell the listener the version of the sequence of the record being read.
`void` `setTaxon(NCBITaxon taxon)` Call back method so the event emitter can tell the listener the Taxon of the record being read.
`void` `setURI(String uri)` Notify the listener of a URI identifying the current sequence.
`void` `setVersion(int version)` Call back method so the event emitter can tell the listener the version of the record being read.
`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.io.BufferedInputStream
`available, close, mark, markSupported, read, reset, skip`

Methods inherited from class java.io.FilterInputStream
`read`

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

Constructor Detail

### DebuggingRichSeqIOListener

    public DebuggingRichSeqIOListener(InputStream inputStream)

Method Detail

### read

    public int read()
             throws IOException

  Echoes everything that is read to stdout.

  Overrides:
    `read` in class `BufferedInputStream`
  Throws:
    `IOException`

### setAccession

    public void setAccession(String accession)
                      throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the accession of the record being read. It is possible that some records have more than one accession. As a guide the first one sent to the listener should be the primary one.

  Specified by:
    `setAccession` in interface `RichSeqIOListener`
  Parameters:
    `accession` - The accession of the record
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.
  See Also:
    `SeqIOListener.setName(String name)`, `RichSeqIOListener.setURI(String uri)`, `RichSeqIOListener.setIdentifier(String identifier)`

### setIdentifier

    public void setIdentifier(String identifier)
                       throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the identifier of the record being read. There should be zero or one identifier per bioentry. If there is more than one the Listener should consider throwing an exception. For some formats like fasta the identifier may not exist. For others like GenBank the identifier best maps to the GI.

  Specified by:
    `setIdentifier` in interface `RichSeqIOListener`
  Parameters:
    `identifier` - The identifier of the Bioentry.
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.
  See Also:
    `SeqIOListener.setName(String name)`, `RichSeqIOListener.setAccession(String accession)`, `RichSeqIOListener.setURI(String uri)`

### setDivision

    public void setDivision(String division)
                     throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the division of the record being read. If the source of the calls back is a GenBank parser the division will be a Genbank division. This method would typically be called 0 or 1 times. It should not be called more than once per entry and an exception could be thrown if it is.

  Specified by:
    `setDivision` in interface `RichSeqIOListener`
  Parameters:
    `division` - The division the entry belongs too.
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setDescription

    public void setDescription(String description)
                        throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the description of the record being read. For example the description line of a FASTA format file would be the description. This method would typically be called 0 or 1 times and may cause an exception if it is called more than once per entry.

  Specified by:
    `setDescription` in interface `RichSeqIOListener`
  Parameters:
    `description` - The description of the record
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setVersion

    public void setVersion(int version)
                    throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the version of the record being read. This method would typically be called 0 or 1 times per entry. If it is not called the Listener should assume the version is 0. If it is called more than once per entry an exception should be thrown.

  Specified by:
    `setVersion` in interface `RichSeqIOListener`
  Parameters:
    `version` - the version of the record
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setSeqVersion

    public void setSeqVersion(String version)
                       throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the version of the sequence of the record being read. This method would typically be called 0 or 1 times per entry. If it is not called the Listener should assume the version is 0. If it is called more than once per entry an exception should be thrown.

  Specified by:
    `setSeqVersion` in interface `RichSeqIOListener`
  Parameters:
    `version` - the version of the record
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setComment

    public void setComment(String comment)
                    throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener about a comment in the record being read. The comment is typically one or more comment lines relevant to the record as a whole and bundled in a Commment object. This method may be called zero or one times per entry. It can be called zero or more times.

  Specified by:
    `setComment` in interface `RichSeqIOListener`
  Parameters:
    `comment` - The comment
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setRankedDocRef

    public void setRankedDocRef(RankedDocRef ref)
                         throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener about a literature reference in the record being read. This method may be called zero or more times.

  Specified by:
    `setRankedDocRef` in interface `RichSeqIOListener`
  Parameters:
    `ref` - A literature reference contained in the entry.
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setTaxon

    public void setTaxon(NCBITaxon taxon)
                  throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the Taxon of the record being read. This method may be called zero or one times. An exception may be thrown if it is called more than once. As a design decision NCBI's taxon model was chosen as it is commonly used and is supported by the BioSQL schema. The setting of an NCBI taxon should be considered entirely optional.

  Specified by:
    `setTaxon` in interface `RichSeqIOListener`
  Parameters:
    `taxon` - The taxon information relevant to this entry.
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setNamespace

    public void setNamespace(Namespace namespace)
                      throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener the namespace of the record being read. The method can be called zero or one time. If it is called more than once an exception may be thrown.

  The namespace is a concept from the BioSQL schema that enables Bioentries to be disambiguated. It is possible in BioSQL and should be possible in other collections of BioEntries to have records that have the same name, accession and version but different namespaces. This method would be expected to be called if you are reading a sequence from a biosql database or if you are implementing a listener that knows how to write to a biosql database. If you give a sequence a namespace and it is persited to biosql at somepoint in it's life you could expect it to be persisted to that namespace (if possible).

  Specified by:
    `setNamespace` in interface `RichSeqIOListener`
  Parameters:
    `namespace` - The namespace of the entry.
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setRelationship

    public void setRelationship(BioEntryRelationship relationship)
                         throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener about a relationship between the bioentry or sequence in the record being read and another bioentry. This may be called zero or more times.

  Specified by:
    `setRelationship` in interface `RichSeqIOListener`
  Parameters:
    `relationship` - The relationship
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### setRankedCrossRef

    public void setRankedCrossRef(RankedCrossRef crossRef)
                           throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Call back method so the event emitter can tell the listener about a cross reference. This could be called zero or more times per entry.

  Specified by:
    `setRankedCrossRef` in interface `RichSeqIOListener`
  Parameters:
    `crossRef` - the cross reference
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### 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`
  Specified by:
    `setURI` in interface `RichSeqIOListener`
  Throws:
    `ParseException`

### getCurrentFeature

    public RichFeature getCurrentFeature()
                                  throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Gets the feature currently being created.

  Specified by:
    `getCurrentFeature` in interface `RichSeqIOListener`
  Returns:
    the feature under construction.
  Throws:
    `ParseException` - if a feature is not currently being created.

### setCircular

    public void setCircular(boolean circular)
                     throws ParseException

  Description copied from interface: `RichSeqIOListener`
  Defined this sequence being parser as circular. It is best to call this as early as possible during parsing. It should definitely be called before doing anything with locations or features.

  Specified by:
    `setCircular` in interface `RichSeqIOListener`
  Parameters:
    `circular` - set this to true if you want it to be circular.
  Throws:
    `ParseException` - If the Listener cannot understand the event, is unable to deal with the event or is not expecting the event.

### 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`

### 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`