Provided by: libbio-perl-perl_1.7.2-2_all bug


       Bio::AlignIO::Handler::GenericAlignHandler - Bio::HandlerI-based generic data handler
       class for alignment-based data


         # MyHandler is a GenericAlignHandler object.
         # inside a parser (driver) constructor....

         $self->alignhandler($handler || MyHandler->new(-format => 'stockholm'));

         # in next_aln() in driver...

         $hobj = $self->alignhandler();

         # roll data up into hashref chunks, pass off into Handler for processing...


         # or retrieve Handler methods and pass data directly to Handler methods...

         my $hmeth = $hobj->handler_methods;

         if ($hmeth->{ $data->{NAME} }) {
             my $mth = $hmeth->{ $data->{NAME} };


       This is an experimental implementation of a alignment-based HandlerBaseI parser and may
       change over time. It is possible that the way handler methods are set up will change over
       development to allow more flexibility.

       Standard Developer caveats:

       Here thar be dragoons...

       Consider yourself warned!

       As in the SeqIO Handler object (still in development), data is passed in as chunks. The
       Annotation and SeqFeatures are essentially the same as the SeqIO parser; the significant
       difference is that data hash being passed could pertain to either the alignment or to a
       specific sequence, so an extra tag may be needed to disambiguate between the two in some
       cases. Here I use the ALIGNMENT tag as a boolean flag: it must be present and set to 0 for
       the data to be tagged for Bio::LocatableSeq or similar (in all other cases it is assumed
       to be for the alignment). In some cases this will not matter (the actual sequence data,
       for instance) but it is highly recommmended adding this tag in to prevent possible

       This is the current Annotation data chunk (via Data::Dumper):

         $VAR1 = {
                   'NAME' => 'REFERENCE',
                   'DATA' => '1  (bases 1 to 10001)'
                   'AUTHORS' => 'International Human Genome Sequencing Consortium.'
                   'TITLE' => 'The DNA sequence of Homo sapiens'
                   'JOURNAL' => 'Unpublished (2003)'
                   'ALIGNMENT' => 1,

       In the case of LocatableSeqs, one can pass them in as follows for simplicity (note the
       block line):

         $VAR1 = {
                   'NAME' => 'SEQUENCE',
                   'BLOCK_LINE' => 0,
                   'NSE' => 'Q7WNI7_BORBR/113-292',
                   'ALPHABET' => 'protein',
                   'DATA' => 'VALILGVYRRL...CYVNREM..RAG....QW',
                   'ALIGNMENT' => 0

       This can be done as the parser parses each block instead of parsing all the blocks and
       then passing them in one at a time; the handler will store the sequence data by the block
       line in an internal hash, concatenating them along the way.  This behaviour is b/c the
       alignment building step requires that the sequence be checked for start/end/strand,
       possible meta sequence, optional accession, etc.

       Similarly, a Meta sequence line can be passed in as follows:

         $VAR1 = {
                   'NAME' => 'NAMED_META',
                   'BLOCK_LINE' => 0,
                   'NSE' => 'Q7WNI7_BORBR/113-292',
                   'META_KEY' => 'pAS',
                   'DATA' => '................................',
                   'ALIGNMENT' => 0

       The meta sequence will be checked against the NSE for the block position and stored based
       on the meta tag. A meta sequence does not have to correspond to a real sequence. At this
       time, unique meta sequence tags must be used for each sequence or they will be overwritten
       (this may change).

       An alignment consensus string:

         $VAR1 = {
                   'NAME' => 'CONSENSUS',
                   'DATA' => 'VALILGVYRRL...CYVNREM..RAG....QW',
                   'ALIGNMENT' => 1

       A consensus meta sequence:

         $VAR1 = {
                   'NAME' => 'CONSENSUS_META',
                   'META_KEY' => 'pAS',
                   'DATA' => '................................',
                   'ALIGNMENT' => 1


   Mailing Lists
       User feedback is an integral part of the evolution of this and other Bioperl modules. Send
       your comments and suggestions preferably to one of the Bioperl mailing lists.  Your
       participation is much appreciated.
                  - General discussion  - About the mailing lists

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

       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 the bugs and their
       resolution.  Bug reports can be submitted via the web:

AUTHOR - Chris Fields

       Email cjfields at bioperl dot org


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

        Title   :  new
        Usage   :
        Returns :
        Args    :  -format    Sequence format to be mapped for handler methods
                   -builder   Bio::Seq::SeqBuilder object (normally defined in
                              SequenceStreamI object implementation constructor)
        Throws  :  On undefined '-format' sequence format parameter
        Note    :  Still under heavy development

Bio::HandlerBaseI implementing methods

        Title   :  handler_methods
        Usage   :  $handler->handler_methods('GenBank')
                   %handlers = $handler->handler_methods();
        Function:  Retrieve the handler methods used for the current format() in
                   the handler.  This assumes the handler methods are already
                   described in the HandlerI-implementing class.
        Returns :  a hash reference with the data type handled and the code ref
                   associated with it.
        Args    :  [optional] String representing the sequence format.  If set here
                   this will also set sequence_format()
        Throws  :  On unimplemented sequence format in %HANDLERS

        Title   :  data_handler
        Usage   :  $handler->data_handler($data)
        Function:  Centralized method which accepts all data chunks, then distributes
                   to the appropriate methods for processing based on the chunk name
                   from within the HandlerBaseI object.

                   One can also use
        Returns :  None
        Args    :  an hash ref containing a data chunk.

        Title   :  reset_parameters
        Usage   :  $handler->reset_parameters()
        Function:  Resets the internal cache of data (normally object parameters for
                   a builder or factory)
        Returns :  None
        Args    :  None

        Title   :  format
        Usage   :  $handler->format('GenBank')
        Function:  Get/Set the format for the report/record being parsed. This can be
                   used to set handlers in classes which are capable of processing
                   similar data chunks from multiple driver modules.
        Returns :  String with the sequence format
        Args    :  [optional] String with the sequence format
        Note    :  The format may be used to set the handlers (as in the
                   current GenericRichSeqHandler implementation)

        Title   :  get_params
        Usage   :  $handler->get_params('-species')
        Function:  Convenience method used to retrieve the specified
                   parameters from the internal parameter cache
        Returns :  Hash ref containing parameters requested and data as
                   key-value pairs.  Note that some parameter values may be
                   objects, arrays, etc.
        Args    :  List (array) representing the parameters requested

        Title   :  set_params
        Usage   :  $handler->set_param({'-seqs' => $seqs})
        Function:  Convenience method used to set specific parameters
        Returns :  None
        Args    :  Hash ref containing the data to be passed as key-value pairs

Methods unique to this implementation

        Title   :  build_alignment
        Usage   :
        Returns :  a Bio::SimpleAlign
        Args    :
        Throws  :
        Note    :  This may be replaced by a Builder object at some point

        Title   :  annotation_collection
        Usage   :
        Returns :
        Args    :
        Throws  :
        Note    :

        Title   :  seq_annotation_collection
        Usage   :
        Returns :
        Args    :
        Throws  :
        Note    :

        Title   :  process_seqs
        Usage   :  $handler->process_seqs;
        Function:  checks internal sequences to ensure they are converted over
                   to the proper Bio::AlignI-compatible sequence class
        Returns :  1 if successful
        Args    :  none

perl v5.26.1                                2017-1Bio::AlignIO::Handler::GenericAlignHandler(3pm)