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


       Bio::SimpleAnalysisI - A simple interface to any (local or remote) analysis tool


       This is an interface module - you do not instantiate it.  Use other modules instead (those
       that implement this interface).


       This interface contains public methods for accessing and controlling local and remote
       analysis tools. It is meant to be used on the client side. The interface consists only of
       a necessary set of methods for synchronous invocation of analysis tools. For more complex
       set, including an asynchronous access, see interface "Bio::AnalysisI" (which inherits from
       this one, by the way).


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


       Martin Senger (


       Copyright (c) 2003, Martin Senger and EMBL-EBI.  All Rights Reserved.

       This module is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself.


       This software is provided "as is" without warranty of any kind.




       This is actually the main documentation...

       If you try to call any of these methods directly on this "Bio::SimpleAnalysisI" object you
       will get a not implemented error message.

        Usage   : $tool->analysis_name;
        Returns : a name of this analysis
        Args    : none

        Usage   : $tool->analysis_spec;
        Returns : a hash reference describing this analysis
        Args    : none

       The returned hash reference uses the following keys (not all of them always present,
       perhaps others present as well): "name", "type", "version", "supplier", "installation",

        Usage   : $tool->input_spec;
        Returns : an array reference with hashes as elements
        Args    : none

       The analysis input data are named, and can be also associated with a default value, with
       allowed values and with few other attributes. The names are important for feeding the
       analysis with the input data (the inputs are given to methods "run" and "wait_for" as
       name/value pairs).

        Usage   : $tool->result_spec;
        Returns : a hash reference with result names as keys
                  and result types as values
        Args    : none

       An analysis can produce several results, or the same result in several different formats.
       All such results are named and can be retrieved using their names by metod "result".

       Here is an example of the result specification:

         $result_spec = {
                 'outseq' => 'String',
                 'report' => 'String',
                 'detailed_status' => 'String'

        Usage   : $tool->run ( ['sequence=@my.seq', 'osformat=embl'] )
        Returns : $self
        Args    : data and parameters for this execution
                  (in various formats)

       Create a job, start it, and wait for its completion. The method is identical to the method
       "wait_for". Why there are two methods doing the same? Because it is expected that the sub-
       classes may implement them differently (an example is an interface "Bio::AnalysisI" which
       uses method "run" for an asynchronous execution and method "wait_for" for a synchronous

       Usually, after this call, you ask for results of the finished job:

           $analysis->run (...)->result;

       The input data and prameters for this execution can be specified in various ways:

       array reference
           The array has scalar elements of the form

              name = [[@]value]

           where "name" is the name of an input data or input parameter (see method "input_spec"
           for finding what names are recognized by this analysis) and "value" is a value for
           this data/parameter. If "value" is missing a 1 is assumed (which is convenient for the
           boolean options). If "value" starts with "@" it is treated as a local filename, and
           its contents is used as the data/parameter value.

       hash reference
           The same as with the array reference but now there is no need to use an equal sign.
           The hash keys are input names and hash values their data. The values can again start
           with a "@" sign indicating a local filename.

        Usage   : $tool->wait_for ( { 'sequence' => '@my,file' } )
        Returns : $self
        Args    : the same as for method 'run'

       Create a job, start it and wait for its completion. The method is identical to the method
       "run". See details in the "run" method.

        Usage   : $tool->status
        Returns : string describing a status of the execution
        Args    : none

       It returns one of the following strings (and perhaps more if a server implementation
       extended possible job states):

          CREATED              (not run yet)
          COMPLETED            (run and finished normally)
          TERMINATED_BY_ERROR  (run and finished with an error or a signal)

        Usage   : $job->result (...)
        Returns : a result created by running an analysis
        Args    : none (but an implementation may choose
                  to add arguments for instructions how to process
                  the raw result)

       The method returns a scalar representing a result of an executed job. If the job was
       terminated by an error the result may contain an error message instead of the real data
       (or both, depending on the implementation).