# Build a Tmhmm  factory

  # $paramfile is the full path to the seg binary file

  my @params = ('PROGRAM',$paramfile);
  my $factory = Bio::Tools::Run::Tmhmm->new($param);

  # Pass the factory a Bio::Seq object
  # @feats is an array of Bio::SeqFeature::Generic objects

  my @feats = $factory->run($seq);

    $PROGRAMNAME = 'tmhmm'  . ($^O =~ /mswin/i ?'.exe':'');       
    @TMHMM_PARAMS=qw(PROGRAM VERBOSE NOPLOT);
    foreach my $attr ( @TMHMM_PARAMS)
    { $OK_FIELD{$attr}++;

    return $PROGRAMNAME;

    return $ENV{TMHMMDIR} || '';

    my ($self) = @_;
    my @path;
    if ($self->program_dir) {
        my $program_dir = $self->program_dir;
        $program_dir =~ s/\/bin//;
        push @path, $program_dir;
    }
    push @path, 'bin';
    push @path, $self->program_name.($^O =~ /mswin/i ?'.exe':'');

    return File::Spec->catfile(@path);

       my $self = shift;
       my $attr = $AUTOLOAD;
       $attr =~ s/.*:://;
       $attr = uc $attr;
       $self->throw("Unallowed parameter: $attr !") unless $OK_FIELD{$attr};
       $self->{$attr} = shift if @_;
       return $self->{$attr};

       my ($class,@args) = @_;
       my $self = $class->SUPER::new(@args);

       my ($attr, $value);
       while (@args)  {
           $attr =   shift @args;
           $value =  shift @args;
           next if( $attr =~ /^-/ ); # don't want named parameters
           $self->$attr($value);
       }
       return $self;

	return shift->run(@_);

    my $self = shift;
    my $exe = $self->SUPER::executable(@_) || return;
    
    # even if its executable, we still need the environment variable to have
    # been set
    if (! $ENV{TMHMMDIR}) {
        $self->warn("Environment variable TMHMMDIR must be set, even if the tmhmm executable is in your path");
        return undef;
    }
    
    return $exe;

    my ($self,$seq) = @_;
    my @feats;

    if (ref($seq) ) {		# it is an object
        if (ref($seq) =~ /GLOB/) {
            $self->throw("cannot use filehandle");
        }

        my $infile1 = $self->_writeSeqFile($seq);

        $self->_input($infile1);

	@feats = $self->_run();
	unlink $infile1;

    }
    else {
        # The clone object is not a seq object but a file.  Perhaps
        # should check here or before if this file is fasta format...if
        # not die Here the file does not need to be created or
        # deleted. Its already written and may be used by other
        # runnables.

        $self->_input($seq);
	@feats = $self->_run();
    }
    return @feats;

     my ($self,$infile1) = @_;
     if (defined $infile1){

         $self->{'input'}=$infile1;
     }
      return $self->{'input'};

     my ($self)= @_;

     my ($tfh1,$outfile) = $self->io->tempfile(-dir=>$self->tempdir());
     my $str = $self->executable || return;
     
     if( $self->NOPLOT ) {
	 $str .= " --noplot";
     }
     $str .= " -basedir=".$self->program_dir." -workdir=".$self->tempdir()." ".$self->_input." > ".$outfile;
     
     my $status = system($str);
     $self->throw( "Tmhmm call ($str) crashed: $?\n ") unless $status==0;
    
     my $filehandle;
     if (ref ($outfile) !~ /GLOB/) {
        open (TMHMM, "<".$outfile) or $self->throw ("Couldn't open file ".$outfile.": $!\n");
        $filehandle =\* TMHMM;
     }
     else {
        $filehandle = $outfile;
     }

     my $tmhmm_parser = Bio::Tools::Tmhmm->new(-fh=>$filehandle);

     my @tmhmm_feat;

     while(my $tmhmm_feat = $tmhmm_parser->next_result){

           push @tmhmm_feat, $tmhmm_feat;
     }
     # free resources
     $self->cleanup();
     unlink $outfile;
     close($tfh1);
     undef $tfh1;
     
     return @tmhmm_feat;

    my ($self,$seq) = @_;
    my ($tfh,$inputfile) = $self->io->tempfile(-dir=>$self->tempdir());
    my $in  = Bio::SeqIO->new(-fh => $tfh , '-format' => 'Fasta');
    $in->write_seq($seq);
    close($tfh);
    undef $tfh;
    return $inputfile;

}
1;

  bioperl-l@bioperl.org                  - General discussion
  http://bioperl.org/wiki/Mailing_lists  - About the mailing lists

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

 Email savikalpa@fugu-sg.org

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

 Title   :   _input
 Usage   :   obj->_input($seqFile)
 Function:   Internal(not to be used directly)
 Returns :
 Args    :