# Build a MAFFT alignment factory
  $factory = Bio::Tools::Run::Alignment::MAFFT->new(@params);

  # Pass the factory a list of sequences to be aligned.
  $inputfilename = 't/cysprot.fa';
  # $aln is a SimpleAlign object.
  $aln = $factory->align($inputfilename);

  # or where @seq_array is an array of Bio::Seq objects
  $seq_array_ref = \@seq_array;
  $aln = $factory->align($seq_array_ref);

  #There are various additional options available.

    %DEFAULTS = ( 'OUTPUT' => 'fasta',
		  'METHOD' => 'fftnsi',
		  'CYCLES' => 2);
    @MAFFT4_PARAMS =qw( METHOD CYCLES );
    @MAFFT4_SWITCHES = qw( NJ ALL_POSITIVE);

    # NB: Mafft6 options are case-sensitive (eg. --lop and --LOP is different)
    @MAFFT6_PARAMS   = qw( weighti retree maxiterate partsize groupsize
        op ep lop lep lexp LOP LEXP bl jtt tm aamatrix fmodel seed );
    @MAFFT6_SWITCHES = qw( auto 6merpair globalpair localpair genafpair
        fastapair fft nofft noscore memsave parttree dpparttree fastaparttree
        clustalout inputorder reorder treeout nuc amino
        );

    @OTHER_SWITCHES = qw(QUIET ALIGN OUTPUT OUTFILE);
    @MAFFT_ALN_METHODS = qw(fftnsi fftns nwnsi nwns fftnsrough nwnsrough);
    #@MAFFT6_ALN_METHODS = qw(linsi ginsi einsi fftnsi fftns nwnsi nwns)
    # Authorize attribute fields
    foreach my $attr ( @MAFFT4_SWITCHES,@MAFFT4_PARAMS,@OTHER_SWITCHES ) {
	$OK_FIELD{$attr}++; 
    }
    foreach my $attr ( @MAFFT6_PARAMS, @MAFFT6_SWITCHES ) {
        $OK_FIELD6{$attr}++

    return 'mafft';

    my ($self, $exename, $exe,$warn) = @_;
    $exename = $self->program_name unless (defined $exename );
 
    if( defined $exe && -x $exe ) {
        $self->{'_pathtoexe'}->{$exename} = $exe;
    }
    unless( defined $self->{'_pathtoexe'}->{$exename} ) {
        my $f = $self->program_path($exename);	    
        $exe = $self->{'_pathtoexe'}->{$exename} = $f if(-e $f && -x $f );
         
        #  This is how I meant to split up these conditionals --jason
        # if exe is null we will execute this (handle the case where
        # PROGRAMDIR pointed to something invalid)
        unless( $exe )  {  # we didn't find it in that last conditional
        if( ($exe = $self->io->exists_exe($exename)) && -x $exe ) {
            $self->{'_pathtoexe'}->{$exename} = $exe;
        } else { 
            $self->warn("Cannot find executable for $exename") if $warn;
            $self->{'_pathtoexe'}->{$exename} = undef;
        }
        }
    }
    return $self->{'_pathtoexe'}->{$exename};

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

    return Bio::Root::IO->catfile(@path);

        return File::Spec->rel2abs($ENV{MAFFTDIR}) if $ENV{MAFFTDIR};

    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);	
    }

    $self->output($DEFAULTS{'OUTPUT'}) unless( $self->output );
    if ( ! $self->_version6 ) {
        $self->method($DEFAULTS{'METHOD'}) unless( $self->method );
    }
    return $self;

    my $self = shift;
    my $attr = $AUTOLOAD;
    $attr =~ s/.*:://;

    # NB: Mafft6 options are case-sensitive
    if ( $self->_version6 ) {
        if ( $OK_FIELD6{ $attr } ) {
            # Don't want the attrs to clash with bioperl attributes
            $self->{version6attrs}{$attr} = shift if @_;
            return $self->{version6attrs}{$attr};
        }
    }
    $attr = uc $attr;
    # aliasing
    $attr = 'OUTFILE' if $attr eq 'OUTFILE_NAME';
    $self->throw("Unallowed parameter: $attr !") unless $OK_FIELD{$attr};

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

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

    my ($self) = @_;
    my $exe;
    return unless $exe = $self->executable;
    # this is a bit of a hack, but MAFFT is just a gawk script
    # so we are actually grepping the scriptfile
    # UPDATE (Torsten Seemann)
    # it now seems to be a 'sh' script and the format has changed
    # slightly. i've tried to make the change compatible with both...
    # version="v5.860 (2006/06/12)"; export version
    
    if( open(my $NAME, "grep 'export version' $exe | ") ) {
		while(<$NAME>) {
			if( /version.*?([\d.a-z]+)\s+/ ) {
				return $1;
			}
		}
		$self->warn("No version found");
		close($NAME);
    } else {
		$self->warn("$!");
    }
    return;

   my ($self,$seqs) = @_;
   return $self->align($seqs);

    my ($self,$input) = @_;
    # Create input file pointer
    $self->io->_io_cleanup();
    my ($infilename,$type) = $self->_setinput($input);
    if (! $infilename) {
	$self->throw("Bad input data or less than 2 sequences in $input !");
    }

    my ($param_string,$outstr) = $self->_setparams();

    # run mafft
    return $self->_run($infilename, $param_string,$outstr);

    my ($self,$infilename,$paramstr,$outstr) = @_;
     my $commandstring = $self->executable()." $paramstr $infilename $outstr";
    
    $self->debug( "mafft command = $commandstring\n ");

    my $status = system($commandstring);
    my $outfile = $self->outfile(); 
    if( !-e $outfile || -z $outfile ) {
        $self->warn( "MAFFT call crashed: $? [command $commandstring]\n");
        return;
    }
    
    my $in  = Bio::AlignIO->new('-file' => $outfile, 
				'-format' => $self->output);
    my $aln = $in->next_aln();
    return $aln;

    my ($self,$input) = @_;
    my ($infilename, $seq, $temp, $tfh);
    if (! ref $input) {
	# check that file exists or throw
	$infilename = $input;
	unless (-e $input) {return 0;}	
	return ($infilename);
    } elsif (ref($input) =~ /ARRAY/i ) { #  $input may be an
	                                 #  array of BioSeq objects...
        #  Open temporary file for both reading & writing of array
	($tfh,$infilename) = $self->io->tempfile();
	if( ! ref($input->[0]) ) {
	    $self->warn("passed an array ref which did not contain objects to _setinput");
	    return;
	} elsif( $input->[0]->isa('Bio::PrimarySeqI') ) {		
	    $temp =  Bio::SeqIO->new('-fh' => $tfh,
				     '-format' => 'fasta');
	    my $ct = 1;
	    foreach $seq (@$input) {
		return 0 unless ( ref($seq) && 
				  $seq->isa("Bio::PrimarySeqI") );
		if( ! defined $seq->display_id ||
		    $seq->display_id =~ /^\s+$/) {
		    $seq->display_id( "Seq".$ct++);
		}
		$temp->write_seq($seq);
	    }
	    $temp->close();
	    undef $temp;
	    close($tfh);
	    $tfh = undef;
	}  else { 
	    $self->warn( "got an array ref with 1st entry ".
			 $input->[0].
			 " and don't know what to do with it\n");
	}

	return ($infilename);
    } else {
	$self->warn("Got $input and don't know what to do with it\n");
    }
    return 0;

    my ($self) = @_;
    my ($outfile,$param_string) = ('','');

    # Set default output file if no explicit output file selected
    unless (defined($outfile = $self->outfile) ) {	
	my $tfh;
	($tfh, $outfile) = $self->io->tempfile(-dir=>$self->tempdir());
	close($tfh);
	undef $tfh;
	$self->outfile($outfile);
    } 
    my ($attr,$value);
    
    if ( $self->_version6 ) {
        for  $attr ( @MAFFT6_SWITCHES) {
            $value = $self->$attr();
            next unless defined $value;
            my $attr_key = lc $attr; #put switches in format expected by mafft
            $attr_key = ' --'.$attr_key;
            $param_string .= $attr_key ;
        }
        for  $attr ( @MAFFT6_PARAMS ) {
            $value = $self->$attr();
            next unless (defined $value);
            my $attr_key = lc $attr;
            $attr_key = ' --'.$attr_key;
            $param_string .= $attr_key .' '.$value;
        }
        if ( ! $self->no_param_checks ) {
            my @incompatible = qw/auto 6merpair globalpair localpair genafpair
                fastapair/;
            my @set = grep { $self->$_ } @incompatible;
            if ( @set > 1 ) {
                $self->throw("You can't specify more than one of @set");
            }
        }
    }
    else {
        for  $attr ( @MAFFT4_SWITCHES) {
            $value = $self->$attr();
            next unless defined $value;
            my $attr_key = lc $attr; #put switches in format expected by mafft
            $attr_key = ' --'.$attr_key;
            $param_string .= $attr_key ;
        }
        # Method is a version 4 option
        my $method = $self->method;
        $self->throw("no method ") unless defined $method;
        if( $method !~ /(rough|nsi)$/ &&
            defined $self->cycles) {
            $param_string .= " ".$self->cycles;
        }
    }

    my $outputstr = " 1>$outfile" ;

    if ($self->quiet() || $self->verbose < 0) { 
	$param_string .= " --quiet";
	$outputstr .= ' 2> /dev/null';
    }
    return ($param_string, $outputstr);

   my ($self) = shift;
   return @MAFFT_ALN_METHODS;

    my $self = shift;
    if ( ! defined $self->{_version6} ) {
        if ( $self->version =~ /^v6/ ) {
            $self->{_version6} = 1;
        }
        else {
            $self->{_version6} = '';
        }
    }
    return $self->{_version6};

  bioperl-l@bioperl.org                  - General discussion
  http://bioperl.org/MailList.html - About the mailing lists

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

 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: 
 Returns : value of save_tempfiles
 Args    : newvalue (optional)

 Title   : outfile_name
 Usage   : my $outfile = $mafft->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   : $mafft->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
 Args    : none