GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  BIO::SEQIO::GAME::GAMEWRITER (3)

.ds Aq ’

NAME

Bio::SeqIO::game::gameWriter -- a class for writing game-XML

CONTENTS

SYNOPSIS



  use Bio::SeqIO;

  my $in  = Bio::SeqIO->new( -format => genbank,
                             -file => myfile.gbk );
  my $out = Bio::SeqIO->new( -format => game,
                             -file => myfile.xml );

  # get a sequence object
  my $seq = $in->next_seq;

  #write it in GAME format
  $out->write_seq($seq);



DESCRIPTION

Bio::SeqIO::game::gameWriter writes GAME-XML (v. 1.2) that is readable by Apollo. It is best not used directly. It is accessed via Bio::SeqIO.

FEEDBACK

    Mailing Lists

User feedback is an integral part of the evolution of this and other Bioperl modules. Send your comments and suggestions preferably to one of the Bioperl mailing lists.

Your participation is much appreciated.



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



    Support

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 Bugs

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://github.com/bioperl/bioperl-live/issues



AUTHOR - Sheldon McKay

Email mckays@cshl.edu

APPENDIX

The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _

    new



 Title   : new
 Usage   : my $writer = Bio::SeqIO::game::gameWriter->new($seq);
 Function: constructor method for gameWriter
 Returns : a game writer object
 Args    : a Bio::SeqI implementing object
           optionally, an argument to set map_position to on.
           ( map => 1 ).  This will create a map_position elemant
           that will cause the feature coordinates to be remapped to
           a parent seqeunce.  A sequence name in the format seq:xxx-xxx
           is expected to determine the offset for the map_position.
           The default behavior is to have features mapped relative to
           the sequence contained in the GAME-XML file



    write_to_game



 Title   : write_to_game
 Usage   : $writer->write_to_game
 Function: writes the sequence object to game-XML
 Returns : xml as a multiline string
 Args    : none



    _rearrange_hierarchies



 Title   : _rearrange_hierarchies
 Usage   : $self->_rearrange_hierarchies($seq)
 Function: internal method to rearrange gene containment hierarchies
           so that snRNA or transposon features contain their genes
           rather than the other way around
 Returns : nothing
 Args    : a Bio::RichSeq object
 Note    : Not currently used, may be removed



    _write_feature



 Title   : _write_feature
 Usage   : $seld->_write_feature($feat, 1)
 Function: internal method for writing generic features as <annotation> elements
 Returns : nothing
 Args    : a Bio::SeqFeature::Generic object and an optional flag to write a
           bare feature set with no annotation wrapper



    _write_gene



 Title   : _write_gene
 Usage   : $self->_write_gene($feature)
 Function: internal method for rendering gene containment hierarchies into
           a nested <annotation> element
 Returns : nothing
 Args    : a nested Bio::SeqFeature::Generic gene feature
 Note    : A nested gene hierarchy (gene->mRNA->CDS->exon) is expected.  If other gene
           subfeatures occur as level one subfeatures (same level as mRNA subfeats)
           an attempt will be made to link them to transcripts via the standard_name
           qualifier



    _check_cds



 Title   : _check_cds
 Usage   : $self->_check_cds($cds, $name)
 Function: internal method to check if the CDS associated with an mRNA is
           the correct alternative splice variant
 Returns : a Bio::SeqFeature::Generic CDS object
 Args    : the CDS object plus the transcript\s standard_name
 Note    : this method only works if alternatively spliced transcripts are bound
           together by a standard_name or mRNA qualifier.  If none is present,
           we will hope that the exons were derived from a segmented RNA or a CDS
           with no associated mRNA feature.  Neither of these two cases would be
           confounded by alternative splice variants.



    _comp_analysis



  Usage:
  Desc :
  Ret  :
  Args :
  Side Effects:
  Example:



    _comp_result



  Usage:
  Desc : recursively render a feature and its subfeatures as
         <result_set> and <result_span> elements
  Ret  : nothing meaningful
  Args : a feature



    _comp_result_span



  Usage: _comp_result_span(foo12,$feature);
  Desc : write GAME XML for a Bio::SeqFeature::Computation feature
         that has no subfeatures
  Ret  : nothing meaningful
  Args : name for this span (some kind of identifier),
         SeqFeature object to put into this span
  Side Effects:
  Example:



    _render_tags



  Usage:
  Desc :
  Ret  :
  Args :
  Side Effects:
  Example:



    _render_output_tags



  Usage:
  Desc : print out <output> elements, with contents
         taken from the SeqFeature::Computations output tag
  Ret  : array of tag names this did not render
  Args : feature object, list of tag names to maybe render

  In game xml, only <result_span> and <result_set> elements can
  have <output> elements.



    _render_tags_as_properties



  Usage:
  Desc :
  Ret  : empty array
  Args : feature object, array of tag names
  Side Effects:
  Example:

  In game xml, <annotation>, <computational_analysis>,
  and <feature_set> elements can have properties.



    _render_comment_tags



  Usage:
  Desc :
  Ret  : names of tags that were not comment tags
  Args : feature object, tag names available for us to render
  Side Effects: writes XML
  Example:

  In game xml, <annotation> and <feature_set> elements can
  have comments.



    _render_date_tags



  Usage:
  Desc :
  Ret  : names of tags that were not date tags
  Args : feature, list of tag names available for us to render
  Side Effects: writes XML for <date> elements
  Example:

  In game xml, <annotation>, <computational_analysis>,
  <transaction>, <comment>, and <feature_set> elements
  can have <date>s.



    _render_dbxref_tags



  Desc : look for xref tags and render them if they are there
  Ret  : tag names that we didnt render
  Args : feature object, list of tag names to render
  Side Effects: writes a <dbxref> element if a tag with name
                matching /xref$/i is present


  In game xml, <annotation> and <seq> elements can have dbxrefs.



    _render_target_tags



  Usage:
  Desc : process any Target tags that would indicate a sequence alignment subject
  Ret  : array of tag names that we didnt render
  Args : feature object
  Side Effects: writes a <seq_relationship> of type subject if it finds
                any properly formed tags named Target
  Example:

  In game xml, <result_span>, <feature_span>, and <result_set> can have
  <seq_relationship>s.  <result_set> can only have one, a query relation.



    _property



 Title   : _property
 Usage   : $self->_property($tag => $value);
 Function: an internal method to write property XML elements
 Returns : nothing
 Args    : a tag/value pair



    _unflatten_attribute



 Title   : _unflatten_attribute
 Usage   : $self->_unflatten_attribute($name, $value)
 Function: an internal method to unflatten and write comment or evidence elements
 Returns : nothing
 Args    : a list of strings



    _xref



 Title   : _xref
 Usage   : $self->_xref($value)
 Function: an internal method to write db_xref elements
 Returns : nothing
 Args    : a list of strings



    _feature_span



 Title   : _feature_span
 Usage   : $self->_feature_span($name, $type, $loc)
 Function: an internal method to write a feature_span element
          (the actual feature with coordinates)
 Returns : nothing
 Args    : a feature name and Bio::SeqFeatureI-compliant object



    _seq_relationship



 Title   : _seq_relationship
 Usage   : $self->_seq_relationship($type, $loc)
 Function: an internal method to handle feature_span sequence relationships
 Returns : nothing
 Args    : feature type, a Bio::LocationI-compliant object,
           (optional) sequence name (defaults to the query seq)
           and (optional) alignment string



    _element



 Title   : _element
 Usage   : $self->_element($name, $chars, $atts)
 Function: an internal method to generate generic XML elements
 Example :
 my $name = foo;
 my $content = bar;
 my $attributes = { baz => 1 };
 # print the element
 $self->_element($name, $content, $attributes);
 Returns : nothing
 Args    : the element name and content plus a ref to an attribute hash



    _span



 Title   : _span
 Usage   : $self->_span($loc)
 Function: an internal method to write the span element
 Returns : nothing
 Args    : a Bio::LocationI-compliant object



    _seq



 Title   : _seq
 Usage   : $self->_seq($seq, $dna)
 Function: an internal method to print the sequence element
 Returns : nothing
 Args    : and Bio::SeqI-compliant object and a reference to an attribute  hash



    _find_name



 Title   : _find_name
 Usage   : my $name = $self->_find_name($feature)
 Function: an internal method to look for a gene name
 Returns : a string
 Args    : a Bio::SeqFeatureI-compliant object



Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 BIO::SEQIO::GAME::GAMEWRITER (3) 2016-04-05

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.