BioPerl
view release on metacpan or search on metacpan
Bio/Align/AlignI.pm view on Meta::CPAN
Returns : None
Argument : a Bio::LocatableSeq object
order (optional)
See L<Bio::LocatableSeq> for more information.
=cut
sub add_seq {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 remove_seq
Title : remove_seq
Usage : $aln->remove_seq($seq);
Function : Removes a single sequence from an alignment
Returns :
Argument : a Bio::LocatableSeq object
=cut
sub remove_seq {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 purge
Title : purge
Usage : $aln->purge(0.7);
Function:
Removes sequences above whatever %id.
Bio/Align/AlignI.pm view on Meta::CPAN
Example :
Returns : An array of the removed sequences
Argument:
=cut
sub purge {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 sort_alphabetically
Title : sort_alphabetically
Usage : $ali->sort_alphabetically
Function :
Changes the order of the alignment to alphabetical on name
followed by numerical by number.
Returns : an array
Argument :
=cut
sub sort_alphabetically {
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Sequence selection methods
Methods returning one or more sequences objects.
=head2 each_seq
Title : each_seq
Usage : foreach $seq ( $align->each_seq() )
Function : Gets an array of Seq objects from the alignment
Returns : an array
Argument :
=cut
sub each_seq {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 each_alphabetically
Title : each_alphabetically
Usage : foreach $seq ( $ali->each_alphabetically() )
Function :
Returns an array of sequence object sorted alphabetically
by name and then by start point.
Does not change the order of the alignment
Returns :
Argument :
=cut
sub each_alphabetically {
my($self) = @_;
$self->throw_not_implemented();
}
=head2 each_seq_with_id
Title : each_seq_with_id
Usage : foreach $seq ( $align->each_seq_with_id() )
Function :
Gets an array of Seq objects from the
alignment, the contents being those sequences
with the given name (there may be more than one)
Returns : an array
Argument : a seq name
=cut
sub each_seq_with_id {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 get_seq_by_pos
Title : get_seq_by_pos
Usage : $seq = $aln->get_seq_by_pos(3) # third sequence from the alignment
Function :
Gets a sequence based on its position in the alignment.
Numbering starts from 1. Sequence positions larger than
num_sequences() will throw an error.
Returns : a Bio::LocatableSeq object
Argument : positive integer for the sequence position
=cut
sub get_seq_by_pos {
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Create new alignments
The result of these methods are horizontal or vertical subsets of the
current MSE.
=head2 select
Title : select
Bio/Align/AlignI.pm view on Meta::CPAN
larger than num_sequences() will throw an error.
Returns : a Bio::SimpleAlign object
Argument : positive integer for the first sequence
positive integer for the last sequence to include (optional)
=cut
sub select {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 select_noncont
Title : select_noncont
Usage : $aln2 = $aln->select_noncont(1, 3) # first and 3rd sequences
Function :
Creates a new alignment from a subset of
sequences. Numbering starts from 1. Sequence positions
larger than num_sequences() will throw an error.
Returns : a Bio::SimpleAlign object
Args : array of integers for the sequences
=cut
sub select_noncont {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 slice
Title : slice
Usage : $aln2 = $aln->slice(20, 30)
Function :
Creates a slice from the alignment inclusive of start and
end columns. Sequences with no residues in the slice are
Bio/Align/AlignI.pm view on Meta::CPAN
padding.
Returns : a Bio::SimpleAlign object
Argument : positive integer for start column
positive integer for end column
=cut
sub slice {
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Change sequences within the MSE
These methods affect characters in all sequences without changing the
alignment.
=head2 map_chars
Bio/Align/AlignI.pm view on Meta::CPAN
$ali->map_chars('.', '-') won't do what you want)
Returns : None
Argument : 'from' rexexp
'to' string
=cut
sub map_chars {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 uppercase
Title : uppercase()
Usage : $ali->uppercase()
Function : Sets all the sequences to uppercase
Returns :
Argument :
=cut
sub uppercase {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 match_line
Title : match_line()
Usage : $align->match_line()
Function : Generates a match line - much like consensus string
except that a line indicating the '*' for a match.
Argument : (optional) Match line characters ('*' by default)
(optional) Strong match char (':' by default)
(optional) Weak match char ('.' by default)
=cut
sub match_line {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 match
Title : match()
Usage : $ali->match()
Function :
Goes through all columns and changes residues that are
identical to residue in first sequence to match '.'
Bio/Align/AlignI.pm view on Meta::CPAN
only. NEXUS format (Bio::AlignIO::nexus) can handle
it.
Returns : 1
Argument : a match character, optional, defaults to '.'
=cut
sub match {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 unmatch
Title : unmatch()
Usage : $ali->unmatch()
Function :
Undoes the effect of method match. Unsets match_char.
Returns : 1
Argument : a match character, optional, defaults to '.'
=cut
sub unmatch {
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 MSE attibutes
Methods for setting and reading the MSE attributes.
Note that the methods defining character semantics depend on the user
to set them sensibly. They are needed only by certain input/output
methods. Unset them by setting to an empty string ('').
Bio/Align/AlignI.pm view on Meta::CPAN
Title : id
Usage : $myalign->id("Ig")
Function : Gets/sets the id field of the alignment
Returns : An id string
Argument : An id string (optional)
=cut
sub id {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 missing_char
Title : missing_char
Usage : $myalign->missing_char("?")
Function : Gets/sets the missing_char attribute of the alignment
It is generally recommended to set it to 'n' or 'N'
for nucleotides and to 'X' for protein.
Returns : An missing_char string,
Argument : An missing_char string (optional)
=cut
sub missing_char {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 match_char
Title : match_char
Usage : $myalign->match_char('.')
Function : Gets/sets the match_char attribute of the alignment
Returns : An match_char string,
Argument : An match_char string (optional)
=cut
sub match_char {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 gap_char
Title : gap_char
Usage : $myalign->gap_char('-')
Function : Gets/sets the gap_char attribute of the alignment
Returns : An gap_char string, defaults to '-'
Argument : An gap_char string (optional)
=cut
sub gap_char {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 symbol_chars
Title : symbol_chars
Usage : my @symbolchars = $aln->symbol_chars;
Function: Returns all the seen symbols (other than gaps)
Returns : array of characters that are the seen symbols
Argument: boolean to include the gap/missing/match characters
=cut
sub symbol_chars{
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Alignment descriptors
These read only methods describe the MSE in various ways.
=head2 consensus_string
Title : consensus_string
Bio/Align/AlignI.pm view on Meta::CPAN
Argument : Optional threshold ranging from 0 to 100.
The consensus residue has to appear at least threshold %
of the sequences at a given location, otherwise a '?'
character will be placed at that location.
(Default value = 0%)
=cut
sub consensus_string {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 consensus_iupac
Title : consensus_iupac
Usage : $str = $ali->consensus_iupac()
Function :
Makes a consensus using IUPAC ambiguity codes from DNA
and RNA. The output is in upper case except when gaps in
Bio/Align/AlignI.pm view on Meta::CPAN
Returns : consensus string
Argument : none
Throws : on protein sequences
=cut
sub consensus_iupac {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 is_flush
Title : is_flush
Usage : if( $ali->is_flush() )
:
:
Function : Tells you whether the alignment
: is flush, ie all of the same length
:
:
Returns : 1 or 0
Argument :
=cut
sub is_flush {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 length
Title : length()
Usage : $len = $ali->length()
Function : Returns the maximum length of the alignment.
To be sure the alignment is a block, use is_flush
Returns : integer
Argument :
=cut
sub length {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 maxname_length
Title : maxname_length
Usage : $ali->maxname_length()
Function :
Gets the maximum length of the displayname in the
alignment. Used in writing out various MSE formats.
Returns : integer
Argument :
=cut
sub maxname_length {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 num_residues
Title : num_residues
Usage : $no = $ali->num_residues
Function : number of residues in total in the alignment
Returns : integer
Argument :
Note : replaces no_residues
=cut
sub num_residues {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 num_sequences
Title : num_sequences
Usage : $depth = $ali->num_sequences
Function : number of sequence in the sequence alignment
Returns : integer
Argument : None
Note : replaces no_sequences
=cut
sub num_sequences {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 percentage_identity
Title : percentage_identity
Usage : $id = $align->percentage_identity
Function: The function calculates the percentage identity of the alignment
Returns : The percentage identity of the alignment (as defined by the
implementation)
Argument: None
=cut
sub percentage_identity{
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 overall_percentage_identity
Title : overall_percentage_identity
Usage : $id = $align->overall_percentage_identity
Function: The function calculates the percentage identity of
the conserved columns
Returns : The percentage identity of the conserved columns
Args : None
=cut
sub overall_percentage_identity{
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 average_percentage_identity
Title : average_percentage_identity
Usage : $id = $align->average_percentage_identity
Function: The function uses a fast method to calculate the average
percentage identity of the alignment
Returns : The average percentage identity of the alignment
Args : None
=cut
sub average_percentage_identity{
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Alignment positions
Methods to map a sequence position into an alignment column and back.
column_from_residue_number() does the former. The latter is really a
property of the sequence object and can done using
L<Bio::LocatableSeq::location_from_column>:
# select somehow a sequence from the alignment, e.g.
Bio/Align/AlignI.pm view on Meta::CPAN
Returns : A column number for the position in the alignment of the
given residue in the given sequence (1 = first column)
Args : A sequence id/name (not a name/start-end)
A residue number in the whole sequence (not just that
segment of it in the alignment)
=cut
sub column_from_residue_number {
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Sequence names
Methods to manipulate the display name. The default name based on the
sequence id and subsequence positions can be overridden in various
ways.
=head2 displayname
Bio/Align/AlignI.pm view on Meta::CPAN
Function : Gets/sets the display name of a sequence in the alignment
:
Returns : A display name string
Argument : name of the sequence
displayname of the sequence (optional)
=cut
sub displayname {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 set_displayname_count
Title : set_displayname_count
Usage : $ali->set_displayname_count
Function :
Sets the names to be name_# where # is the number of
times this name has been used.
Returns : None
Argument : None
=cut
sub set_displayname_count {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 set_displayname_flat
Title : set_displayname_flat
Usage : $ali->set_displayname_flat()
Function : Makes all the sequences be displayed as just their name,
not name/start-end
Returns : 1
Argument : None
=cut
sub set_displayname_flat {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 set_displayname_normal
Title : set_displayname_normal
Usage : $ali->set_displayname_normal()
Function : Makes all the sequences be displayed as name/start-end
Returns : None
Argument : None
=cut
sub set_displayname_normal {
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Deprecated methods
=head2 no_residues
Title : no_residues
Usage : $no = $ali->no_residues
Function : number of residues in total in the alignment
Returns : integer
Bio/Align/DNAStatistics.pm view on Meta::CPAN
alignment using the Felsenstein 1984 distance model.
Returns : L<Bio::Matrix::PhylipDist>
Args : L<Bio::Align::AlignI> of DNA sequences
[optional] double - gap penalty
=cut
sub D_F84 {
my ($self,$aln,$gappenalty) = @_;
return 0 unless $self->_check_arg($aln);
$self->throw_not_implemented();
# ambiguities ignored at this point
my (@seqs,@names,@values,%dist);
my $seqct = 0;
foreach my $seq ( $aln->each_seq) {
# if there is no name,
my $id = $seq->display_id;
if( ! length($id) || # deal with empty names
$id =~ /^\s+$/ ) {
$id = $seqct+1;
}
Bio/Align/StatisticsI.pm view on Meta::CPAN
sequences in an alignment.
Returns : Array ref
Args : -align => Bio::Align::AlignI object
-method => String specifying specific distance method
(implementing class may assume a default)
=cut
sub distance{
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 available_distance_methods
Title : available_distance_methods
Usage : my @methods = $stats->available_distance_methods();
Function: Enumerates the possible distance methods
Returns : Array of strings
Args : none
=cut
sub available_distance_methods{
my ($self,@args) = @_;
$self->throw_not_implemented();
}
1;
Bio/AlignIO/arp.pm view on Meta::CPAN
Function: writes the $aln object into the stream in xmfa format
Returns : 1 for success and 0 for error
Args : L<Bio::Align::AlignI> object
See L<Bio::Align::AlignI>
=cut
sub write_aln {
my ($self,@aln) = @_;
$self->throw_not_implemented;
}
################ PRIVATE SUBS ################
sub _process_sequence {
my ($self, $raw) = @_;
return unless defined $raw;
$raw =~ s{(?:^\s+|\s+$)}{}g;
my ($id, $samples, $seq) = split(' ', $raw);
my $ls = Bio::LocatableSeq->new('-seq' => $seq,
Bio/AlignIO/bl2seq.pm view on Meta::CPAN
Usage : $stream->write_aln(@aln)
Function: writes the $aln object into the stream in bl2seq format
Returns : 1 for success and 0 for error
Args : L<Bio::Align::AlignI> object
=cut
sub write_aln {
my ($self,@aln) = @_;
$self->throw_not_implemented();
}
=head2 report_type
Title : report_type
Usage : $obj->report_type($newval)
Function: Sets the report type (blastn, blastp...)
Returns : value of report_type (a scalar)
Args : on set, new value (a scalar or undef, optional)
Bio/AlignIO/maf.pm view on Meta::CPAN
'-alphabet' => $self->alphabet,
);
$aln->add_seq($seq);
}
return $aln if $aln->num_sequences;
return;
}
sub write_aln {
shift->throw_not_implemented
}
1;
Bio/AlignIO/mase.pm view on Meta::CPAN
Usage : $stream->write_aln(@aln)
Function: writes the $aln object into the stream in mase format ###Not yet implemented!###
Returns : 1 for success and 0 for error
Args : L<Bio::Align::AlignI> object
=cut
sub write_aln {
my ($self,@aln) = @_;
$self->throw_not_implemented();
}
1;
Bio/AlignIO/meme.pm view on Meta::CPAN
Title : write_aln
Usage : $stream->write_aln(@aln)
Function: Not implemented
Returns : 1 for success and 0 for error
Args : Bio::SimpleAlign object
=cut
sub write_aln {
my ( $self, @aln ) = @_;
$self->throw_not_implemented();
}
# ----------------------------------------
# - Private methods
# ----------------------------------------
sub _initialize {
my ( $self, @args ) = @_;
# Call into our base version
Bio/AlignIO/proda.pm view on Meta::CPAN
Title : write_aln
Usage : $stream->write_aln(@aln)
Function: writes the proda-format object (.aln) into the stream
Returns : 1 for success and 0 for error
Args : Bio::Align::AlignI object
=cut
sub write_aln {
my ($self,@aln) = @_;
$self->throw_not_implemented();
}
=head2 percentages
Title : percentages
Usage : $obj->percentages($newval)
Function: Set the percentages flag - whether or not to show percentages in
each output line
Returns : value of percentages
Args : newvalue (optional)
Bio/AlignIO/prodom.pm view on Meta::CPAN
Usage : $stream->write_aln(@aln)
Function: writes the $aln object into the stream in prodom format ###Not yet implemented!###
Returns : 1 for success and 0 for error
Args : L<Bio::Align::AlignI> object
=cut
sub write_aln {
my ($self,@aln) = @_;
$self->throw_not_implemented();
}
1;
Bio/AnalysisI.pm view on Meta::CPAN
# -----------------------------------------------------------------------------
=head2 analysis_name
Usage : $tool->analysis_name;
Returns : a name of this analysis
Args : none
=cut
sub analysis_name { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 analysis_spec
Usage : $tool->analysis_spec;
Returns : a hash reference describing this analysis
Args : none
The returned hash reference uses the following keys (not all of them always
Bio/AnalysisI.pm view on Meta::CPAN
Analysis 'edit.seqret':
installation => EMBL-EBI
description => Reads and writes (returns) sequences
supplier => EMBOSS
version => 2.6.0
type => edit
name => seqret
=cut
sub analysis_spec { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 describe
Usage : $tool->analysis_spec;
Returns : an XML detailed description of this analysis
Args : none
The returned XML string contains metadata describing this analysis
Bio/AnalysisI.pm view on Meta::CPAN
<!ATTLIST output
type CDATA #REQUIRED
name CDATA #REQUIRED>
But the DTD may be extended by provider-specific metadata. For
example, the EBI experimental SOAP-based service on top of EMBOSS uses
DTD explained at C<http://www.ebi.ac.uk/~senger/applab>.
=cut
sub describe { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 input_spec
Usage : $tool->input_spec;
Returns : an array reference with hashes as elements
Args : none
The analysis input data are named, and can be also associated with a
Bio/AnalysisI.pm view on Meta::CPAN
...
'raw'
],
'type' => 'String',
'name' => 'osformat'
}
];
=cut
sub input_spec { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 result_spec
Usage : $tool->result_spec;
Returns : a hash reference with result names as keys
and result types as values
Args : none
Bio/AnalysisI.pm view on Meta::CPAN
I<edit.seqret>):
$result_spec = {
'outseq' => 'String',
'report' => 'String',
'detailed_status' => 'String'
};
=cut
sub result_spec { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 create_job
Usage : $tool->create_job ( {'sequence'=>'tatat'} )
Returns : Bio::Tools::Run::Analysis::Job
Args : data and parameters for this execution
(in various formats)
Bio/AnalysisI.pm view on Meta::CPAN
=item undef
Finally, if the parameter is undefined, ask server to create an empty
job. The input data may be added later using C<set_data...>
method(s) - see scripts/papplmaker.PLS for details.
=back
=cut
sub create_job { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 run
Usage : $tool->run ( ['sequence=@my.seq', 'osformat=embl'] )
Returns : Bio::Tools::Run::Analysis::Job,
representing started job (an execution)
Args : the same as for create_job
Create a job and start it, but do not wait for its completion.
=cut
sub run { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 wait_for
Usage : $tool->wait_for ( { 'sequence' => '@my,file' } )
Returns : Bio::Tools::Run::Analysis::Job,
representing finished job
Args : the same as for create_job
Bio/AnalysisI.pm view on Meta::CPAN
Note that this is a blocking method. It returns only after the
executed job finishes, either normally or by an error.
Usually, after this call, you ask for results of the finished job:
$analysis->wait_for (...)->results;
=cut
sub wait_for { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
#
# Bio::AnalysisI::JobI
#
# -----------------------------------------------------------------------------
package Bio::AnalysisI::JobI;
=head1 Module Bio::AnalysisI::JobI
Bio/AnalysisI.pm view on Meta::CPAN
Args : none
Each job (an execution) is identifiable by this unique ID which can be
used later to re-create the same job (in other words: to re-connect to
the same job). It is useful in cases when a job takes long time to
finish and your client program does not want to wait for it within the
same session.
=cut
sub id { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 Bio::AnalysisI::JobI::run
Usage : $job->run
Returns : itself
Args : none
It starts previously created job. The job already must have all input
data filled-in. This differs from the method of the same name of the
C<Bio::Tools::Run::Analysis> object where the C<Bio::AnalysisI::JobI::run> method
creates also a new job allowing to set input data.
=cut
sub run { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 Bio::AnalysisI::JobI::wait_for
Usage : $job->wait_for
Returns : itself
Args : none
It waits until a previously started execution of this job finishes.
=cut
sub wait_for { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 terminate
Usage : $job->terminate
Returns : itself
Args : none
Stop the currently running job (represented by this object). This is a
definitive stop, there is no way to resume it later.
=cut
sub terminate { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 last_event
Usage : $job->last_event
Returns : an XML string
Args : none
It returns a short XML document showing what happened last with this
Bio/AnalysisI.pm view on Meta::CPAN
->last_event;
<?xml version = "1.0"?>
<analysis_event>
<message>Mar 3, 2003 5:17:14 PM (Europe/London)</message>
<state_changed previous_state="running" new_state="completed"/>
</analysis_event>
=cut
sub last_event { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 status
Usage : $job->status
Returns : string describing the job status
Args : none
It returns one of the following strings (and perhaps more if a server
implementation extended possible job states):
CREATED
RUNNING
COMPLETED
TERMINATED_BY_REQUEST
TERMINATED_BY_ERROR
=cut
sub status { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 created
Usage : $job->created (1)
Returns : time when this job was created
Args : optional
Without any argument it returns a time of creation of this job in
seconds, counting from the beginning of the UNIX epoch
(1.1.1970). With a true argument it returns a formatted time, using
rules described in C<Bio::Tools::Run::Analysis::Utils::format_time>.
=cut
sub created { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 started
Usage : $job->started (1)
Returns : time when this job was started
Args : optional
See C<created>.
=cut
sub started { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 ended
Usage : $job->ended (1)
Returns : time when this job was terminated
Args : optional
See C<created>.
=cut
sub ended { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 elapsed
Usage : $job->elapsed
Returns : elapsed time of the execution of the given job
(in milliseconds), or 0 of job was not yet started
Args : none
Note that some server implementations cannot count in millisecond - so
the returned time may be rounded to seconds.
=cut
sub elapsed { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 times
Usage : $job->times ('formatted')
Returns : a hash reference with all time characteristics
Args : optional
It is a convenient method returning a hash reference with the following
Bio/AnalysisI.pm view on Meta::CPAN
};
$Times = {
'ended' => '1046713961',
'started' => '1046713926',
'elapsed' => '35000',
'created' => '1046713926'
};
=cut
sub times { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 results
Usage : $job->results (...)
Returns : one or more results created by this job
Args : various, see belou
This is a complex method trying to make sense for all kinds of
Bio/AnalysisI.pm view on Meta::CPAN
* any result can be returned as a scalar value, or as an array reference
(the latter is used for results consisting of more parts, such images);
this applies regardless whether the returned result is the result itself
or a filename created for the result
* look in the documentation of the C<panalysis[.PLS]> script for examples
(especially how to use various templates for inventing file names)
=cut
sub results { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 result
Usage : $job->result (...)
Returns : the first result
Args : see 'results'
=cut
sub result { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
=head2 remove
Usage : $job->remove
Returns : 1
Args : none
The job object is not actually removed in this time but it is marked
(setting 1 to C<_destroy_on_exit> attribute) as ready for deletion when
the client program ends (including a request to server to forget the job
mirror object on the server side).
=cut
sub remove { shift->throw_not_implemented(); }
# -----------------------------------------------------------------------------
1;
__END__
Bio/AnalysisParserI.pm view on Meta::CPAN
undef if there are no more results.
Example :
Returns : A Bio::Search::Result::ResultI implementing object,
or undef if there are no more results.
Args : none
=cut
sub next_result {
my ($self);
$self->throw_not_implemented;
}
1;
__END__
NOTE (sac): My ten-month old son Russell added the following line.
It doesn't look like it will compile so I'm putting it here:
mt6 j7qa
Bio/AnalysisResultI.pm view on Meta::CPAN
Argument : n/a
Returns : A Bio::PrimarySeqI-compatible object without sequence information.
The sequence will have display_id, description, moltype, and length data.
=cut
#---------------------
sub analysis_query {
#---------------------
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 analysis_subject
Usage : $obj = $result->analyis_subject();
Purpose : Get the subject of the analysis against which it was
performed. For similarity searches it will probably be a database,
and for sequence feature predictions (exons, promoters, etc) it
may be a collection of models or homologous sequences that were
Bio/AnalysisResultI.pm view on Meta::CPAN
Purpose : Get the date on which the analysis was performed.
Returns : String
Argument : n/a
=cut
#---------------------
sub analysis_date {
#---------------------
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 analysis_method
Usage : $meth = $result->analysis_method();
Purpose : Get the name of the sequence analysis method that was used
to produce this result (BLASTP, FASTA, etc.). May also be the
actual name of a program.
Returns : String
Argument : n/a
=cut
#-------------
sub analysis_method {
#-------------
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 analysis_method_version
Usage : $vers = $result->analysis_method_version();
Purpose : Get the version string of the analysis program.
: (e.g., 1.4.9MP, 2.0a19MP-WashU).
Returns : String
Argument : n/a
=cut
#---------------------
sub analysis_method_version {
#---------------------
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 next_feature
Title : next_feature
Usage : $seqfeature = $obj->next_feature();
Function: Returns the next feature available in the analysis result, or
undef if there are no more features.
Example :
Returns : A Bio::SeqFeatureI implementing object, or undef if there are no
more features.
Args : none
=cut
#---------------------
sub next_feature {
#---------------------
my ($self);
$self->throw_not_implemented;
}
1;
Bio/AnnotatableI.pm view on Meta::CPAN
Returns : a Bio::AnnotationCollectionI implementing object, or undef
Args : on set, new value (a Bio::AnnotationCollectionI
implementing object, optional) (an implementation may not
support changing the annotation collection)
See L<Bio::AnnotationCollectionI>
=cut
sub annotation{
shift->throw_not_implemented();
}
1;
Bio/AnnotationCollectionI.pm view on Meta::CPAN
=head2 get_all_annotation_keys()
Usage : $ac->get_all_annotation_keys()
Function: gives back a list of annotation keys, which are simple text strings
Returns : list of strings
Args : none
=cut
sub get_all_annotation_keys{
shift->throw_not_implemented();
}
=head2 get_Annotations()
Usage : my @annotations = $collection->get_Annotations('key')
Function: Retrieves all the Bio::AnnotationI objects for a specific key
Returns : list of Bio::AnnotationI - empty if no objects stored for a key
Args : string which is key for annotations
=cut
sub get_Annotations{
shift->throw_not_implemented();
}
=head2 add_Annotation()
Usage : $self->add_Annotation('reference',$object);
$self->add_Annotation($object,'Bio::MyInterface::DiseaseI');
$self->add_Annotation($object);
$self->add_Annotation('disease',$object,'Bio::MyInterface::DiseaseI');
Function: Adds an annotation for a specific key.
Bio/AnnotationCollectionI.pm view on Meta::CPAN
Returns : none
Args : annotation key ('disease', 'dblink', ...)
object to store (must be Bio::AnnotationI compliant)
[optional] object archetype to map future storage of object
of these types to
=cut
sub add_Annotation {
shift->throw_not_implemented();
}
=head2 remove_Annotations()
Usage :
Function: Remove the annotations for the specified key from this collection.
Returns : an list of Bio::AnnotationI compliant objects which were stored
under the given key(s)
Args : the key(s) (tag name(s), one or more strings) for which to
remove annotations (optional; if none given, flushes all
annotations)
=cut
sub remove_Annotations{
shift->throw_not_implemented();
}
=head2 get_num_of_annotations()
Usage : my $count = $collection->get_num_of_annotations()
Function: Returns the count of all annotations stored in this collection
Returns : integer
Args : none
=cut
sub get_num_of_annotations{
shift->throw_not_implemented();
}
1;
Bio/AnnotationI.pm view on Meta::CPAN
annotation, mainly for human readability. It is not aimed
at being able to store/represent the annotation.
Example :
Returns : a string
Args : none
=cut
sub as_text{
shift->throw_not_implemented();
}
=head2 display_text
Title : display_text
Usage : my $str = $ann->display_text();
Function: returns a string. Unlike as_text(), this method returns a string
formatted as would be expected for the specific implementation.
Implementations should allow passing a callback as an argument which
Bio/AnnotationI.pm view on Meta::CPAN
of the annotation data but probably shouldn't be used in cases
where more complex comparisons are needed or where data is
stored.
Example :
Returns : a string
Args : [optional] callback
=cut
sub display_text {
shift->throw_not_implemented();
}
=head2 hash_tree
Title : hash_tree
Usage :
Function: should return an anonymous hash with "XML-like" formatting
Example :
Returns : a hash reference
Args : none
=cut
sub hash_tree{
shift->throw_not_implemented();
}
=head2 tagname
Title : tagname
Usage : $obj->tagname($newval)
Function: Get/set the tagname for this annotation value.
Setting this is optional. If set, it obviates the need to
provide a tag to Bio::AnnotationCollectionI when adding
Bio/AnnotationI.pm view on Meta::CPAN
stored already.
Example :
Returns : value of tagname (a scalar)
Args : new value (a scalar, optional)
=cut
sub tagname{
shift->throw_not_implemented();
}
1;
Bio/Assembly/Contig.pm view on Meta::CPAN
Example :
Returns : An array of the removed sequences
Argument:
=cut
sub purge {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 sort_alphabetically
Title : sort_alphabetically
Usage : $contig->sort_alphabetically
Function :
Changes the order of the alignment to alphabetical on name
followed by numerical by number.
Returns :
Argument :
=cut
sub sort_alphabetically {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 Sequence selection methods
Methods returning one or more sequences objects.
=head2 each_seq
Title : each_seq
Usage : foreach $seq ( $contig->each_seq() )
Bio/Assembly/Contig.pm view on Meta::CPAN
by name and then by start point.
Does not change the order of the alignment
Returns :
Argument :
=cut
sub each_alphabetically {
my($self) = @_;
$self->throw_not_implemented();
}
=head2 each_seq_with_id
Title : each_seq_with_id
Usage : foreach $seq ( $contig->each_seq_with_id() )
Function :
Gets an array of Seq objects from the
alignment, the contents being those sequences
with the given name (there may be more than one)
Returns : an array
Argument : a seq name
=cut
sub each_seq_with_id {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 get_seq_by_pos
Title : get_seq_by_pos
Usage : $seq = $contig->get_seq_by_pos(3)
Function :
Gets a sequence based on its position in the alignment.
Numbering starts from 1. Sequence positions larger than
Bio/Assembly/Contig.pm view on Meta::CPAN
larger than num_sequences() will thow an error.
Returns : a Bio::Assembly::Contig object
Argument : positive integer for the first sequence
positive integer for the last sequence to include (optional)
=cut
sub select {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 select_noncont
Title : select_noncont
Usage : $contig2 = $contig->select_noncont(1, 3) # first and 3rd sequences
Function :
Creates a new alignment from a subset of
sequences. Numbering starts from 1. Sequence positions
larger than num_sequences() will throw an error.
Returns : a Bio::Assembly::Contig object
Args : array of integers for the sequences
=cut
sub select_noncont {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 slice
Title : slice
Usage : $contig2 = $contig->slice(20, 30)
Function :
Creates a slice from the alignment inclusive of start and
end columns. Sequences with no residues in the slice are
Bio/Assembly/Contig.pm view on Meta::CPAN
padding.
Returns : a Bio::Assembly::Contig object
Argument : positive integer for start column
positive integer for end column
=cut
sub slice {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 Change sequences within the MSE
These methods affect characters in all sequences without changeing the
alignment.
=head2 map_chars
Bio/Assembly/Contig.pm view on Meta::CPAN
$contig->map_chars('.','-') won't do what you want)
Returns :
Argument : 'from' rexexp
'to' string
=cut
sub map_chars {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 uppercase
Title : uppercase()
Usage : $contig->uppercase()
Function : Sets all the sequences to uppercase
Returns :
Argument :
=cut
sub uppercase {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 match_line
Title : match_line()
Usage : $contig->match_line()
Function : Generates a match line - much like consensus string
except that a line indicating the '*' for a match.
Argument : (optional) Match line characters ('*' by default)
(optional) Strong match char (':' by default)
(optional) Weak match char ('.' by default)
=cut
sub match_line {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 match
Title : match()
Usage : $contig->match()
Function :
Goes through all columns and changes residues that are
identical to residue in first sequence to match '.'
Bio/Assembly/Contig.pm view on Meta::CPAN
only. NEXUS format (Bio::AlignIO::nexus) can handle
it.
Returns : 1
Argument : a match character, optional, defaults to '.'
=cut
sub match {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 unmatch
Title : unmatch()
Usage : $contig->unmatch()
Function :
Undoes the effect of method match. Unsets match_char.
Returns : 1
Argument : a match character, optional, defaults to '.'
=cut
sub unmatch {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 MSE attibutes
Methods for setting and reading the MSE attributes.
Note that the methods defining character semantics depend on the user
to set them sensibly. They are needed only by certain input/output
methods. Unset them by setting to an empty string ('').
Bio/Assembly/Contig.pm view on Meta::CPAN
Function : Gets/sets the missing_char attribute of the alignment
It is generally recommended to set it to 'n' or 'N'
for nucleotides and to 'X' for protein.
Returns : An missing_char string,
Argument : An missing_char string (optional)
=cut
sub missing_char {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 match_char
Title : match_char
Usage : $contig->match_char('.')
Function : Gets/sets the match_char attribute of the alignment
Returns : An match_char string,
Argument : An match_char string (optional)
=cut
sub match_char {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 gap_char
Title : gap_char
Usage : $contig->gap_char('-')
Function : Gets/sets the gap_char attribute of the alignment
Returns : An gap_char string, defaults to '-'
Argument : An gap_char string (optional)
=cut
sub gap_char {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 symbol_chars
Title : symbol_chars
Usage : my @symbolchars = $contig->symbol_chars;
Function: Returns all the seen symbols (other than gaps)
Returns : array of characters that are the seen symbols
Argument: boolean to include the gap/missing/match characters
=cut
sub symbol_chars{
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 Alignment descriptors
These read only methods describe the MSE in various ways.
=head2 consensus_string
Title : consensus_string
Bio/Assembly/Contig.pm view on Meta::CPAN
Argument : Optional threshold ranging from 0 to 100.
The consensus residue has to appear at least threshold %
of the sequences at a given location, otherwise a '?'
character will be placed at that location.
(Default value = 0%)
=cut
sub consensus_string {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 consensus_iupac
Title : consensus_iupac
Usage : $str = $contig->consensus_iupac()
Function :
Makes a consensus using IUPAC ambiguity codes from DNA
and RNA. The output is in upper case except when gaps in
Bio/Assembly/Contig.pm view on Meta::CPAN
Returns : consensus string
Argument : none
Throws : on protein sequences
=cut
sub consensus_iupac {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 is_flush
Title : is_flush
Usage : if( $contig->is_flush() )
:
:
Function : Tells you whether the alignment
: is flush, ie all of the same length
:
:
Returns : 1 or 0
Argument :
=cut
sub is_flush {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 length
Title : length()
Usage : $len = $contig->length()
Function : Returns the maximum length of the alignment.
To be sure the alignment is a block, use is_flush
Returns :
Argument :
=cut
sub length {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 maxname_length
Title : maxname_length
Usage : $contig->maxname_length()
Function :
Gets the maximum length of the displayname in the
alignment. Used in writing out various MSE formats.
Returns : integer
Argument :
=cut
sub maxname_length {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 num_residues
Title : num_residues
Usage : $no = $contig->num_residues
Function : number of residues in total in the alignment
Returns : integer
Argument :
Note : replaces no_residues
Bio/Assembly/Contig.pm view on Meta::CPAN
Usage : $id = $contig->percentage_identity
Function: The function calculates the percentage identity of the alignment
Returns : The percentage identity of the alignment (as defined by the
implementation)
Argument: None
=cut
sub percentage_identity{
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 overall_percentage_identity
Title : percentage_identity
Usage : $id = $contig->percentage_identity
Function: The function calculates the percentage identity of
the conserved columns
Returns : The percentage identity of the conserved columns
Args : None
=cut
sub overall_percentage_identity{
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 average_percentage_identity
Title : average_percentage_identity
Usage : $id = $contig->average_percentage_identity
Function: The function uses a fast method to calculate the average
percentage identity of the alignment
Returns : The average percentage identity of the alignment
Args : None
=cut
sub average_percentage_identity {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 Alignment positions
Methods to map a sequence position into an alignment column and back.
column_from_residue_number() does the former. The latter is really a
property of the sequence object and can done using
L<Bio::LocatableSeq::location_from_column>:
# select somehow a sequence from the alignment, e.g.
Bio/Assembly/Contig.pm view on Meta::CPAN
Returns : A column number for the position in the alignment of the
given residue in the given sequence (1 = first column)
Args : A sequence id/name (not a name/start-end)
A residue number in the whole sequence (not just that
segment of it in the alignment)
=cut
sub column_from_residue_number {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 Sequence names
Methods to manipulate the display name. The default name based on the
sequence id and subsequence positions can be overridden in various
ways.
=head2 displayname
Bio/Assembly/Contig.pm view on Meta::CPAN
Sets the names to be name_# where # is the number of
times this name has been used.
Returns : None
Argument : None
=cut
sub set_displayname_count {
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 set_displayname_flat
Title : set_displayname_flat
Usage : $contig->set_displayname_flat()
Function : Makes all the sequences be displayed as just their name,
not name/start-end
Returns : 1
Argument : None
Bio/Assembly/ContigAnalysis.pm view on Meta::CPAN
$lcq_start = $self->{'_objref'}->change_coord('gapped consensus','ungapped consensus',$lcq_start);
my $lcq_end = $self->{'_objref'}->change_coord('gapped consensus','ungapped consensus',$i);
push(@LCQ, Bio::SeqFeature::Generic->new(-start=>$lcq_start,
-end=>$lcq_end,
-primary=>'low_consensus_quality') );
}
return @LCQ;
}
=head2 not_confirmed_on_both_strands
Title : low_quality_consensus
Usage : my $sfc = $ContigAnal->low_quality_consensus();
Function :
Locates all regions whose consensus bases were not
confirmed by bases from sequences aligned in both
orientations, i.e., in such regions, no bases in aligned
sequences of either +1 or -1 strand agree with the
consensus bases.
Returns : an array of Bio::SeqFeature::Generic objects
Args : optional arguments are
-start : start of interval that will be analyzed
-end : start of interval that will be analyzed
-type : coordinate system type for interval
=cut
sub not_confirmed_on_both_strands {
my ($self,@args) = shift; # Package reference
my ($start,$end,$type) =
$self->_rearrange([qw(START END TYPE)],@args);
# Changing coordinates to default system 'align' (contig sequence with alignments)
$start = 1 unless (defined($start));
if (defined($type) && ($type ne 'gapped consensus')) {
$start = $self->{'_objref'}->change_coord($type,'gapped consensus',$start);
$end = $self->{'_objref'}->change_coord($type,'gapped consensus',$end) if (defined($end));
Bio/Assembly/ContigAnalysis.pm view on Meta::CPAN
if (!defined($ncbs_start) &&
(!defined($confirmed{$orientation}[$i]) || ($confirmed{$orientation}[$i] == 0))) {
$ncbs_start = $self->{'_objref'}->change_coord('gapped consensus','ungapped consensus',$i);
} elsif (defined($ncbs_start) &&
defined($confirmed{$orientation}[$i]) &&
($confirmed{$orientation}[$i] > 0)) {
$ncbs_end = $self->{'_objref'}->change_coord('gapped consensus','ungapped consensus',$i-1);
push(@NCBS, Bio::SeqFeature::Generic->new(-start=>$ncbs_start,
-end=>$ncbs_end,
-strand=>$orientation,
-primary=>"not_confirmed_on_both_strands") );
$ncbs_start = undef;
}
}
if (defined($ncbs_start)) { # NCBS at the end of contig
$ncbs_end = $self->{'_objref'}->change_coord('gapped consensus','ungapped consensus',$end);
push(@NCBS, Bio::SeqFeature::Generic->new(-start=>$ncbs_start,
-end=>$ncbs_end,
-strand=>$orientation,
-primary=>'not_confirmed_on_both_strands') );
}
}
return @NCBS;
}
=head2 single_strand
Title : single_strand
Usage : my $sfc = $ContigAnal->single_strand();
Bio/Assembly/ContigAnalysis.pm view on Meta::CPAN
Function : Merge all overlapping features into features
that hold original features as sub-features
Returns : array of Bio::SeqFeature::Generic objects
Args : array of Bio::SeqFeature::Generic objects
=cut
sub _merge_overlapping_features {
my ($self,@feat) = @_;
$self->throw_not_implemented();
}
=head2 _complementary_features_list
Title : _complementary_features_list
Usage : @feat = $ContigAnal->_complementary_features_list($start,$end,@features);
Function : Build a list of features for regions
not covered by features in @features array
Returns : array of Bio::SeqFeature::Generic objects
Args :
$start : [integer] start of first output feature
$end : [integer] end of last output feature
@features : array of Bio::SeqFeature::Generic objects
=cut
sub _complementary_features_list {
my ($self,$start,$end,@feat) = @_;
$self->throw_not_implemented();
}
1;
__END__
Bio/Assembly/IO/phrap.pm view on Meta::CPAN
Title : write_assembly
Usage : $ass_io->write_assembly($assembly)
Function: Write the assembly object in Phrap compatible ACE format
Returns : 1 on success, 0 for error
Args : A Bio::Assembly::Scaffold object
=cut
sub write_assembly {
my $self = shift;
$self->throw_not_implemented();
}
1;
__END__
Bio/Assembly/ScaffoldI.pm view on Meta::CPAN
Usage : $assembly->get_nof_contigs()
Function: Get the number of contigs included in the assembly
Returns : integer
Args : none
=cut
sub get_nof_contigs {
my $self = shift;
$self->throw_not_implemented();
}
=head2 get_nof_singlets
Title : get_nof_singlets
Usage : $assembly->get_nof_singlets()
Function: Get the number of singlets included in the assembly
Returns : integer
Args : none
=cut
sub get_nof_singlets {
my $self = shift;
$self->throw_not_implemented();
}
=head2 get_contig_ids
Title : get_contig_ids
Usage : $assembly->get_contig_ids()
Function: Access list of contig IDs from assembly
Returns : an array if there are any contigs in the assembly.
undef otherwise
Args : an array of contig IDs
=cut
sub get_contig_ids {
my $self = shift;
$self->throw_not_implemented();
}
=head2 get_singlet_ids
Title : get_singlet_ids
Usage : $assembly->get_singlet_ids()
Function: Access list of singlet IDs from assembly
Returns : an array if there are any singlets in the assembly.
undef otherwise
Args : an array of singlet IDs
=cut
sub get_singlet_ids {
my $self = shift;
$self->throw_not_implemented();
}
=head2 get_contig_by_id
Title : get_contig_by_id
Usage : $assembly->get_contig_by_id($id)
Function: Get a reference for a contig from the assembly
Returns : a Bio::Assembly::Contig object or undef
Args : [string] contig unique identifier (ID)
=cut
sub get_contig_by_id {
my $self = shift;
$self->throw_not_implemented();
}
=head2 get_singlet_by_id
Title : get_singlet_by_id
Usage : $assembly->get_singlet_by_id()
Function: Get a reference for a singlet from the assembly
Returns : Bio::Assembly::Singlet object or undef
Args : [string] a singlet ID
=cut
sub get_singlet_by_id {
my $self = shift;
$self->throw_not_implemented();
}
=head1 Modifier methods
Implementation of these methods is optional in the sense that
read-only implementations may not have these. If an object implements
one of them, it should however implement all.
=cut
Bio/Assembly/ScaffoldI.pm view on Meta::CPAN
Args : a Bio::Assembly:Contig object
See Bio::Assembly::Contig for more information
=cut
#---------------------
sub add_contig {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 add_singlet
Title : add_singlet
Usage : $assembly->add_singlet($seq)
Function: Add another singlet to the Bio::Assembly::ScaffoldI object
Returns : 1 on success, 0 otherwise
Args : a Bio::Assembly::Singlet object
=cut
#---------------------
sub add_singlet {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 remove_contigs
Title : remove_contigs
Usage : $assembly->remove_contigs(1..4)
Function: Remove contig from assembly object
Returns : a Bio::Assembly::Contig object
Args : a list of contig IDs
See function get_contig_ids() above
=cut
#---------------------
sub remove_contigs {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 remove_singlets
Title : remove_singlets
Usage : $assembly->remove_singlets(1..4)
Function: Remove singlets from assembly object
Returns : an array of Bio::Assembly::Singlet objects
Args : an array of singlet IDs
See function get_singlet_ids() above
=cut
#---------------------
sub remove_singlets {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head1 Contig and singlet selection methos
=cut
=head2 select_contigs
Title : select_contig
Usage : $assembly->select_contig
Bio/Assembly/ScaffoldI.pm view on Meta::CPAN
Args : an array of contig ids
See function get_contig_ids() above
=cut
#---------------------
sub select_contigs {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 select_singlets
Title : select_singlets
Usage : $assembly->select_singlets(@list)
Function: Selects an array of singlets from the assembly
Returns : an array of Bio::Assembly::Singlet objects
Args : an array of singlet ids
See function get_singlet_ids() above
=cut
#---------------------
sub select_singlets {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 all_contigs
Title : all_contigs
Usage : my @contigs = $assembly->all_contigs
Function: Returns a list of all contigs in this assembly.
Contigs are both clusters and alignments of one
or more reads, with an associated consensus
sequence.
Returns : array of Bio::Assembly::Contig
Args : none
=cut
#---------------------
sub all_contigs {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
=head2 all_singlets
Title : all_singlets
Usage : my @singlets = $assembly->all_singlets
Function: Returns a list of all singlets in this assembly.
Singlets are isolated reads, without non-vector
matches to any other read in the assembly.
Returns : array of Bio::Assembly::Singlet objects
Args : none
=cut
#---------------------
sub all_singlets {
#---------------------
my ($self) = @_;
$self->throw_not_implemented();
}
1;
Bio/Cluster/FamilyI.pm view on Meta::CPAN
Title : family_id
Usage : Bio::Cluster::FamilyI->family_id("znfp");
Function: get/set for the family id
Returns : the family id
Args : the family id
=cut
sub family_id{
shift->throw_not_implemented();
}
=head2 family_score
Title : family_score
Usage : Bio::Cluster::FamilyI->family_score(95);
Function: get/set for the score of algorithm used to generate
the family if present
Returns : the score
Args : the score
=cut
sub family_score {
shift->throw_not_implemented();
}
=head1 Methods inherited from L<Bio::ClusterI>
=cut
=head2 display_id
Title : display_id
Bio/Cluster/SequenceFamily.pm view on Meta::CPAN
Function: Constructor for SequenceFamily object
Returns : Bio::Cluster::SequenceFamily object
See L<Bio::Cluster::SequenceFamily>.
=cut
sub new {
my ($class,@args) = @_;
my $self = $class->SUPER::new(@args);
my ($id,$description,$version,$annot_score,
$family_score,$members) = $self->_rearrange([qw(FAMILY_ID DESCRIPTION VERSION
ANNOTATION_SCORE
FAMILY_SCORE MEMBERS)],@args);
$self->{'_members'} = [];
$id && $self->family_id($id);
$description && $self->description($description);
$version && $self->version($version);
$annot_score && $self->annotation_score($annot_score);
$family_score && $self->family_score($family_score);
$members && $self->add_members($members);
return $self;
}
=head2 version
Title : version
Usage : $family->version("1.0");
Bio/Cluster/UniGeneI.pm view on Meta::CPAN
Function: Returns the unigene_id associated with the object.
Example : $id = $unigene->unigene_id or $unigene->unigene_id($id)
Returns : A string
Args : None or an id
=cut
sub unigene_id {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 title
Title : title
Usage : title();
Function: Returns the title associated with the object.
Example : $title = $unigene->title or $unigene->title($title)
Returns : A string
Args : None or a title
=cut
sub title {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 gene
Title : gene
Usage : gene();
Function: Returns the gene associated with the object.
Example : $gene = $unigene->gene or $unigene->gene($gene)
Returns : A string
Args : None or a gene
=cut
sub gene {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 cytoband
Title : cytoband
Usage : cytoband();
Function: Returns the cytoband associated with the object.
Example : $cytoband = $unigene->cytoband or $unigene->cytoband($cytoband)
Returns : A string
Args : None or a cytoband
=cut
sub cytoband {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 mgi
Title : mgi
Usage : mgi();
Function: Returns the mgi associated with the object.
Example : $mgi = $unigene->mgi or $unigene->mgi($mgi)
Returns : A string
Args : None or a mgi
=cut
sub mgi {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 locuslink
Title : locuslink
Usage : locuslink();
Function: Returns or stores a reference to an array containing locuslink data.
This should really only be used by ClusterIO, not directly
Returns : An array reference
Args : None or an array reference
=cut
sub locuslink {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 homol
Title : homol
Usage : homol();
Function: Returns the homol entry associated with the object.
Example : $homol = $unigene->homol or $unigene->homol($homol)
Returns : A string
Args : None or a homol entry
=cut
sub homol {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 restr_expr
Title : restr_expr
Usage : restr_expr();
Function: Returns the restr_expr entry associated with the object.
Example : $restr_expr = $unigene->restr_expr or $unigene->restr_expr($restr_expr)
Returns : A string
Args : None or a restr_expr entry
=cut
sub restr_expr {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 gnm_terminus
Title : gnm_terminus
Usage : gnm_terminus();
Function: Returns the gnm_terminus associated with the object.
Example : $gnm_terminus = $unigene->gnm_terminus or $unigene->gnm_terminus($gnm_terminus)
Returns : A string
Args : None or a gnm_terminus
=cut
sub gnm_terminus {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 scount
Title : scount
Usage : scount();
Function: Returns the scount associated with the object.
Example : $scount = $unigene->scount or $unigene->scount($scount)
Returns : A string
Args : None or a scount
=cut
sub scount {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 express
Title : express
Usage : express();
Function: Returns or stores a reference to an array containing tissue expression data.
This should really only be used by ClusterIO, not directly
Returns : An array reference
Args : None or an array reference
=cut
sub express {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 chromosome
Title : chromosome
Usage : chromosome();
Function: Returns or stores a reference to an array containing chromosome lines
This should really only be used by ClusterIO, not directly
Returns : An array reference
Args : None or an array reference
=cut
sub chromosome {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 sts
Title : sts
Usage : sts();
Function: Returns or stores a reference to an array containing sts lines
This should really only be used by ClusterIO, not directly
Returns : An array reference
Args : None or an array reference
=cut
sub sts {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 txmap
Title : txmap
Usage : txmap();
Function: Returns or stores a reference to an array containing txmap lines
Returns : An array reference
Args : None or an array reference
=cut
sub txmap {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 protsim
Title : protsim
Usage : protsim();
Function: Returns or stores a reference to an array containing protsim lines
This should really only be used by ClusterIO, not directly
Returns : An array reference
Args : None or an array reference
=cut
sub protsim {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 sequence
Title : sequence
Usage : sequence();
Function: Returns or stores a reference to an array containing sequence data
This should really only be used by ClusterIO, not directly
Returns : An array reference
Args : None or an array reference
=cut
sub sequence {
my ($self) = @_;
$self->throw_not_implemented;
}
=head2 species
Title : species
Usage : $obj->species($newval)
Function: Get the species object for this Unigene cluster.
Example :
Returns : value of species (a L<Bio::Species> object)
Args :
=cut
sub species{
shift->throw_not_implemented();
}
=head1 Methods inherited from L<Bio::ClusterI>
=cut
=head2 display_id
Title : display_id
Usage :
Bio/ClusterI.pm view on Meta::CPAN
Title : display_id
Usage :
Function: Get the display name or identifier for the cluster
Returns : a string
Args :
=cut
sub display_id{
shift->throw_not_implemented();
}
=head2 description
Title : description
Usage : Bio::ClusterI->description("POLYUBIQUITIN")
Function: get/set for the consensus description of the cluster
Returns : the description string
Args : Optional the description string
=cut
sub description{
shift->throw_not_implemented();
}
=head2 size
Title : size
Usage : Bio::ClusterI->size();
Function: get/set for the size of the family,
calculated from the number of members
Returns : the size of the family
Args :
=cut
sub size {
shift->throw_not_implemented();
}
=head2 cluster_score
Title : cluster_score
Usage : $cluster ->cluster_score(100);
Function: get/set for cluster_score which
represent the score in which the clustering
algorithm assigns to this cluster.
Returns : a number
=cut
sub cluster_score{
shift->throw_not_implemented();
}
=head2 get_members
Title : get_members
Usage : Bio::ClusterI->get_members(($seq1, $seq2));
Function: retrieve the members of the family by some criteria, for
example :
$cluster->get_members(-species => 'homo sapiens');
Will return all members if no criteria are provided.
Returns : the array of members
Args :
=cut
sub get_members {
shift->throw_not_implemented();
}
1;
Bio/DB/Expression.pm view on Meta::CPAN
Usage :
Function:
Example :
Returns : a list of Bio::Expression::Platform objects
Args :
=cut
sub get_platforms {
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_samples()
Usage :
Function:
Example :
Returns : a list of Bio::Expression::Sample objects
Args :
=cut
sub get_samples {
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_contacts()
Usage :
Function:
Example :
Returns : a list of Bio::Expression::Contact objects
Args :
=cut
sub get_contacts {
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_datasets()
Usage :
Function:
Example :
Returns : a list of Bio::Expression::DataSet objects
Args :
=cut
sub get_datasets {
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 _load_expression_module
Title : _load_expression_module
Usage : *INTERNAL Bio::DB::Expression stuff*
Function: Loads up (like use) a module at run time on demand
Bio/DB/Expression/geo.pm view on Meta::CPAN
Usage :
Function:
Example :
Returns : a list of Bio::Expression::Sample objects
Args :
=cut
sub get_samples {
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_contacts()
Usage :
Function:
Example :
Returns : a list of Bio::Expression::Contact objects
Args :
=cut
sub get_contacts {
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_datasets()
Usage : $db->get_datasets('accession');
Function:
Example :
Returns : a list of Bio::Expression::DataSet objects
Args :
Bio/DB/Flat.pm view on Meta::CPAN
=head2 To Be Implemented in Subclasses
The following methods MUST be implemented by subclasses.
=cut
# create real live Bio::Seq object
sub get_Seq_by_id {
my $self = shift;
my $id = shift;
$self->throw_not_implemented;
}
# fetch array of Bio::Seq objects
sub get_Seq_by_acc {
my $self = shift;
return $self->get_Seq_by_id(shift) if @_ == 1;
my ($ns,$key) = @_;
$self->throw_not_implemented;
}
sub fetch_raw {
my ($self,$id,$namespace) = @_;
$self->throw_not_implemented;
}
sub default_file_format {
my $self = shift;
$self->throw_not_implemented;
}
sub _store_index {
my $self = shift;
my ($ids,$file,$offset,$length) = @_;
$self->throw_not_implemented;
}
=head2 May Be Overridden in Subclasses
The following methods MAY be overridden by subclasses.
=cut
sub default_primary_namespace {
return "ACC";
Bio/DB/GenericWebAgent.pm view on Meta::CPAN
Title : get_Parser
Usage : $agent->get_Parser;
Function: Return HTTP::Response content (file, fh, object) attached to defined parser
Returns : None
Args : None
Note : Abstract method; defined by implementation
=cut
sub get_Parser {
shift->throw_not_implemented;
}
=head2 delay
Title : delay
Usage : $secs = $self->delay($secs)
Function: get/set number of seconds to delay between fetches
Returns : number of seconds to delay
Args : new value
Bio/DB/IndexedBase.pm view on Meta::CPAN
Function: This method calculates the sequence offsets in a file based on ID and
should be implemented by classes that use Bio::DB::IndexedBase.
Returns : Hash of offsets
Args : File to process
Hashref of file offsets keyed by IDs.
=cut
sub _calculate_offsets {
my $self = shift;
$self->throw_not_implemented();
}
sub _index_files {
# Do the indexing of the given files using the index file on record
my ($self, $files, $force_reindex) = @_;
$self->_set_pack_method( @$files );
# Get name of index file
Bio/DB/LocationI.pm view on Meta::CPAN
Title : get_Location_by_id
Usage : $loc = $db->get_Location_by_id('123456')
Function: Gets a Bio::LocationI-implementing object by its name (id)
Returns : a Bio::LocationI object or undef if not found
Args : the id (as a string) of a sequence
=cut
sub get_Location_by_id{
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_Location_by_acc
Title : get_Location_by_acc
Usage : $loc = $db->get_Location_by_acc('X77802');
Function: Gets a Bio::LocationI object by accession number
Returns : A Bio::LocationI object or undef if not found
Args : accession number (as a string)
Throws : "more than one sequences correspond to this accession"
if the accession maps to multiple primary ids and
method is called in a scalar context
=cut
sub get_Location_by_acc{
my ($self,@args) = @_;
$self->throw_not_implemented();
}
=head2 get_Location_by_version
Title : get_Location_by_version
Usage : $loc = $db->get_Location_by_version('X77802.1');
Function: Gets a Bio::LocationI object by sequence version
Returns : A Bio::LocationI object
Args : accession.version (as a string)
Throws : "acc.version does not exist" exception
=cut
sub get_Location_by_version{
my ($self,@args) = @_;
$self->throw_not_implemented();
}
## End of Package
1;
( run in 0.657 second using v1.01-cache-2.11-cpan-0a987023a57 )