Bio::EnsEMBL::Analysis::RunnableDB::BestTargetted

  my $db      = Bio::EnsEMBL::DBAdaptor->new($locator);
  my $cond = Bio::EnsEMBL::Analysis::RunnableDB::BestTargetted
    ->new (-db         => $pipelinedb,
           -input_id   => $input_id
           -analysis   => $analysis );
  $cond->fetch_input();
  $cond->run();
  $cond->write_output();

  This module acts as an intermediate between the runnable and the
  core database. It reads configuration and uses information from the analysis
  object to setup the runnable and then write the results back to the 
  database specified in the config file.

  my ($self,$value) = @_;

  if (defined $value) {
    $self->{_biotypes} = $value;
  }
  return $self->{_biotypes};

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_dbname} = $value;
  }
  return $self->{_dbname};

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_exon_prog} = $value;
  }
  return $self->{_exon_prog};

  my ($self,$value) = @_;

  if (defined $value) {
    $self->{_input_data_from_dbs} = $value;
  }
  return $self->{_input_data_from_dbs};

  my ($self,$value) = @_;

  if (defined $value) {
    $self->{_keep_single_analysis} = $value;
  }
  return $self->{_keep_single_analysis};
}

1;

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_outdb_name} = $value;
  }
  return $self->{_outdb_name};

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_seqfetcher_dir} = $value;
  }
  return $self->{_seqfetcher_dir};

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_seqfetcher_object} = $value;
  }
  return $self->{_seqfetcher_object};

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_verbose} = $value;
  }
  return $self->{_verbose};

  
  my ($self) = @_;

  $self->throw("No input id") unless defined($self->input_id);
  
  my $dnadb = $self->get_dbadaptor('REFERENCE_DB');
  my $db = $self->get_dbadaptor($self->DB_NAME);
  $db->dnadb($dnadb);
  
  my $slice = $self->fetch_sequence($self->input_id, $db);
  $self->query($slice);
 
  my @genes; 
  my @all_bt_for_clustering;  

  # fetch genes from different databases  
  foreach my $db_alias ( keys  %{ $self->INPUT_DATA_FROM_DBS } ) { 
     print "fetching out of DB : " . $db_alias ." : " ;  
     my @biotypes_to_fetch = @{${$self->INPUT_DATA_FROM_DBS }{$db_alias}};
     for ( @biotypes_to_fetch ) { 
       print $_ . " " ;  
     }
     print "\n";  
     # get db adaptor for db 
     my $input_db = $self->get_dbadaptor($db_alias) ;
     # get slice 
     my $input_slice = $self->fetch_sequence($self->input_id, $input_db);
     # get biotypes  
     #
     for my $bt ( @biotypes_to_fetch ) {  
        my @genes_fetched = @{ $input_slice->get_all_Genes_by_type($bt) }  ; 
        print "-> $bt    ".scalar(@genes_fetched) . " genes fetched\n " ;  
        push @genes, @genes_fetched; 
        push @all_bt_for_clustering , $bt ; 
     }
  } 
  $self->BIOTYPES(\@all_bt_for_clustering) ;  
  print "\nGot ".scalar(@genes)." genes\n";
  $self->genes(\@genes);
#  my @genes = @{ $slice->get_all_Genes($self->PRIMARY_LOGICNAME) }  ;
#  print "\nGot ".scalar(@genes)." genes from primary logic_name\n";
#  push @genes, @{ $slice->get_all_Genes($self->SECONDARY_LOGICNAME) }  ;
#  print "Now have ".scalar(@genes)." genes in total";
#  $self->genes(\@genes);
  

  return 1;

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_genes} = $value;
  }
  return $self->{_genes};
}



################
# CONFIG VARS
################

  my ( $self, $index, $seqfetcher_class ) = @_;

  my $seqfetcher;
  
  (my $class = $seqfetcher_class) =~ s/::/\//g;

  throw ("Configuration-error !! There's no entry for SEQFETCHER_OBJECT in Targetted.pm\n") if (length($class)==0)  ;

  require "$class.pm";

  if(defined $index && $index ne ''){
    my @db = ( $index );
    
    # make sure that your class is compatible with the index type
    $seqfetcher = "$seqfetcher_class"->new('-db' =>\@ db, );
  }
  else{
    $self->throw("can't make seqfetcher\n");
  }

  return $seqfetcher;
}


####################################
# config variable holders
####################################

  my ($class,@args) = @_;
  my $self = $class->SUPER::new(@args);
  
  $self->read_and_check_config($BEST_TARGETTED_CONFIG);
  
  
  my $seqfetcher = $self->make_seqfetcher($self->SEQFETCHER_DIR, 
                                          $self->SEQFETCHER_OBJECT);
  $self->seqfetcher($seqfetcher);
  
  
  return $self;

  my ($self, $hash) = @_;

  $self->SUPER::read_and_check_config($hash);
 
  my $logic = $self->analysis->logic_name;

  foreach my $var (qw(BIOTYPES 
                      DB_NAME
                      SEQFETCHER_DIR
                      SEQFETCHER_OBJECT)) {

    throw("You must define $var in config for logic '$logic'" . 
          " or in the DEFAULT entry")
        if not $self->$var;
        
  }
  
  if (not $self->OUT_DB_NAME) {
    warn ("\n\tOUT_DB_NAME has not been provided in config-file Analysis/Config/GeneBuild/BestTargetted.pm\n ".
          "\toutput will be written to " . $self->DB_NAME . "\n");
    $self->OUT_DB_NAME($self->DB_NAME);   
  }
  
}


  
   






##############
# containers
##############

  my ($self) = @_;

  my $runnable = Bio::EnsEMBL::Analysis::Runnable::BestTargetted->new
    (
     -query             => $self->query,
     -analysis          => $self->analysis,
     -seqfetcher        => $self->seqfetcher, 
     -biotypes          => $self->BIOTYPES,
     -program           => $self->EXONERATE_PROGRAM,
     -verbose           => $self->VERBOSE,
     -keep_single_analysis => $self->KEEP_SINGLE_ANALYSIS,
     -genes             => $self->genes,
     
    );

  eval{
    $runnable->run;
  };

  #
  # checking errors from Runnable 
  #
  if(my $err = $@){
    chomp $err;
    print $err ;  
    # only match '"ABC_DEFGH"' and not all possible throws
    if ($err =~ /^\"([A-Z_]{1,40})\"$/i) {
      my $code = $1;
      if ($code ne 'VOID') {
        $self->failing_job_status($1);          
        throw("BestTargetted::run failed $@");
      }
    }
  } else { 
    print $@; 
  }  
  
  $self->output($runnable->output);

  1;

  my ($self,$value) = @_;
  
  if (defined $value) {
    $self->{_seq_fetcher} = $value;
  }
  return $self->{_seq_fetcher};

  my ($self) = @_;

  my $out_dba = $self->get_dbadaptor($self->OUT_DB_NAME);

  my $gene_a = $out_dba->get_GeneAdaptor() ; 
  info ("trying to write output") ;  
  foreach my $gene (@{$self->output}){
     info("storing $gene" ); 
    $gene_a->store($gene) ; 
  }  
  return ;

  Post questions to the Ensembl development list: ensembl-dev@ebi.ac.uk