use Bio::Tools::Run::Alignment::Blat;

 my $factory = Bio::Tools::Run::Alignment::Blat->new(-db => $database);
 # $report is a SearchIO-compliant object
 my $report = $factory->align($seqobj);

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

  return 'blat';

  return Bio::Root::IO->catfile($ENV{BLATDIR}) if $ENV{BLATDIR};

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

	if  (ref($query) ) {	# it is an object
    	if (ref($query) =~ /GLOB/) {
	      $self->throw("Cannot use filehandle as argument to run()");
    	}
    	my $infile = $self->_writeSeqFile($query);
        return  $self->_run($infile);
	} else {
		return $self->_run($query);
	}

  return shift->run(@_);

    my $self = shift;
    return $self->{blat_db} = shift if @_;
    return $self->{blat_db};
}

# this is a kludge for tests (so one might expect this to be used elsewhere).
# None of the other parameters worked in the past, so not replacing them

*DB =\& db;

    my $self = shift;
    return $self->{blat_qsegment} = shift if @_;
    return $self->{blat_qsegment};

    my $self = shift;
    return $self->{blat_tsegment} = shift if @_;
    return $self->{blat_tsegment};
}

# override this, otherwise one gets a default of 'mlc'

    my $self = shift;
    return $self->{blat_outfile} = shift if @_;
    return $self->{blat_outfile};

    my ($self, $params) = @_;
    if ($params && ref $params eq 'HASH') {
        delete $params->{-format}; 
        $self->{blat_searchio} = $params;
    }
    return $self->{blat_searchio} || {};

    my $self = shift;
    # circumvent any issues arising from passing in refs
    my %args = (ref($_[0]) eq 'HASH')  ? %{$_[0]} :
               (ref($_[0]) eq 'ARRAY') ? @{$_[0]} :
               @_;
    # set the parameters passed in, but only ones supported for the program
    %args = map { my $a = $_;
              $a =~ s{^-}{};
              $a => $args{$_};
                 } sort keys %args;
    
    while (my ($key, $val) = each %args) {
        if (exists $BLAT_PARAMS{$key}) {
            $self->{parameters}->{$key} = $val;
        } elsif (exists $BLAT_SWITCHES{$key}) {
            $self->{parameters}->{$key} = $BLAT_SWITCHES{$key} ? 1 : 0;
        } elsif ($LOCAL_ATTRIBUTES{$key} && $self->can($key)) {
            $self->$key($val);
        }
    }

    my $self = shift;
    delete $self->{parameters};
    if (@_) {
        $self->set_parameters(@_);
    }

 0

 1

    my ($self, $exec) = @_;
    my @params = (sort keys %BLAT_PARAMS, sort keys %BLAT_SWITCHES);
    return @params;

    my ($self, $option) = @_;
    $option ||= ''; # no option
    my %params;
    if (exists $self->{parameters}) {
        %params = map {$_ => $self->{parameters}->{$_}} sort keys %{$self->{parameters}};
    } else {
        %params = ();
    }
    return %params;

    my ($self, @passed) = @_;
    my ($seq) = $self->_rearrange([qw(SEQ_FILE)], @passed);
    $self->throw("Must provide a seq_file") unless defined $seq;
    my %params = $self->get_parameters();
    
    my ($exe, $db, $qseg, $tseg) = ($self->executable,
                                   $self->db,
                                   $self->qsegment,
                                   $self->tsegment);
    
    $self->throw("Executable not found") unless defined($exe);

    if ($tseg) {
        $db .= ":$tseg";
    }
    
    if ($qseg) {
        $seq .= ":$qseg";
    }
    
    my @params;
    
    for my $p (sort keys %BLAT_SWITCHES) {
        if (exists $params{$p}) {
            push @params, "-$p"
        }
    }

    for my $p (sort keys %BLAT_PARAMS) {
        if (exists $params{$p}) {
            push @params, "-$p=$params{$p}"
        }
    }
    
    # this only passes in the first seq file (no globs are allow AFAIK)
    
    push @params, ($db, $seq);

    # quiet! Unfortunately, it is NYI
    
    my $string = "$exe ".join(' ',@params);

    $string;
}

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

    my ($self,$infile1) = @_;
    if(defined $infile1){
        $self->{'input'}=$infile1;
     }   
     return $self->{'input'};
}

#=head2 _database
#
# Title   :   _database
# Usage   :   obj->_database($seqFile)
# Function:   Internal (not to be used directly)
# Returns :
# Args    :
#
#=cut

    my ($self,$infile1) = @_;
    $self->{'db'} = $infile1 if(defined $infile1);
    return $self->{'db'};
}


#=head2 _run
#
# Title   :   _run
# Usage   :   $obj->_run()
# Function:   Internal (not to be used directly)
# Returns :   An array of Bio::SeqFeature::Generic objects
# Args    :
#
#=cut

	my ($self)= shift;
	my $str = $self->to_exe_string(-seq_file => shift);
    
    my $out = $self->outfile_name || $self->_tempfile;
    
    $str .= " $out".$self->_quiet;
	$self->debug($str."\n") if( $self->verbose > 0 );

    my %params = $self->get_parameters;

	my $status = system($str);
	$self->throw( "Blat call ($str) crashed: $?\n ") unless $status==0;
	
    my $format = exists($params{out}) ?
                $searchio_map{$params{out}} : 'psl';
    
	my @io = ref ($out) !~ /GLOB/ ? (-file    => $out,) : (-fh    => $out,);
	my $blat_obj = Bio::SearchIO->new(%{$self->searchio},
                                    @io,
                                    -query_type => $params{prot} ? 'protein' :
                                                    $params{q} || 'dna',
                                    -hit_type   => $params{prot} ? 'protein' :
                                                    $params{t} || 'dna',
                                    -format => $format);
	return $blat_obj;
}


#=head2 _writeSeqFile
#
# Title   :   _writeSeqFile
# Usage   :   obj->_writeSeqFile($seq)
# Function:   Internal (not to be used directly)
# Returns :
# Args    :
#
#=cut

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

    my $self = shift;
    my ($tfh,$outfile) = $self->io->tempfile(-dir=>$Bio::Root::IO::TEMPDIR);
	# this is because we only want a unique filename
	close($tfh);
    return $outfile;

    my $self = shift;
    my $q = '';
    # BLAT output goes to a file, all other output is STDOUT
    if ($self->quiet) {
        $q =  $^O =~ /Win/i ? ' 2>&1 NUL' : ' > /dev/null 2>&1';
    }
    $q;
}

1;

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

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

 Chris Fields - cjfields at bioperl dot org

 Original author- Bala Email bala@tll.org.sg