use Bio::Map::GeneRelative;

    # say that a somthing will have a position relative to the start of the
    # gene on map
    my $rel = Bio::Map::GeneRelative->new(-gene => 0);

    # or that something will be relative to the third transcript of a gene
    # on a map
    $rel = Bio::Map::GeneRelative->new(-transcript => 3);

    # or to the 5th intron of the default transcript
    $rel = Bio::Map::GeneRelative->new(-intron => [0, 5]);

    # use the $rel as normal; see Bio::Map::Relative

    my ($class, @args) = @_;
    my $self = $class->SUPER::new(@args);
    
    my ($gene, $transcript, $exon, $intron, $coding) =
        $self->_rearrange([qw( GENE TRANSCRIPT EXON INTRON CODING )], @args);
    
    my $set = (defined $gene) + (defined $transcript) + (defined $exon) + (defined $intron) + (defined $coding);
    if ($set > 1) {
        $self->throw("-gene, -transcript, -exon, -intron and -coding are mutually exclusive");
    }
    if ($exon && (! ref($exon) || ref($exon) ne 'ARRAY')) {
        $self->throw("-exon takes an array ref");
    }
    if ($intron && (! ref($intron) || ref($intron) ne 'ARRAY')) {
        $self->throw("-intron takes an array ref");
    }
    if ($set == 0) {
        # type could have been set already in the call to SUPER::new
        if ($self->type) {
            $self->warn("You set a type of relative not supported by GeneRelative; resetting to type 'gene'");
        }
        $gene = 0;
    }
    
    $self->gene($gene) if defined $gene;
    $self->transcript($transcript) if defined $transcript;
    $self->exon(@{$exon}) if defined $exon;
    $self->intron(@{$intron}) if defined $intron;
    $self->coding($coding) if defined $coding;
    
    return $self;

    my ($self, $pos) = @_;
    $self->throw("Must supply an object") unless ref($pos);
    $self->throw("This is [$pos], not a Bio::Map::PositionI") unless $pos->isa('Bio::Map::PositionI');
    
    # get the raw start position of our position
    my $raw = $pos->start($pos->relative);
    $self->throw("Can't convert co-ordinates when start isn't set") unless defined($raw); #*** needed? return undef?
    
    # what are we relative to?
    my $type = $self->type;
    my $value = $self->$type;
    $self->throw("Details not yet set for this Relative, cannot convert") unless defined($value);
    
    # get the absolute start of the thing we're relative to
    if ($type =~ /gene|transcript|exon|intron|coding/) {
        my $map = $pos->map;
        my $throw_desc = $type eq 'gene' ? 'gene' : "gene's transcript";
        $self->throw("Relative to a map's $throw_desc, but the Position has no map") unless $map;
        $self->throw("Relative to a map's $throw_desc, but the Position's map isn't a Bio::Map::GeneMap") unless $map->isa('Bio::Map::GeneMap');
        my $gene = $map->gene;
        
        if ($type eq 'gene') {
            my $gene_pos = $gene->position($map);
            my $rel = $gene_pos->relative;
            my $start = $rel->absolute_conversion($gene_pos);
            $value += $start;
        }
        else {
            my @values = ref($value) ? @{$value} : ($value);
            my $trans = ref($value) ? $values[1] : $value;
            my $throw_txt = $trans == 0 ? 'default/active transcript' : "transcript $trans";
            my $throw_txt2 = ref($value) ? ", or no $type $values[0]" : '';
            my $method = $type eq 'coding' ? 'coding_position' : "get_${type}_position";
            $value = $gene->$method($map, @values) || $self->throw("Relative to $throw_txt of the map's gene, but there is no such transcript$throw_txt2");
        }
    }
    else {
        return $self->SUPER::absolute_conversion($pos);
    }
    if (ref($value)) {
        # psuedo-recurse
        my $rel = $value->relative;
        $value = $rel->absolute_conversion($value);
    }
    
    if (defined($value)) {
        return $value + $raw;
    }
    return;

    my ($self, $num) = @_;
    if (defined($num)) {
        $self->throw("This is [$num], not a number") unless looks_like_number($num);
        $self->{_use} = 'gene';
        $self->{_gene} = $num;
    }
    return defined($self->{_gene}) ? $self->{_gene} : return;

    my ($self, $num) = @_;
    if (defined($num)) {
        $self->throw("This is [$num], not a number") unless looks_like_number($num);
        $self->{_use} = 'transcript';
        $self->{_transcript} = $num;
    }
    return defined($self->{_transcript}) ? $self->{_transcript} : return;

    my ($self, $num, $t_num) = @_;
    if (defined($num)) {
        if (defined($t_num)) {
            $self->throw("This is [$t_num], not a number") unless looks_like_number($t_num);
        }
        $t_num ||= 0;
        $self->throw("This is [$num], not a number") unless looks_like_number($num);
        $self->{_use} = 'exon';
        $self->{_exon} = [$num, $t_num];
    }
    return $self->{_exon} || return;

    my ($self, $num, $t_num) = @_;
    if (defined($num)) {
        if (defined($t_num)) {
            $self->throw("This is [$t_num], not a number") unless looks_like_number($t_num);
        }
        $t_num ||= 0;
        $self->throw("This is [$num], not a number") unless looks_like_number($num);
        $self->{_use} = 'intron';
        $self->{_intron} = [$num, $t_num];
    }
    return $self->{_intron} || return;

    my ($self, $num) = @_;
    if (defined($num)) {
        $self->throw("This is [$num], not a number") unless looks_like_number($num);
        $self->{_use} = 'coding';
        $self->{_coding} = $num;
    }
    return defined($self->{_coding}) ? $self->{_coding} : return;
}

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   : type
 Usage   : my $type = $relative->type();
 Function: Get the type of thing we are relative to. The types correspond
           to a method name, so the value of what we are relative to can
           subsequently be found by $value = $relative->$type;

           Note that type is set by the last method that was set, or during
           new().

 Returns : 'gene', 'transcript', 'exon', 'intron' or 'coding'
 Args    : none