Bio::Factory::SequenceProcessorI man page on Fedora

Man page or keyword search:  
man Server   31170 pages
apropos Keyword Search (all sections)
Output format
Fedora logo
[printable version]

Bio::Factory::SequenceUsereContributed PerlBio::Factory::SequenceProcessorI(3)

NAME
       Bio::Factory::SequenceProcessorI - Interface for chained sequence
					  processing algorithms

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.

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

   Support
       Please direct usage questions or support issues to the mailing list:

       bioperl-l@bioperl.org

       rather than to the module maintainer directly. Many experienced and
       reponsive experts will be able look at the problem and quickly address
       it. Please include a thorough description of the problem with code and
       data examples if at all possible.

   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 _

   source_stream
	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)

Bio::Factory::SequenceStreamI methods
	The requirement to implement these methods is inherited from
	L<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.

   next_seq
	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

   write_seq
	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

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

perl v5.14.1			  2011-07-2Bio::Factory::SequenceProcessorI(3)
[top]

List of man pages available for Fedora

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net