Bio::Annotation::TagTree.3pm

Langue: en

Version: 2010-05-19 (ubuntu - 24/10/10)

Section: 3 (Bibliothèques de fonctions)

NAME

Bio::Annotation::TagTree - AnnotationI with tree-like hierarchal key-value relationships ('structured tags') that can be represented as simple text.

SYNOPSIS

    use Bio::Annotation::TagTree;
    use Bio::Annotation::Collection;
 
    my $col = Bio::Annotation::Collection->new();
 
    # data structure can be an array reference with a data structure
    # corresponding to that defined by Data::Stag:
 
    my $sv = Bio::Annotation::TagTree->new(-tagname => 'mytag1',
                                           -value => $data_structure);
    $col->add_Annotation($sv);
 
    # regular text passed is parsed based on the tagformat().
    my $sv2 = Bio::Annotation::TagTree->new(-tagname => 'mytag2',
                                           -tagformat => 'xml',
                                           -value => $xmltext);
    $col->add_Annotation($sv2);
 
 

DESCRIPTION

This takes tagged data values and stores them in a hierarchal structured element-value hierarchy (complements of Chris Mungall's Data::Stag module). Data can then be represented as text using a variety of output formats (indention, itext, xml, spxr). Furthermore, the data structure can be queried using various means. See Data::Stag for details.

Data passed in using value() or the '-value' parameter upon instantiation can either be:

1) an array reference corresponding to the data structure for Data::Stag;

2) a text string in 'xml', 'itext', 'spxr', or 'indent' format. The default format is 'xml'; this can be changed using tagformat() prior to using value() or by passing in the proper format using '-tagformat' upon instantiation;

3) another Bio::Annotation::TagTree or Data::Stag node instance. In both cases a deep copy (duplicate) of the instance is generated.

Beyond checking for an array reference no format guessing occurs (so, for roundtrip tests ensure that the IO formats correspond). For now, we recommend when using text input to set tagformat() to one of these formats prior to data loading to ensure the proper Data::Stag parser is selected. After data loading, the tagformat() can be changed to change the text string format returned by value(). (this may be rectified in the future)

This Annotation type is fully BioSQL compatible and could be considered a temporary replacement for nested Bio::Annotation::Collections, at least until BioSQL and bioperl-db can support nested annotation collections.

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 the bugs and their resolution. Bug reports can be submitted via or the web:
   http://bugzilla.open-bio.org/
 
 

AUTHOR

Chris Fields

APPENDIX

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

new

  Title   : new
  Usage   : my $sv = Bio::Annotation::TagTree->new();
  Function: Instantiate a new TagTree object
  Returns : Bio::Annotation::TagTree object
  Args    : -value => $value to initialize the object data field [optional]
            -tagname => $tag to initialize the tagname [optional]
            -tagformat => format for output [optional]
                       (types 'xml', 'itext', 'sxpr', 'indent', default = 'itext')
            -node => Data::Stag node or Bio::Annotation::TagTree instance
 
 

AnnotationI implementing functions

as_text

  Title   : as_text
  Usage   : my $text = $obj->as_text
  Function: return the string "Value: $v" where $v is the value
  Returns : string
  Args    : none
 
 

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.
 
            One can pass a callback as an argument which allows custom text
            generation; the callback is passed the current instance and any text
            returned
  Example :
  Returns : a string
  Args    : [optional] callback
 
 

hash_tree

  Title   : hash_tree
  Usage   : my $hashtree = $value->hash_tree
  Function: For supporting the AnnotationI interface just returns the value
            as a hashref with the key 'value' pointing to the value
            Maybe reimplement using Data::Stag::hash()?
  Returns : hashrf
  Args    : none
 
 

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 AnnotationCollection when adding this object.
  Example :
  Returns : value of tagname (a scalar)
  Args    : new value (a scalar, optional)
 
 

Specific accessors for TagTree

value

  Title   : value
  Usage   : $obj->value($newval)
  Function: Get/set the value for this annotation.
  Returns : value of value
  Args    : newvalue (optional)
 
 

tagformat

  Title   : tagformat
  Usage   : $obj->tagformat($newval)
  Function: Get/set the output tag format for this annotation.
  Returns : value of tagformat
  Args    : newvalue (optional) - format for the data passed into value
            must be of values 'xml', 'indent', 'sxpr', 'itext', 'perl'
 
 

node

  Title   : node
  Usage   : $obj->node()
  Function: Get/set the topmost Data::Stag node used for this annotation.  
  Returns : Data::Stag node implementation
            (default is Data::Stag::StagImpl)
  Args    : (optional) Data::Stag node implementation
            (optional)'copy' => flag to create a copy of the node
 
 

Data::Stag convenience methods

Because Data::Stag uses blessed arrays and the core Bioperl class uses blessed hashes, TagTree uses an internal instance of a Data::Stag node for data storage. Therefore the following methods actually delegate to the Data:::Stag internal instance.

For consistency (since one could recursively check child nodes), methods retain the same names as Data::Stag. Also, no 'magic' (AUTOLOAD'ed) methods are employed, simply b/c full-fledged Data::Stag functionality can be attained by grabbing the Data::Stag instance using node().

element

  Title   : element
  Usage   :
  Function: Returns the element name (key name) for this node
  Example :
  Returns : scalar
  Args    : none
 
 

data

  Title   : data
  Usage   :
  Function: Returns the data structure (array ref) for this node
  Example :
  Returns : array ref
  Args    : none
 
 

children

  Title   : children
  Usage   :
  Function: Get the top-level array of Data::Stag nodes or (if the top level is
            a terminal node) a scalar value.
 
            This is similar to StructuredValue's get_values() method, with the
            key difference being instead of array refs and scalars you get either
            Data::Stag nodes or the value for this particular node.
 
            For consistency (since one could recursively check nodes),
            we use the same method name as Data::Stag children().
  Example :
  Returns : an array
  Args    : none
 
 

subnodes

  Title   : subnodes
  Usage   :
  Function: Get the top-level array of Data::Stag nodes.  Unlike children(),
            this only returns an array of nodes (if this is a terminal node,
            no value is returned)
  Example :
  Returns : an array of nodes
  Args    : none
 
 

get

  Title   : get
  Usage   : 
  Function: Returns the nodes or value for the named element or path
  Example : 
  Returns : returns array of nodes or a scalar (if node is terminal)
            dependent on wantarray
  Args    : none
 
 

find

  Title   : find
  Usage   : 
  Function: Recursively searches for and returns the nodes or values for the
            named element or path
  Example : 
  Returns : returns array of nodes or scalars (for terminal nodes)
  Args    : none
 
 

findnode

  Title   : findnode
  Usage   : 
  Function: Recursively searches for and returns a list of nodes
            of the given element path
  Example : 
  Returns : returns array of nodes
  Args    : none
 
 

findval

  Title   : findval
  Usage   : 
  Function: 
  Example : 
  Returns : returns array of nodes or values
  Args    : none
 
 

addchild

  Title   : addchild
  Usage   : $struct->addchild(['name' => [['foo'=> 'bar1']]]);
  Function: add new child node to the current node.  One can pass in a node, TagTree,
            or data structure; for instance, in the above, this would translate
            to (in XML):
 
            <name>
              <foo>bar1</foo>
            </name>
 
  Returns : node
  Args    : first arg = element name
            all other args are added as tag-value pairs
 
 

add

  Title   : add
  Usage   : $struct->add('foo', 'bar1', 'bar2', 'bar3');
  Function: add tag-value nodes to the current node.  In the above, this would
            translate to (in XML):
            <foo>bar1</foo>
            <foo>bar2</foo>
            <foo>bar3</foo>
  Returns : 
  Args    : first arg = element name
            all other args are added as tag-value pairs
 
 

set

  Title   : set
  Usage   : $struct->set('foo','bar');
  Function: sets a single tag-value pair in the current node.  Note this
            differs from add() in that this replaces any data already present
  Returns : node
  Args    : first arg = element name
            all other args are added as tag-value pairs
 
 

unset

  Title   : unset
  Usage   : $struct->unset('foo');
  Function: unsets all key-value pairs of the passed element from the
            current node
  Returns : node
  Args    : element name
 
 

free

  Title   : free
  Usage   : $struct->free
  Function: removes all data from the current node
  Returns : 
  Args    :
 
 

hash

  Title   : hash
  Usage   : $struct->hash;
  Function: turns the tag-value tree into a hash, all data values are array refs
  Returns : hash
  Args    : first arg = element name
            all other args are added as tag-value pairs
 
 

pairs

  Title   : pairs
  Usage   : $struct->pairs;
  Function: turns the tag-value tree into a hash, all data values are scalar
  Returns : hash
  Args    : first arg = element name
            all other args are added as tag-value pairs, note that duplicates
            will be lost
 
 

qmatch

  Title    : qmatch
  Usage    : @persons = $s->qmatch('person', ('name'=>'fred'));
  Function : returns all elements in the node tree which match the
             element name and the key-value pair
  Returns  : Array of nodes
  Args     : return-element str, match-element str, match-value str
 
 

tnodes

  Title    : tnodes
  Usage    : @termini = $s->tnodes;
  Function : returns all terminal nodes below this node
  Returns  : Array of nodes
  Args     : return-element str, match-element str, match-value str
 
 

ntnodes

  Title    : ntnodes
  Usage    : @termini = $s->ntnodes;
  Function : returns all nonterminal nodes below this node
  Returns  : Array of nodes
  Args     : return-element str, match-element str, match-value str
 
 

StructureValue-like methods

get_all_values

  Title    : get_all_values
  Usage    : @termini = $s->get_all_values;
  Function : returns all terminal node values
  Returns  : Array of values
  Args     : return-element str, match-element str, match-value str
 
 

This is meant to emulate the values one would get from StructureValue's get_all_values() method. Note, however, using this method dissociates the tag-value relationship (i.e. you only get the value list, no elements)