Bio::Map MappableI
SummaryIncluded librariesPackage variablesSynopsisDescriptionGeneral documentationMethods
Toolbar
WebCvs
Summary
Bio::Map::MappableI - An object that can be placed in a map
Package variables
No package variables defined.
Included modules
Bio::Map::PositionHandler
Inherit
Bio::AnnotatableI Bio::Map::EntityI
Synopsis
    # do not use this module directly
# See Bio::Map::Mappable for an example of
# implementation.
Description
This object handles the generic notion of an element placed on a
(linear) Map. A Mappable can have multiple positions in multiple maps, such as
is the case of Restriction enzyme cut sites on sequence maps. For exact
information about a mappable's position in a map one must query the associate
PositionI objects which are accessible through the get_positions() method.
Methods
get_position_handlerDescriptionCode
add_positionDescriptionCode
get_positionsDescriptionCode
purge_positionsDescriptionCode
known_mapsDescriptionCode
nameDescriptionCode
idDescriptionCode
in_mapDescriptionCode
equalsDescriptionCode
overlapsDescriptionCode
containsDescriptionCode
intersectionDescriptionCode
unionDescriptionCode
Methods description
get_position_handlercode    nextTop
 Title   : get_position_handler
Usage : my $position_handler = $entity->get_position_handler();
Function: Gets a PositionHandlerI that $entity is registered with.
Returns : Bio::Map::PositionHandlerI object
Args : none
add_positioncodeprevnextTop
 Title   : add_position
Usage : $mappable->add_position($position);
Function: Add a position to this mappable (defining where on which map it is).
Returns : n/a
Args : Bio::Map::PositionI object
get_positionscodeprevnextTop
 Title   : get_positions
Usage : my @positions = $mappable->get_positions();
Function: Get all the Positions of this Mappable (sorted).
Returns : Array of Bio::Map::PositionI objects
Args : none for all, OR
Bio::Map::MapI object for positions on the given map, AND/OR some
other true value to avoid sorting
purge_positionscodeprevnextTop
 Title   : purge_positions
Usage : $mappable->purge_positions();
Function: Remove positions from this mappable.
Returns : n/a
Args : none to remove all positions, OR
Bio::Map::PositionI object to remove just that Position, OR
Bio::Map::MapI object to remove only those positions on the given
map
known_mapscodeprevnextTop
 Title   : known_maps
Usage : my @maps = $marker->known_maps()
Function: Returns the maps that this mappable is found on
Returns : Array of Bio::Map::MapI objects
Args : none
namecodeprevnextTop
 Title   : name
Usage : my $name = $marker->name();
$marker->name($new_name);
Function: Get/Set the name for this Mappable.
Returns : A scalar representing the current name of this Mappable
Args : none to get
string to set
idcodeprevnextTop
 Title   : id
Usage : my $id = $marker->id();
$marker->id($new_id);
Function: Get/Set the id for this Mappable.
Returns : A scalar representing the current id of this Mappable
Args : none to get
string to set
in_mapcodeprevnextTop
 Title   : in_map
Usage : if ($marker->in_map($map)) {...}
Function: Tests if this mappable is found on a specific map
Returns : boolean
Args : Bio::Map::MapI
equalscodeprevnextTop
 Title   : equals
Usage : if ($mappable->equals($other_mappable)) {...}
my @equal_positions = $mappable->equals($other_mappable);
Function: Finds the positions in this mappable that are equal to any
comparison positions.
Returns : array of Bio::Map::PositionI objects
Args : arg #1 = Bio::Map::MappableI OR Bio::Map::PositionI to compare
this one to (mandatory)
arg #2 = optionally, the key => value pairs below
-map => Bio::Map::MapI : optionally a Map to only consider
positions on the given map
-relative => Bio::Map::RelativeI : optionally a Relative to ask if
the Positions equal in terms of
their relative position to the
thing described by that Relative
overlapscodeprevnextTop
 Title   : overlaps
Usage : if ($mappable->overlaps($other_mappable)) {...}
my @overlapping_positions = $mappable->overlaps($other_mappable);
Function: Finds the positions in this mappable that overlap with any
comparison positions.
Returns : array of Bio::Map::PositionI objects
Args : arg #1 = Bio::Map::MappableI OR Bio::Map::PositionI to compare
this one to (mandatory)
arg #2 = optionally, the key => value pairs below
-map => Bio::Map::MapI : optionally a Map to only consider
positions on the given map
-relative => Bio::Map::RelativeI : optionally a Relative to ask if
the Positions overlap in terms of
their relative position to the
thing described by that Relative
containscodeprevnextTop
 Title   : contains
Usage : if ($mappable->contains($other_mappable)) {...}
my @container_positions = $mappable->contains($other_mappable);
Function: Finds the positions in this mappable that contain any comparison
positions.
Returns : array of Bio::Map::PositionI objects
Args : arg #1 = Bio::Map::MappableI OR Bio::Map::PositionI to compare
this one to (mandatory)
arg #2 = optionally, the key => value pairs below
-map => Bio::Map::MapI : optionally a Map to only consider
positions on the given map
-relative => Bio::Map::RelativeI : optionally a Relative to ask if
the Positions contains in terms of
their relative position to the
thing described by that Relative
intersectioncodeprevnextTop
 Title   : intersection
Usage : my $position = $mappable->intersection($other_mappable);
my $position = Bio::Map::Mappable->intersection(\@mappables);
Function: Make the position that is at the intersection of all positions of all
supplied mappables.
Returns : Bio::Map::PositionI object or undef (if not all positions overlap)
Args : arg #1 = Bio::Map::MappableI OR Bio::Map::PositionI to compare
this one to, or an array ref of such objects (mandatory)
arg #2 = optionally, the key => value pairs below
-map => Bio::Map::MapI : optionally a Map to only consider
positions on the given map
-relative => Bio::Map::RelativeI : optionally a Relative to to ask
how the Positions intersect in
terms of their relative position
to the thing described by that
Relative
unioncodeprevnextTop
 Title   : union
Usage : my $position = $mappable->union($other_mappable);
my $position = Bio::Map::Mappable->union(@mappables);
Function: Make the minimal position that contains all of the positions of all
supplied mappables.
Returns : Bio::Map::PositionI object or undef (if not all positions overlap)
Args : arg #1 = Bio::Map::MappableI OR Bio::Map::PositionI to compare
this one to, or an array ref of such objects (mandatory)
arg #2 = optionally, the key => value pairs below
-map => Bio::Map::MapI : optionally a Map to only consider
positions on the given map
-relative => Bio::Map::RelativeI : optionally a Relative to to ask
if the union of the Positions in
terms of their relative position
to the thing described by that
Relative
Methods code
get_position_handlerdescriptionprevnextTop
sub get_position_handler {
    my $self = shift;
    unless (defined $self->{_eh}) {
        my $ph = Bio::Map::PositionHandler->new(-self => $self);
        $self->{_eh} = $ph;
        $ph->register;
    }
    return $self->{_eh};
}
add_positiondescriptionprevnextTop
sub add_position {
    my $self = shift;
	# actually, we allow multiple positions to be set at once
$self->get_position_handler->add_positions(@_);
}
get_positionsdescriptionprevnextTop
sub get_positions {
    my ($self, $thing, $no_sort) = @_;
    my $map;
    if (ref($thing) && $thing->isa('Bio::Map::MapI')) {
        $map = $thing;
    }
    else {
        $no_sort = $thing;
    }
    my @positions = $self->get_position_handler->get_positions($map);
    return @positions if @positions == 1;
    
    unless ($no_sort) {
        # don't do
# @positions = sort { $a->sortable <=> $b->sortable } @positions;
# directly since sortable() can result in the call of another sort
# routine and cause problems; pre-compute sortable values instead
# (which is also more efficient)
@positions = map { $_->[1] } sort { $a->[0] <=> $b->[0] } map { [$_->sortable, $_] } @positions; } return @positions;
}
purge_positionsdescriptionprevnextTop
sub purge_positions {
    my ($self, $thing) = @_;
    $self->get_position_handler->purge_positions($thing);
}
known_mapsdescriptionprevnextTop
sub known_maps {
	my $self = shift;
	return $self->get_position_handler->get_other_entities;
}
namedescriptionprevnextTop
sub name {
    my $self = shift;
    $self->throw_not_implemented();
}
iddescriptionprevnextTop
sub id {
    my $self = shift;
    $self->throw_not_implemented();
}
in_mapdescriptionprevnextTop
sub in_map {
	my $self = shift;
	$self->throw_not_implemented();
}
equalsdescriptionprevnextTop
sub equals {
    my $self = shift;
    $self->throw_not_implemented();
}
overlapsdescriptionprevnextTop
sub overlaps {
    my $self = shift;
    $self->throw_not_implemented();
}
containsdescriptionprevnextTop
sub contains {
    my $self = shift;
    $self->throw_not_implemented();
}
intersectiondescriptionprevnextTop
sub intersection {
    my $self = shift;
    $self->throw_not_implemented();
}
uniondescriptionprevnextTop
sub union {
    my $self = shift;
    $self->throw_not_implemented();
}

1;
}
General documentation
FEEDBACKTop
Mailing ListsTop
User feedback is an integral part of the evolution of this and other
Bioperl modules. Send your comments and suggestions preferably to
the Bioperl mailing list. Your participation is much appreciated.
  bioperl-l@bioperl.org                  - General discussion
http://bioperl.org/wiki/Mailing_lists - About the mailing lists
Support Top
Please direct usage questions or support issues to the mailing list:
bioperl-l@bioperl.org
rather than to the module maintainer directly. Many experienced and
reponsive experts will be able look at the problem and quickly
address it. Please include a thorough description of the problem
with code and data examples if at all possible.
Reporting BugsTop
Report bugs to the Bioperl bug tracking system to help us keep track
of the bugs and their resolution. Bug reports can be submitted via the
web:
  https://redmine.open-bio.org/projects/bioperl/
AUTHOR - Jason StajichTop
Email jason@bioperl.org
CONTRIBUTORSTop
Heikki Lehvaslaiho heikki-at-bioperl-dot-org
Lincoln Stein lstein@cshl.org
Sendu Bala bix@sendu.me.uk
APPENDIXTop
The rest of the documentation details each of the object methods.
Internal methods are usually preceded with a _
EntityI methodsTop
 These are fundamental to coordination of Mappables and other entities, so are
implemented at the interface level
PositionHandlerI-related methodsTop
 These are fundamental to coordination of Mappables and other entities, so are
implemented at the interface level
each_positionTop
 Title   : each_position
Function: Synonym of the get_positions() method.
Status : deprecated, will be removed in next version
MappableI-specific methodsTop
RangeI-related MethodsTop
They throw an error if start and end are not defined in the Positions of the
Mappables supplied.