use Bio::LocatableSeq;
    my $seq = new Bio::LocatableSeq(-seq => "CAGT-GGT",
				    -id  => "seq1",
				    -start => 1,
				    -end   => 7);

    # a normal sequence object
    $locseq->seq();
    $locseq->id();

    # has start,end points
    $locseq->start();
    $locseq->end();

    # inherits off RangeI, so range operations possible

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

    my ($start,$end,$strand) =
	$self->_rearrange( [qw(START END STRAND)],
			   @args);

    defined $start && $self->start($start);
    defined $end   && $self->end($end);
    defined $strand && $self->strand($strand);

    return $self; # success - we hope!

   my $self = shift;
   if( @_ ) {
      my $value = shift;
      $self->{'start'} = $value;
  }
   return $self->{'start'} if defined $self->{'start'};
   return 1                if $self->seq;
   return;

   my $self = shift;
   if( @_ ) {
      my $value = shift;
      my $string = $self->seq;
      if ($self->seq) {
          my $len = $self->_ungapped_len;
	  my $id = $self->id;
	  $self->warn("In sequence $id residue count gives end value $len.
Overriding value [$value] with value $len for Bio::LocatableSeq::end().")
	      and $value = $len if $len != $value and $self->verbose > 0;
      }

      $self->{'end'} = $value;
    }

   return $self->{'end'} || $self->_ungapped_len;

    my $self = shift;
    my $string = $self->seq || '';
    $string =~ s/[\.\-]+//g;
    $self->seq ? (return $self->start + CORE::length($string) - 1 ) : undef;

   my $self = shift;
   if( @_ ) {
      my $value = shift;
      $self->{'strand'} = $value;
    }
    return $self->{'strand'};

   my ($self,$char1,$char2) = @_;

   $char1 ||= "/";
   $char2 ||= "-";

   $self->throw("Attribute id not set") unless defined($self->id());
   $self->throw("Attribute start not set") unless defined($self->start());
   $self->throw("Attribute end not set") unless defined($self->end());

   return $self->id() . $char1 . $self->start . $char2 . $self->end ;

    my ($self,$char) = @_;
    my ($seq, $count) = (undef, 0);

    # default gap characters
    $char ||= '-.';

    $self->warn("I hope you know what you are doing setting gap to [$char]")
	unless $char =~ /[-.]/;

    $seq = $self->seq;
    return 0 unless $seq; # empty sequence does not have gaps

    $seq =~ s/^([$char]+)//;
    $seq =~ s/([$char]+)$//;
    $count++ while $seq =~ /[$char]+/g;

    return $count;

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

    $self->throw("Residue number has to be a positive integer, not [$resnumber]")
	unless $resnumber =~ /^\d+$/ and $resnumber > 0;

    if ($resnumber >= $self->start() and $resnumber <= $self->end()) {
	my @residues = split //, $self->seq;
	my $count = $self->start();
	my $i;
	my ($start,$end,$inc,$test);
        my $strand = $self->strand || 0;
	# the following bit of "magic" allows the main loop logic to be the
	# same regardless of the strand of the sequence
	($start,$end,$inc,$test)= ($strand == -1)?
            (scalar(@residues-1),0,-1,sub{$i >= $end}) :
                (0,scalar(@residues-1),1,sub{$i <= $end});

	for ($i=$start; $test->(); $i+= $inc) {
	    if ($residues[$i] ne '.' and $residues[$i] ne '-') {
		$count == $resnumber and last;
		$count++;
	    }
	}
	# $i now holds the index of the column.
        # The actual column number is this index + 1

	return $i+1;
    }

    $self->throw("Could not find residue number $resnumber");

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

    $self->throw("Column number has to be a positive integer, not [$column]")
	unless $column =~ /^\d+$/ and $column > 0;
    $self->throw("Column number [$column] is larger than".
		 " sequence length [". $self->length. "]")
	unless $column <= $self->length;

    my ($loc);
    my $s = $self->subseq(1,$column);
    $s =~ s/[^a-zA-Z\*]//g;

    my $pos = CORE::length $s;

    my $start = $self->start || 0 ;
    my $strand = $self->strand() || 1;
    my $relative_pos = ($strand == -1)
        ? ($self->end - $pos + 1)
	: ($pos + $start - 1);
    if ($self->subseq($column, $column) =~ /[a-zA-Z\*]/ ) {
	$loc = new Bio::Location::Simple
	    (-start  => $relative_pos,
	     -end    => $relative_pos,
	     -strand => 1,
	     );
    } elsif ($pos == 0 and $self->start == 1) {
    } else {
      my ($start,$end) = ($relative_pos, $relative_pos + $strand);
      if ($strand == -1) {
	($start,$end) = ($end,$start);
      }
	$loc = new Bio::Location::Simple
	    (-start         => $start,
	     -end           => $end,
	     -strand        => 1,
	     -location_type => 'IN-BETWEEN'
	     );
    }
    return $loc;

    my ($self) = @_;

    my $new = $self->SUPER::revcom;
    $new->strand($self->strand * -1);
    $new->start($self->start) if $self->start;
    $new->end($self->end) if $self->end;
    return $new;

    my ($self, $start, $end) = @_;
    my $new = $self->SUPER::trunc($start, $end);
    $new->strand($self->strand);

    # end will be automatically calculated
    $start = $end if $self->strand == -1;

    $start = $self->location_from_column($start);
    $start ? ($start = $start->end) : ($start = 1);
    $new->start($start) if $start;

    return $new;

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

  http://bugzilla.open-bio.org/

 Title   : no_gaps
 Usage   :$self->no_gaps('.')
 Function:

           Gets number of gaps in the sequence. The count excludes
           leading or trailing gap characters.

           Valid bioperl sequence characters are [A-Za-z\-\.\*]. Of
           these, '.' and '-' are counted as gap characters unless an
           optional argument specifies one of them.

 Returns : number of internal gaps in the sequnce.
 Args    : a gap character (optional)