NAME

Bio::Seq::BaseSeqProcessor - Base implementation for a SequenceProcessor

SYNOPSIS

# you need to derive your own processor from this one

DESCRIPTION

This provides just a basic framework for implementations of Bio::Factory::SequenceProcessorI.

Essentially what it does is support a parameter to new() to set sequence factory and source stream, and a next_seq() implementation that will use a queue to be filled by a class overriding process_seq().

FEEDBACK

Mailing Lists

User feedback is an integral part of the evolution of this and other Bioperl modules. Send your comments and suggestions preferably to the Bioperl mailing list. Your participation is much appreciated.

bioperl-l@bioperl.org                  - General discussion
http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

Reporting Bugs

Report bugs to the Bioperl bug tracking system to help us keep track of the bugs and their resolution. Bug reports can be submitted via the web:

http://bugzilla.open-bio.org/

AUTHOR - Hilmar Lapp

Email hlapp at gmx.net

APPENDIX

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

new

Title   : new
Usage   : my $obj = new Bio::Seq::BaseSeqProcessor();
Function: Builds a new Bio::Seq::BaseSeqProcessor object 
Returns : an instance of Bio::Seq::BaseSeqProcessor
Args    : Named parameters. Currently supported are
            -seqfactory  the Bio::Factory::SequenceFactoryI object to use
            -source_stream the Bio::Factory::SequenceStreamI object to
                         which we are chained

Bio::Factory::SequenceProcessorI methods

source_stream

Title   : source_stream
Usage   : $obj->source_stream($newval)
Function: Get/set the source sequence stream for this sequence
          processor.

Example : 
Returns : A Bio::Factory::SequenceStreamI compliant object
Args    : on set, new value (a Bio::Factory::SequenceStreamI compliant
          object)

Bio::Factory::SequenceStreamI methods

next_seq

Title   : next_seq
Usage   : $seq = stream->next_seq
Function: Reads the next sequence object from the stream and returns it.

          This implementation will obtain objects from the source
          stream as necessary and pass them to process_seq() for
          processing. This method will return the objects one at a
          time that process_seq() returns.

Returns : a Bio::Seq sequence object
Args    : none

See Bio::Factory::SequenceStreamI::next_seq

write_seq

Title   : write_seq
Usage   : $stream->write_seq($seq)
Function: Writes the result(s) of processing the sequence object into
          the stream.

          You need to override this method in order not to alter
          (process) sequence objects before output.

Returns : 1 for success and 0 for error. The method stops attempting
          to write objects after the first error returned from the
          source stream. Otherwise the return value is the value
          returned from the source stream from writing the last
          object resulting from processing the last sequence object
          given as argument.

Args    : Bio::SeqI object, or an array of such objects

sequence_factory

Title   : sequence_factory
Usage   : $seqio->sequence_factory($seqfactory)
Function: Get the Bio::Factory::SequenceFactoryI
Returns : Bio::Factory::SequenceFactoryI
Args    : none

object_factory

Title   : object_factory
Usage   : $obj->object_factory($newval)
Function: This is an alias to sequence_factory with a more generic name.
Example : 
Returns : a L<Bio::Factory::ObjectFactoryI> compliant object
Args    : on set, new value (a L<Bio::Factory::ObjectFactoryI> 
          compliant object or undef, optional)

close

Title   : close
Usage   :
Function: Closes the stream. We override this here in order to cascade
          to the source stream.
Example :
Returns : 
Args    : none

To be overridden by a derived class

process_seq

Title   : process_seq
Usage   :
Function: This is the method that is supposed to do the actual
          processing. It needs to be overridden to do what you want
          it to do.

          Generally, you do not have to override or implement any other
          method to derive your own sequence processor.

          The implementation provided here just returns the unaltered
          input sequence and hence is not very useful other than
          serving as a neutral default processor.

Example :
Returns : An array of zero or more Bio::PrimarySeqI (or derived
          interface) compliant object as the result of processing the
          input sequence.
Args    : A Bio::PrimarySeqI (or derived interface) compliant object
          to be processed.

cpanm Bio::Seq

perl -MCPAN -e shell
install Bio::Seq