# parse a string into a location object
    $loc = Bio::Factory::FTLocationFactory->from_string("join(100..200, 400..500");

    my ($self, $locstr) = @_;
    my ($loc, $seqid);

    $self->debug( "Location parse, processing $locstr\n");

    # 'remote' location?
    if($locstr =~ /^(\S+):(.*)$/) {
	# yes; memorize remote ID and strip from location string
	$seqid = $1;
	$locstr = $2;
    }
    
    # split into start and end
    my ($start, $end) = split(/\.\./, $locstr);
    # remove enclosing parentheses if any; note that because of parentheses
    # possibly surrounding the entire location the parentheses around start
    # and/or may be asymmetrical
    $start =~ s/^\(+//;
    $start =~ s/\)+$//;
    $end   =~ s/^\(+// if $end;
    $end   =~ s/\)+$// if $end;

    # Is this a simple (exact) or a fuzzy location? Simples have exact start
    # and end, or is between two adjacent bases. Everything else is fuzzy.
    my $loctype = ".."; # exact with start and end as default
    my $locclass = "Bio::Location::Simple";
    if(! defined($end)) {
	if($locstr =~ /(\d+)([\.\^])(\d+)/) {
	    $start = $1;
	    $end = $3;
	    $loctype = $2;
	    $locclass = "Bio::Location::Fuzzy"
		unless (abs($end - $start) <= 1) && ($loctype eq "^");
	    
	} else {
	    $end = $start;
	}
    }
    if ( ($start =~ /[\>\<\?\.\^]/) || ($end   =~ /[\>\<\?\.\^]/) ) {
	$locclass = 'Bio::Location::Fuzzy';
    } 

    # instantiate location and initialize
    $loc = $locclass->new(-verbose => $self->verbose,
			  -start   => $start, 
			  -end     => $end, 
			  -strand  => 1,
			  -location_type => $loctype);
    # set remote ID if remote location
    if($seqid) {
	$loc->is_remote(1);
	$loc->seq_id($seqid);
    }

    # done (hopefully)
    return $loc;
    
}

1;

    # the third parameter is purely optional and indicates a recursive
    # call if set
    my ($self,$locstr,$is_rec) = @_;
    my $loc;

    # there is no place in FT-formatted location strings where whitespace 
    # carries meaning, so strip it off entirely upfront
    $locstr =~ s/\s+//g if ! $is_rec;

    # does it contain an operator?
    if($locstr =~ /^([A-Za-z]+)\((.*)\)$/) {
	# yes:
	my $op = $1;
	my $oparg = $2;
	if($op eq "complement") {
	    # parse the argument recursively, then set the strand to -1
	    $loc = $self->from_string($oparg, 1);
	    $loc->strand(-1);
	} elsif(($op eq "join") || ($op eq "order") || ($op eq "bond")) {
	    # This is a split location. Split into components and parse each
	    # one recursively, then gather into a SplitLocationI instance.
	    #
	    # Note: The following code will /not/ work with nested
	    # joins (you want to have grammar-based parsing for that).
	    $loc = Bio::Location::Split->new(-verbose => $self->verbose,
					     -splittype => $op);
	    foreach my $substr (split(/,/, $oparg)) {
		$loc->add_sub_Location($self->from_string($substr, 1));
	    }
	} else {
	    $self->throw("operator\" $op\" unrecognized by parser");
	}
    } else {
	# no operator, parse away
	$loc = $self->_parse_location($locstr);
    }
    return $loc;

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

  bioperl-bugs@bioperl.org
  http://bugzilla.bioperl.org/

 Title   : new
 Usage   : my $obj = new Bio::Factory::FTLocationFactory();
 Function: Builds a new Bio::Factory::FTLocationFactory object 
 Returns : an instance of Bio::Factory::FTLocationFactory
 Args    :