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

NAME

       Bio::SeqIO::Handler::GenericRichSeqHandler - Bio::HandlerI-based data handler for
       GenBank/EMBL/UniProt (and other) sequence data

SYNOPSIS

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

         $self->seq_handler($handler || MyHandler->new(-format => 'genbank'));

         # in next_seq() in driver...

         $hobj = $self->seqhandler();

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

         $hobj->data_handler($data);

         # 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} };
             $hobj->$mth($data);
         }

DESCRIPTION

       This is an experimental implementation of a sequence-based HandlerBaseI parser and may
       change over time. It is possible (nay, likely) that the way handler methods are set up
       will change over development to allow more flexibility.  Release pumpkins, please do not
       add this to a release until the API has settled.  It is also likely that write_seq() will
       not work properly for some data.

       Standard Developer caveats:

       Do not use for production purposes.  Not responsible for destroying (your
       data|computer|world).  Do not stare directly at GenericRichSeqHandler.  If
       GenericRichSeqHandler glows, back slowly away and call for help.

       Consider yourself warned!

       This class acts as a demonstration on how to handle similar data chunks derived from
       Bio::SeqIO::gbdriver, Bio::SeqIO::embldriver, and Bio::SeqIO::swissdriver using similar
       (or the same) handler methods.

       The modules currently pass all previous tests in t/genbank.t, t/embl.t, and t/swiss.t yet
       all use the same handler methods (the collected tests for handlers can be found in
       t/Handler.t). Some tweaking of the methods themselves is probably in order over the long
       run to ensure that data is consistently handled for each parser.  Round-trip tests are
       probably in order here...

       Though a Bio::Seq::SeqBuilder is employed for building sequence objects no bypassing of
       data based on builder slots has been implemented (yet); this is planned in the near
       future.

       As a reminder: 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)'
                 };
         ...

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

         $VAR1 = {
                   'mol_type' => 'genomic DNA',
                   'LOCATION' => '<1..>10001',
                   'NAME' => 'FEATURES',
                   'FEATURE_KEY' => 'source',
                   'note' => 'Accession AL451081 sequenced by The Sanger Centre',
                   'db_xref' => 'taxon:9606',
                   'clone' => 'RP11-302I18',
                   'organism' => 'Homo sapiens'
                 };

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

         https://redmine.open-bio.org/projects/bioperl/

AUTHOR - Chris Fields

       Email cjfields at bioperl dot org

APPENDIX

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

   new
        Title   :  new
        Usage   :
        Function:
        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

   handler_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

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

   reset_parameters
        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

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

   get_params
        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

   set_params
        Title   :  set_params
        Usage   :  $handler->set_param({'-species')
        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

   seqbuilder
        Title   :  seqbuilder
        Usage   :
        Function:
        Returns :
        Args    :
        Throws  :
        Note    :

   build_sequence
        Title   :  build_sequence
        Usage   :
        Function:
        Returns :
        Args    :
        Throws  :
        Note    :

   location_factory
        Title   :  location_factory
        Usage   :
        Function:
        Returns :
        Args    :
        Throws  :
        Note    :

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

perl v5.14.2                                2011-1Bio::SeqIO::Handler::GenericRichSeqHandler(3pm)