Provided by: libbio-perl-perl_1.7.8-1_all 
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:
https://github.com/bioperl/bioperl-live/issues
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)