Bio::S...cessor(3pm)

🌸 NAME 🌸

Bio::Seq::BaseSeqProcessor — the base implementation for a SequenceProcessor, bestie. It's giving "starter pack" but make it Perl. 💅

---

✨ SYNOPSIS ✨

    # you need to derive your own processor from this one

ok so real talk: you literally cannot just use this thing as-is. You gotta subclass it, periodt. 💀

---

💖 DESCRIPTION 💖

So this module is just a basic framework, right? A lil skeleton 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(). That's the whole vibe. 🎀

---

🫶 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. (no cap, they genuinely want to hear from you 💜)

  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.

fr fr, skip the DMs and go straight to the group chat — that's where the geniuses are. 🧚

🐛 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:

https://github.com/bioperl/bioperl-live/issues

---

👑 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 _ (iykyk 🔥).

🌸 new

Title   : new
Usage   : my $obj = Bio::Seq::BaseSeqProcessor->new();
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

builds the lil guy. you hand it named args, it hands you an object. iconic behavior. ✨

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

get it, set it, slay. the source stream for this processor is right there. 💅

🦋 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

it grabs objects from the source stream as needed, yeets them into process_seq(), and hands them back to you one at a time. no args needed, it just knows. 🔥

🌟 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

heads up bestie: you HAVE to override this one if you don't want your sequence objects getting altered (aka processed) before output. don't skip that step. 🙈

returns 1 for success, 0 for error. once the source stream throws an error, it stops trying to write — like, it's done. otherwise you get back whatever the source stream returned from writing the last object that came out of processing the last sequence object you passed in. and yeah, you can pass one Bio::SeqI object or an array of them. 🫶

🌈 sequence_factory

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

just gets you the Bio::Factory::SequenceFactoryI. no args, no drama. 💖

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

it's literally just sequence_factory wearing a more generic name. same energy, different label. on set you can pass a Bio::Factory::ObjectFactoryI compliant object, or undef, and that arg is 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

closes the stream — and we override it here specifically so it cascades down to the source stream too. chain reaction, main character energy. 👑

🧚 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.

ok so THIS is the one. the actual processing happens here, and you gotta override it to make it do the thing you want. the good news? generally you don't have to override or implement any other method to derive your own sequence processor. one method, that's the whole assignment. 🫶

the version shipped here just hands back your input sequence completely unaltered, so honestly it's not very useful — it's just a neutral default processor, a vibe, a placeholder. 💀

it returns an array of zero or more Bio::PrimarySeqI (or derived interface) compliant objects as the result of processing the input sequence, and it takes a Bio::PrimarySeqI (or derived interface) compliant object to be processed as its arg. ✨

---

and that's the whole page, bestie!! 🎀 this doc came to you courtesy of perl v5.32.1, dated 2021-08-15, and the page itself is Bio::S...cessor(3pm). go forth and subclass responsibly. mwah 💋💖