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

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

 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

 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

 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)

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

 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'

 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

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

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

 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

 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

 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

 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

 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

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

 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):

           
             bar1
           

 Returns : node
 Args    : first arg = element name
           all other args are added as tag-value pairs

 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

 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

 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

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

 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

 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

 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

 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

 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

 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