Provided by: libbio-perl-run-perl_1.7.1-3_all bug


       Bio::Tools::Run::WrapperBase - A Base object for wrappers around executables


         # do not use this object directly, it provides the following methods
         # for its subclasses

         my $errstr = $obj->error_string();
         my $exe    = $obj->executable();
         my $outfile= $obj->outfile_name();
         my $tempdir= $obj->tempdir(); # get a temporary dir for executing
         my $io     = $obj->io;  # Bio::Root::IO object
         my $cleanup= $obj->cleanup(); # remove tempfiles

         $obj->run({-arg1 => $value});


       This is a basic module from which to build executable wrapper modules.  It has some basic
       methods to help when implementing new modules.


   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:

AUTHOR - Jason Stajich



       Sendu Bala,


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

        Title   : run
        Usage   : $wrapper->run({ARGS HERE});
        Function: Support generic running with args passed in
                  as a hashref
        Returns : Depends on the implementation, status OR data
        Args    : hashref of named arguments

        Title   : error_string
        Usage   : $obj->error_string($newval)
        Function: Where the output from the last analysis run is stored.
        Returns : value of error_string
        Args    : newvalue (optional)

        Title   : arguments
        Usage   : $obj->arguments($newval)
        Function: Commandline parameters
        Returns : value of arguments
        Args    : newvalue (optional)

        Title   : no_param_checks
        Usage   : $obj->no_param_checks($newval)
        Function: Boolean flag as to whether or not we should
                  trust the sanity checks for parameter values
        Returns : value of no_param_checks
        Args    : newvalue (optional)

        Title   : save_tempfiles
        Usage   : $obj->save_tempfiles($newval)
        Function: Get/set the choice of if tempfiles in the temp dir (see tempdir())
                  are kept or cleaned up. Default is '0', ie. delete temp files.
                  NB: This must be set to the desired value PRIOR to first creating
                  a temp dir with tempdir(). Any attempt to set this after tempdir creation will get a warning.
        Returns : boolean
        Args    : none to get, boolean to set

        Title   : outfile_name
        Usage   : my $outfile = $wrapper->outfile_name();
        Function: Get/Set the name of the output file for this run
                  (if you wanted to do something special)
        Returns : string
        Args    : [optional] string to set value to

        Title   : tempdir
        Usage   : my $tmpdir = $self->tempdir();
        Function: Retrieve a temporary directory name (which is created)
        Returns : string which is the name of the temporary directory
        Args    : none

        Title   : cleanup
        Usage   : $wrapper->cleanup();
        Function: Will cleanup the tempdir directory
        Returns : none
        Args    : none

        Title   : io
        Usage   : $obj->io($newval)
        Function: Gets a Bio::Root::IO object
        Returns : Bio::Root::IO object
        Args    : none

        Title   : version
        Usage   : $version = $wrapper->version()
        Function: Returns the program version (if available)
        Returns : string representing version of the program
        Args    : [Optional] value to (re)set version string

        Title   : executable
        Usage   : my $exe = $factory->executable();
        Function: Finds the full path to the executable
        Returns : string representing the full path to the exe
        Args    : [optional] name of executable to set path to
                  [optional] boolean flag whether or not warn when exe is not found

        Title   : program_path
        Usage   : my $path = $factory->program_path();
        Function: Builds path for executable
        Returns : string representing the full path to the exe
        Args    : none

        Title   : program_dir
        Usage   : my $dir = $factory->program_dir();
        Function: Abstract get method for dir of program. To be implemented
                  by wrapper.
        Returns : string representing program directory
        Args    : none

        Title   : program_name
        Usage   : my $name = $factory->program_name();
        Function: Abstract get method for name of program. To be implemented
                  by wrapper.
        Returns : string representing program name
        Args    : none

        Title   : quiet
        Usage   : $factory->quiet(1);
                  if ($factory->quiet()) { ... }
        Function: Get/set the quiet state. Can be used by wrappers to control if
                  program output is printed to the console or not.
        Returns : boolean
        Args    : none to get, boolean to set

        Title   : _setparams
        Usage   : $params = $self->_setparams(-params => [qw(window evalue_cutoff)])
        Function: For internal use by wrapper modules to build parameter strings
                  suitable for sending to the program being wrapped. For each method
                  name supplied, calls the method and adds the method name (as modified
                  by optional things) along with its value (unless a switch) to the
                  parameter string
        Example : $params = $self->_setparams(-params => [qw(window evalue_cutoff)],
                                              -switches => [qw(simple large all)],
                                              -double_dash => 1,
                                              -underscore_to_dash => 1);
                  If window() and simple() had not been previously called, but
                  evalue_cutoff(0.5), large(1) and all(0) had been called, $params
                  would be ' --evalue-cutoff 0.5 --large'
        Returns : parameter string
        Args    : -params => [] or {}  # array ref of method names to call,
                                         or hash ref where keys are method names and
                                         values are how those names should be output
                                         in the params string
                  -switches => [] or {}# as for -params, but no value is printed for
                                         these methods
                  -join => string      # define how parameters and their values are
                                         joined, default ' '. (eg. could be '=' for
                  -lc => boolean       # lc() method names prior to output in string
                  -dash => boolean     # prefix all method names with a single dash
                  -double_dash => bool # prefix all method names with a double dash
                  -mixed_dash => bool  # prefix single-character method names with a
                                       # single dash, and multi-character method names
                                       # with a double-dash
                  -underscore_to_dash => boolean # convert all underscores in method
                                                   names to dashes