use Bio::Location::Simple;

    my $location = Bio::Location::Simple->new(
        -start  => 1,
        -end    => 100,
        -strand => 1,
    );

    if( $location->strand == -1 ) {
        printf "complement(%d..%d)\n", $location->start, $location->end;
    } else {
        printf "%d..%d\n", $location->start, $location->end;
    }

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

    my ($locationtype) = $self->_rearrange([qw(LOCATION_TYPE)],@args);

    $locationtype && $self->location_type($locationtype);

    return $self;

    my ($self, $value) = @_;
    $self->{'_start'} = $value if defined $value ;
  
    $self->throw("Only adjacent residues when location type ".
             "is IN-BETWEEN. Not [". $self->{'_start'}. "] and [".
             $self->{'_end'}. "]" )
        if defined $self->{'_start'} && defined $self->{'_end'} && 
        $self->location_type eq 'IN-BETWEEN' &&
        ($self->{'_end'} - 1 != $self->{'_start'});
    return $self->{'_start'};

    my ($self, $value) = @_;
  
    $self->{'_end'} = $value if defined $value ;
    
    # Assume end is the same as start if not defined
    if (!defined $self->{'_end'}) {
        if (!defined $self->{'_start'}) {
            $self->warn('Can not set Bio::Location::Simple::end() equal to start; start not set');
            return;
        }
        $self->warn('Setting end to equal start['. $self->{'_start'}. ']');
        $self->{'_end'} = $self->{'_start'};
    }
    $self->throw("Only adjacent residues when location type ".
            "is IN-BETWEEN. Not [". $self->{'_start'}. "] and [".
             $self->{'_end'}. "]" )
        if defined $self->{'_start'} && defined $self->{'_end'} && 
        $self->location_type eq 'IN-BETWEEN' &&
        ($self->{'_end'} - 1 != $self->{'_start'});
  
    return $self->{'_end'};

    my ($self) = @_;
    if ($self->location_type eq 'IN-BETWEEN' ) {
        return 0;
    } else {
        return abs($self->end - $self->start) + 1;
    }

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

    if( defined $value || ! defined $self->{'_location_type'} ) {
        $value = 'EXACT' unless defined $value;
        $value = uc $value;
        if (! defined $RANGEDECODE{$value}) {
            $value = '\^' if $value eq '^';
            $value = '\.\.' if $value eq '..';
            $value = $RANGEENCODE{$value};
        }
        $self->throw("Did not specify a valid location type. [$value] is no good")
            unless defined $value;
        $self->{'_location_type'} = $value;
    }
    $self->throw("Only adjacent residues when location type ".
            "is IN-BETWEEN. Not [". $self->{'_start'}. "] and [".
            $self->{'_end'}. "]" )
        if $self->{'_location_type'} eq 'IN-BETWEEN' &&
        defined $self->{'_start'} &&
        defined $self->{'_end'} &&
            ($self->{'_end'} - 1 != $self->{'_start'});

    return $self->{'_location_type'};

     my($self) = @_;

    my $str;
    if( $self->start == $self->end ) {
        $str =  $self->start;
    } else {
        $str = $self->start . $RANGEDECODE{$self->location_type} . $self->end;
    }
    if($self->is_remote() && $self->seq_id()) {
        $str = $self->seq_id() . ":" . $str;
    }
    if( defined $self->strand &&
        $self->strand == -1 ) {
        $str = "complement(".$str.")";
    }
    return $str;

    my ($self,$start,$end,$relative_ori) = @_;
    my $newstart  = $self->start - $start+1;
    my $newend    = $self->end   - $start+1;
    my $newstrand = $relative_ori * $self->strand;

    my $out;
    if( $newstart < 1 || $newend > ($end-$start+1) ) {
        $out = Bio::Location::Simple->new();
        $out->start($self->start);
        $out->end($self->end);
        $out->strand($self->strand);
        $out->seq_id($self->seqid);
        $out->is_remote(1);
    } else {
        $out = Bio::Location::Simple->new();
        $out->start($newstart);
        $out->end($newend);
        $out->strand($newstrand);
       $out->seq_id();
    }

    return $out;
}

1;

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

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

  Title   : strand
  Usage   : $strand = $loc->strand();
  Function: get/set the strand of this range
  Returns : the strandedness (-1, 0, +1)
  Args    : optionaly allows the strand to be set
          : using $loc->strand($strand)

  Title   : min_start
  Usage   : my $minstart = $location->min_start();
  Function: Get minimum starting location of feature startpoint
  Returns : integer or undef if no minimum starting point.
  Args    : none

  Title   : max_start
  Usage   : my $maxstart = $location->max_start();
  Function: Get maximum starting location of feature startpoint.

            In this implementation this is exactly the same as min_start().

  Returns : integer or undef if no maximum starting point.
  Args    : none

  Title   : start_pos_type
  Usage   : my $start_pos_type = $location->start_pos_type();
  Function: Get start position type (ie <,>, ^).

  Returns : type of position coded as text 
            ('BEFORE', 'AFTER', 'EXACT','WITHIN', 'BETWEEN')
  Args    : none

  Title   : min_end
  Usage   : my $minend = $location->min_end();
  Function: Get minimum ending location of feature endpoint 
  Returns : integer or undef if no minimum ending point.
  Args    : none

  Title   : max_end
  Usage   : my $maxend = $location->max_end();
  Function: Get maximum ending location of feature endpoint 

            In this implementation this is exactly the same as min_end().

  Returns : integer or undef if no maximum ending point.
  Args    : none

  Title   : end_pos_type
  Usage   : my $end_pos_type = $location->end_pos_type();
  Function: Get end position type (ie <,>, ^) 

  Returns : type of position coded as text 
            ('BEFORE', 'AFTER', 'EXACT','WITHIN', 'BETWEEN')
  Args    : none

 Title   : is_remote
 Usage   : $is_remote_loc = $loc->is_remote()
 Function: Whether or not a location is a remote location.

           A location is said to be remote if it is on a different
           'object' than the object which 'has' this
           location. Typically, features on a sequence will sometimes
           have a remote location, which means that the location of
           the feature is on a different sequence than the one that is
           attached to the feature. In such a case, $loc->seq_id will
           be different from $feat->seq_id (usually they will be the
           same).

           While this may sound weird, it reflects the location of the
           kind of AL445212.9:83662..166657 which can be found in GenBank/EMBL
           feature tables.

 Example : 
 Returns : TRUE if the location is a remote location, and FALSE otherwise
 Args    : Value to set to

 Title   : valid_Location
 Usage   : if ($location->valid_location) {...};
 Function: boolean method to determine whether location is considered valid
           (has minimum requirements for Simple implementation)
 Returns : Boolean value: true if location is valid, false otherwise
 Args    : none