Bio::Factory
SequenceProcessorI
Toolbar
Summary
Bio::Factory::SequenceProcessorI - Interface for chained sequence
processing algorithms
Package variables
No package variables defined.
Included modules
Inherit
Synopsis
use Bio::SeqIO;
use MySeqProcessor; # is-a Bio::Factory::SequenceProcessorI
# obtain your source stream, e.g., an EMBL file
my $seqin = Bio::SeqIO->new(-fh => \*STDIN, -format => 'embl');
# create your processor (it must implement this interface)
my $seqalgo = MySeqProcessor->new();
# chain together
$seqalgo->source_stream($seqin);
# you could create more processors and chain them one after another
# ...
# finally, the last link in the chain is your SeqIO stream
my $seqpipe = $seqalgo;
# once you've established the pipeline, proceed as if you had a
# single SeqIO stream
while(my $seq = $seqpipe->next_seq()) {
# ... do something ...
}
Description
This defines an interface that allows seamless chaining of sequence
processing algorithms encapsulated in modules while retaining the
overall Bio::SeqIO interface at the end of the pipeline.
This is especially useful if you want an easily configurable
processing pipeline of re-usable algorithms as building blocks instead
of (hard-)coding the whole algorithm in a single script.
There are literally no restrictions as to what an individual module
can do with a sequence object it obtains from the source stream before
it makes it available through its own next_seq() method. It can
manipulate the sequence object, but otherwise keep it intact, but it
can also create any number of new sequence objects from it, or it can
discard some, or any combination thereof. The only requirement is that
its next_seq() method return Bio::PrimarySeqI compliant objects. In
order to play nice, if a processor creates new objects it should try
to use the same sequence factory that the source stream uses, but this
is not strongly mandated.
Methods
Methods description
Title : source_stream
Usage : $obj->source_stream($newval)
Function: Get/set the source sequence stream for this sequence
processor.
An implementation is not required to allow set, but will
usually do so.
Example :
Returns : A Bio::Factory::SequenceStreamI compliant object
Args : on set, new value (a Bio::Factory::SequenceStreamI compliant
object) |
Methods code
sub source_stream
{ shift->throw_not_implemented(); } | General documentation
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/MailList.shtml - About the mailing lists
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
email or the web:
bioperl-bugs@bioperl.org
http://bioperl.org/bioperl-bugs/
Email hlapp at gmx.net
Describe contact details here
Additional contributors names and emails here
The rest of the documentation details each of the object methods.
Internal methods are usually preceded with a _
| Bio::Factory::SequenceStreamI methods | Top |
The requirement to implement these methods is inherited from
Bio::Factory::SequenceStreamI. An implementation may not
necessarily have to implement all methods in a meaningful way. Which
methods will be necessary very much depends on the context in which
an implementation of this interface is used. E.g., if it is only used
for post-processing sequences read from a SeqIO stream, write_seq()
will not be used and hence does not need to be implemented in a
meaningful way (it may in fact even throw an exception).
Also, since an implementor will already receive built objects from a
sequence stream, sequence_factory() may or may not be relevant,
depending on whether the processing method does or does not involve
creating new objects.
Title : next_seq
Usage : $seq = stream->next_seq
Function: Reads the next sequence object from the stream and returns it.
In the case of a non-recoverable situation an exception
will be thrown. Do not assume that you can resume parsing
the same stream after catching the exception. Note that you
can always turn recoverable errors into exceptions by
calling $stream->verbose(2).
Returns : a Bio::Seq sequence object
Args : none
See
Bio::Root::RootI Title : write_seq
Usage : $stream->write_seq($seq)
Function: writes the $seq object into the stream
Returns : 1 for success and 0 for error
Args : Bio::Seq object
Title : sequence_factory
Usage : $seqio->sequence_factory($seqfactory)
Function: Get the Bio::Factory::SequenceFactoryI
Returns : Bio::Factory::SequenceFactoryI
Args : none