NAME¶
Data::Stag - Structured Tags datastructures
SYNOPSIS¶
# PROCEDURAL USAGE
use Data::Stag qw(:all);
$doc = stag_parse($file);
@persons = stag_find($doc, "person");
foreach $p (@persons) {
printf "%s, %s phone: %s\n",
stag_sget($p, "family_name"),
stag_sget($p, "given_name"),
stag_sget($p, "phone_no"),
;
}
# OBJECT-ORIENTED USAGE
use Data::Stag;
$doc = Data::Stag->parse($file);
@persons = $doc->find("person");
foreach $p (@person) {
printf "%s, %s phone:%s\n",
$p->sget("family_name"),
$p->sget("given_name"),
$p->sget("phone_no"),
;
}
DESCRIPTION¶
This module is for manipulating data as hierarchical tag/value pairs (Structured
TAGs or Simple Tree AGgreggates). These datastructures can be represented as
nested arrays, which have the advantage of being native to perl. A simple
example is shown below:
[ person=> [ [ family_name => $family_name ],
[ given_name => $given_name ],
[ phone_no => $phone_no ] ] ],
Data::Stag uses a subset of XML for import and export. This means the module can
also be used as a general XML parser/writer (with certain caveats).
The above set of structured tags can be represented in XML as
<person>
<family_name>...</family_name>
<given_name>...</given_name>
<phone_no>...</phone_no>
</person>
This datastructure can be examined, manipulated and exported using Stag
functions or methods:
$document = Data::Stag->parse($file);
@persons = $document->find('person');
foreach my $person (@person) {
$person->set('full_name',
$person->sget('given_name') . ' ' .
$person->sget('family_name'));
}
Advanced querying is performed by passing functions, for example:
# get all people in dataset with name starting 'A'
@persons =
$document->where('person',
sub {shift->sget('family_name') =~ /^A/});
One of the things that marks this module out against other XML modules is this
emphasis on a
functional approach as an obect-oriented or procedural
approach.
For full information on the stag project, see
<
http://stag.sourceforge.net>
PROCEDURAL VS OBJECT-ORIENTED USAGE¶
Depending on your preference, this module can be used a set of procedural
subroutine calls, or as method calls upon Data::Stag objects, or both.
In procedural mode, all the subroutine calls are prefixed "stag_" to
avoid namespace clashes. The following three calls are equivalent:
$person = stag_find($doc, "person");
$person = $doc->find("person");
$person = $doc->find_person;
In object mode, you can treat any tree element as if it is an object with
automatically defined methods for getting/setting the tag values.
USE OF XML¶
Nested arrays can be imported and exported as XML, as well as other formats. XML
can be slurped into memory all at once (using less memory than an equivalent
DOM tree), or a simplified SAX style event handling model can be used.
Similarly, data can be exported all at once, or as a series of events.
Although this module can be used as a general XML tool, it is intended primarily
as a tool for manipulating hierarchical data using nested tag/value pairs.
This module is more suited to dealing with data-oriented documents than
text-oriented documents.
By using a simpler subset of XML equivalent to a basic data tree structure, we
can write simpler, cleaner code.
This module is ideally suited to element-only XML (that is, XML without
attributes or mixed elements).
If you are using attributes or mixed elements, it is useful to know what is
going on under the hood.
All attributes are turned into elements; they are nested inside an element with
name
'@'.
For example, the following piece of XML
<foo id="x">
<bar>ugh</bar>
</foo>
Gets represented internally as
<foo>
<@>
<id>x</id>
</@>
<bar>ugh</bar>
</foo>
Of course, this is not valid XML. However, it is just an internal representation
- when exporting back to XML it will look like normal XML with attributes
again.
Mixed content cannot be represented in a simple tree format, so this is also
expanded.
The following piece of XML
<paragraph id="1" color="green">
example of <bold>mixed</bold>content
</paragraph>
gets parsed as if it were actually:
<paragraph>
<@>
<id>1</id>
<color>green</color>
</@>
<.>example of</.>
<bold>mixed</bold>
<.>content</.>
</paragraph>
When using stag with attribute or mixed attribute xml, you can treat
'@'
and
'.' as normal elements
SAX
This module can also be used as part of a SAX-style event generation / handling
framework - see Data::Stag::BaseHandler
PERL REPRESENTATION
Because nested arrays are native to perl, we can specify an XML datastructure
directly in perl without going through multiple object calls.
For example, instead of using XML::Writer for the lengthy
$obj->startTag("record");
$obj->startTag("field1");
$obj->characters("foo");
$obj->endTag("field1");
$obj->startTag("field2");
$obj->characters("bar");
$obj->endTag("field2");
$obj->end("record");
We can instead write
$struct = [ record => [
[ field1 => 'foo'],
[ field2 => 'bar']]];
PARSING
The following example is for parsing out subsections of a tree and changing
sub-elements
use Data::Stag qw(:all);
my $tree = stag_parse($xmlfile);
my ($subtree) = stag_findnode($tree, $element);
stag_set($element, $sub_element, $new_val);
print stag_xml($subtree);
OBJECT ORIENTED
The same can be done in a more OO fashion
use Data::Stag qw(:all);
my $tree = Data::Stag->parse($xmlfile);
my ($subtree) = $tree->findnode($element);
$element->set($sub_element, $new_val);
print $subtree->xml;
IN A STREAM
Rather than parsing in a whole file into memory all at once (which may not be
suitable for very large files), you can take an
event handling
approach. The easiest way to do this to register which nodes in the file you
are interested in using the
makehandler method. The parser will sweep
through the file, building objects as it goes, and handing the object to a
subroutine that you specify.
For example:
use Data::Stag;
# catch the end of 'person' elements
my $h = Data::Stag->makehandler( person=> sub {
my ($self, $person) = @_;
printf "name:%s phone:%s\n",
$person->get_name,
$person->get_phone;
return; # clear node
});
Data::Stag->parse(-handler=>$h,
-file=>$f);
see Data::Stag::BaseHandler for writing handlers
See the Stag website at <
http://stag.sourceforge.net> for more examples.
A tree of structured tags is represented as a recursively nested array, the
elements of the array represent nodes in the tree.
A node is a name/data pair, that can represent tags and values. A node is
represented using a reference to an array, where the first element of the
array is the
tagname, or
element, and the second element is the
data
This can be visualised as a box:
+-----------+
|Name | Data|
+-----------+
In perl, we represent this pair as a reference to an array
[ Name => $Data ]
The
Data can either be a list of child nodes (subtrees), or a data value.
The terminal nodes (leafs of the tree) contain data values; this is represented
in perl using primitive scalars.
For example:
[ Name => 'Fred' ]
For non-terminal nodes, the Data is a reference to an array, where each element
of the the array is a new node.
+-----------+
|Name | Data|
+-----------+
||| +-----------+
||+-->|Name | Data|
|| +-----------+
||
|| +-----------+
|+--->|Name | Data|
| +-----------+
|
| +-----------+
+---->|Name | Data|
+-----------+
In perl this would be:
[ Name => [
[Name1 => $Data1],
[Name2 => $Data2],
[Name3 => $Data3],
]
];
The extra level of nesting is required to be able to store any node in the tree
using a single variable. This representation has lots of advantages over
others, eg hashes and mixed hash/array structures.
MANIPULATION AND QUERYING¶
The following example is taken from biology; we have a list of species (mouse,
human, fly) and a list of genes found in that species. These are
cross-referenced by an identifier called
tax_id. We can do a
relational-style inner join on this identifier, as follows -
use Data::Stag qw(:all);
my $tree =
Data::Stag->new(
'db' => [
[ 'species_set' => [
[ 'species' => [
[ 'common_name' => 'house mouse' ],
[ 'binomial' => 'Mus musculus' ],
[ 'tax_id' => '10090' ]]],
[ 'species' => [
[ 'common_name' => 'fruit fly' ],
[ 'binomial' => 'Drosophila melanogaster' ],
[ 'tax_id' => '7227' ]]],
[ 'species' => [
[ 'common_name' => 'human' ],
[ 'binomial' => 'Homo sapiens' ],
[ 'tax_id' => '9606' ]]]]],
[ 'gene_set' => [
[ 'gene' => [
[ 'symbol' => 'HGNC' ],
[ 'tax_id' => '9606' ],
[ 'phenotype' => 'Hemochromatosis' ],
[ 'phenotype' => 'Porphyria variegata' ],
[ 'GO_term' => 'iron homeostasis' ],
[ 'map' => '6p21.3' ]]],
[ 'gene' => [
[ 'symbol' => 'Hfe' ],
[ 'synonym' => 'MR2' ],
[ 'tax_id' => '10090' ],
[ 'GO_term' => 'integral membrane protein' ],
[ 'map' => '13 A2-A4' ]]]]]]
);
# inner join of species and gene parts of tree,
# based on 'tax_id' element
my $gene_set = $tree->find("gene_set"); # get <gene_set> element
my $species_set = $tree->find("species_set"); # get <species_set> element
$gene_set->ijoin("gene", "tax_id", $species_set); # INNER JOIN
print "Reorganised data:\n";
print $gene_set->xml;
# find all genes starting with letter 'H' in where species/common_name=human
my @genes =
$gene_set->where('gene',
sub { my $g = shift;
$g->get_symbol =~ /^H/ &&
$g->findval("common_name") eq ('human')});
print "Human genes beginning 'H'\n";
print $_->xml foreach @genes;
S-Expression (Lisp) representation¶
The data represented using this module can be represented as Lisp-style
S-Expressions.
See Data::Stag::SxprParser and Data::Stag::SxprWriter
If we execute this code on the XML from the example above
$stag = Data::Stag->parse($xmlfile);
print $stag->sxpr;
The following S-Expression will be printed:
'(db
(species_set
(species
(common_name "house mouse")
(binomial "Mus musculus")
(tax_id "10090"))
(species
(common_name "fruit fly")
(binomial "Drosophila melanogaster")
(tax_id "7227"))
(species
(common_name "human")
(binomial "Homo sapiens")
(tax_id "9606")))
(gene_set
(gene
(symbol "HGNC")
(tax_id "9606")
(phenotype "Hemochromatosis")
(phenotype "Porphyria variegata")
(GO_term "iron homeostasis")
(map
(cytological
(chromosome "6")
(band "p21.3"))))
(gene
(symbol "Hfe")
(synonym "MR2")
(tax_id "10090")
(GO_term "integral membrane protein")))
(similarity_set
(pair
(symbol "HGNC")
(symbol "Hfe"))
(pair
(symbol "WNT3A")
(symbol "Wnt3a"))))
TIPS FOR EMACS USERS AND LISP PROGRAMMERS
If you use emacs, you can save this as a file with the ".el" suffix
and get syntax highlighting for editing this file. Quotes around the terminal
node data items are optional.
If you know emacs lisp or any other lisp, this also turns out to be a very nice
language for manipulating these datastructures. Try copying and pasting the
above s-expression to the emacs scratch buffer and playing with it in lisp.
INDENTED TEXT REPRESENTATION¶
Data::Stag has its own text format for writing data trees. Again, this is only
possible because we are working with a subset of XML (no attributes, no mixed
elements). The data structure above can be written as follows -
db:
species_set:
species:
common_name: house mouse
binomial: Mus musculus
tax_id: 10090
species:
common_name: fruit fly
binomial: Drosophila melanogaster
tax_id: 7227
species:
common_name: human
binomial: Homo sapiens
tax_id: 9606
gene_set:
gene:
symbol: HGNC
tax_id: 9606
phenotype: Hemochromatosis
phenotype: Porphyria variegata
GO_term: iron homeostasis
map: 6p21.3
gene:
symbol: Hfe
synonym: MR2
tax_id: 10090
GO_term: integral membrane protein
map: 13 A2-A4
similarity_set:
pair:
symbol: HGNC
symbol: Hfe
pair:
symbol: WNT3A
symbol: Wnt3a
See Data::Stag::ITextParser and Data::Stag::ITextWriter
NESTED ARRAY SPECIFICATION II¶
To avoid excessive square bracket usage, you can specify a structure like this:
use Data::Stag qw(:all);
*N = \&stag_new;
my $tree =
N(top=>[
N('personset'=>[
N('person'=>[
N('name'=>'davey'),
N('address'=>'here'),
N('description'=>[
N('hair'=>'green'),
N('eyes'=>'two'),
N('teeth'=>5),
]
),
N('pets'=>[
N('petname'=>'igor'),
N('petname'=>'ginger'),
]
),
],
),
N('person'=>[
N('name'=>'shuggy'),
N('address'=>'there'),
N('description'=>[
N('hair'=>'red'),
N('eyes'=>'three'),
N('teeth'=>1),
]
),
N('pets'=>[
N('petname'=>'thud'),
N('petname'=>'spud'),
]
),
]
),
]
),
N('animalset'=>[
N('animal'=>[
N('name'=>'igor'),
N('class'=>'rat'),
N('description'=>[
N('fur'=>'white'),
N('eyes'=>'red'),
N('teeth'=>50),
],
),
],
),
]
),
]
);
# find all people
my @persons = stag_find($tree, 'person');
# write xml for all red haired people
foreach my $p (@persons) {
print stag_xml($p)
if stag_tmatch($p, "hair", "red");
} ;
# find all people that have name == shuggy
my @p =
stag_qmatch($tree,
"person",
"name",
"shuggy");
NODES AS DATA OBJECTS¶
As well as the methods listed below, a node can be treated as if it is a data
object of a class determined by the element.
For example, the following are equivalent.
$node->get_name;
$node->get('name');
$node->set_name('fred');
$node->set('name', 'fred');
This is really just syntactic sugar. The autoloaded methods are not checked
against any schema, although this may be added in future.
INDEXING STAG TREES¶
A stag tree can be indexed as a hash for direct retrieval; see
Data::Stag::HashDB
This index can be made persistent as a DB file; see Data::Stag::StagDB
If you wish to use Stag in conjunction with a relational database, you should
install DBIx::DBStag
STAG METHODS¶
All method calls are also available as procedural subroutine calls; unless
otherwise noted, the subroutine call is the same as the method call, but with
the string
stag_ prefixed to the method name. The first argument should
be a Data::Stag datastructure.
To import all subroutines into the current namespace, use this idiom:
use Data::Stag qw(:all);
$doc = stag_parse($file);
@persons = stag_find($doc, 'person');
If you wish to use this module procedurally, and you are too lazy to prefix all
calls with
stag_, use this idiom:
use Data::Stag qw(:lazy);
$doc = parse($file);
@persons = find($doc, 'person');
But beware of clashes!
Most method calls also have a handy short mnemonic. Use of these is optional.
Software engineering types prefer longer names, in the belief that this leads
to clearer code. Hacker types prefer shorter names, as this requires less
keystrokes, and leads to a more compact representation of the code. It is
expected that if you do use this module, then its usage will be fairly
ubiquitous within your code, and the mnemonics will become familiar, much like
the qw and s/ operators in perl. As always with perl, the decision is yours.
Some methods take a single parameter or list of parameters; some have large
lists of parameters that can be passed in any order. If the documentation
states:
Args: [x str], [y int], [z ANY]
Then the method can be called like this:
$stag->foo("this is x", 55, $ref);
or like this:
$stag->foo(-z=>$ref, -x=>"this is x", -y=>55);
INITIALIZATION METHODS¶
new
Title: new
Args: element str, data STAG-DATA
Returns: Data::Stag node
Example: $node = stag_new();
Example: $node = Data::Stag->new;
Example: $node = Data::Stag->new(person => [[name=>$n], [phone=>$p]]);
creates a new instance of a Data::Stag node
stagify (nodify)
Title: stagify
Synonym: nodify
Args: data ARRAY-REF
Returns: Data::Stag node
Example: $node = stag_stagify([person => [[name=>$n], [phone=>$p]]]);
turns a perl array reference into a Data::Stag node.
similar to
new
parse
Title: parse
Args: [file str], [format str], [handler obj], [fh FileHandle]
Returns: Data::Stag node
Example: $node = stag_parse($fn);
Example: $node = stag_parse(-fh=>$fh, -handler=>$h, -errhandler=>$eh);
Example: $node = Data::Stag->parse(-file=>$fn, -handler=>$myhandler);
slurps a file or string into a Data::Stag node structure. Will guess the format
(xml, sxpr, itext, indent) from the suffix if it is not given.
The format can also be the name of a parsing module, or an actual parser object;
The handler is any object that can take nested Stag events (start_event,
end_event, evbody) which are generated from the parse. If the handler is
omitted, all events will be cached and the resulting tree will be returned.
See Data::Stag::BaseHandler for writing your own handlers
See Data::Stag::BaseGenerator for details on parser classes, and error handling
parsestr
Title: parsestr
Args: [str str], [format str], [handler obj]
Returns: Data::Stag node
Example: $node = stag_parsestr('(a (b (c "1")))');
Example: $node = Data::Stag->parsestr(-str=>$str, -handler=>$myhandler);
Similar to
parse(), except the first argument is a string
from
Title: from
Args: format str, source str
Returns: Data::Stag node
Example: $node = stag_from('xml', $fn);
Example: $node = stag_from('xmlstr', q[<top><x>1</x></top>]);
Example: $node = Data::Stag->from($parser, $fn);
Similar to
parse
slurps a file or string into a Data::Stag node structure.
The format can also be the name of a parsing module, or an actual parser object
unflatten
Title: unflatten
Args: data array
Returns: Data::Stag node
Example: $node = stag_unflatten(person=>[name=>$n, phone=>$p, address=>[street=>$s, city=>$c]]);
Creates a node structure from a semi-flattened representation, in which children
of a node are represented as a flat list of data rather than a list of array
references.
This means a structure can be specified as:
person=>[name=>$n,
phone=>$p,
address=>[street=>$s,
city=>$c]]
Instead of:
[person=>[ [name=>$n],
[phone=>$p],
[address=>[ [street=>$s],
[city=>$c] ] ]
]
]
The former gets converted into the latter for the internal representation
makehandler
Title: makehandler
Args: hash of CODEREFs keyed by element name
OR a string containing the name of a module
Returns: L<Data::Stag::BaseHandler>
Example: $h = Data::Stag->makehandler(%subs);
Example: $h = Data::Stag->makehandler("My::FooHandler");
Example: $h = Data::Stag->makehandler('xml');
This creates a Stag event handler. The argument is a hash of subroutines keyed
by element/node name. After each node is fired by the parser/generator, the
subroutine is called, passing the handler object and the stag node as
arguments. whatever the subroutine returns is placed back into the tree
For example, for a a parser/generator that fires events with the following tree
form
<person>
<name>foo</name>
...
</person>
we can create a handler that writes person/name like this:
$h = Data::Stag->makehandler(
person => sub { my ($self,$stag) = @_;
print $stag->name;
return $stag; # don't change tree
});
$stag = Data::Stag->parse(-str=>"(...)", -handler=>$h)
See Data::Stag::BaseHandler for details on handlers
getformathandler
Title: getformathandler
Args: format str OR L<Data::Stag::BaseHandler>
Returns: L<Data::Stag::BaseHandler>
Example: $h = Data::Stag->getformathandler('xml');
$h->file("my.xml");
Data::Stag->parse(-fn=>$fn, -handler=>$h);
Creates a Stag event handler - this handler can be passed to an event generator
/ parser. Built in handlers include:
- xml
- Generates xml tags from events
- sxpr
- Generates S-Expressions from events
- itext
- Generates itext format from events
- indent
- Generates indent format from events
All the above are kinds of Data::Stag::Writer
chainhandler
Title: chainhandler
Args: blocked events - str or str[]
initial handler - handler object
final handler - handler object
Returns:
Example: $h = Data::Stag->chainhandler('foo', $processor, 'xml')
chains handlers together - for example, you may want to make transforms on an
event stream, and then pass the event stream to another handler - for example,
and xml handler
$processor = Data::Stag->makehandler(
a => sub { my ($self,$stag) = @_;
$stag->set_foo("bar");
return $stag
},
b => sub { my ($self,$stag) = @_;
$stag->set_blah("eek");
return $stag
},
);
$chainh = Data::Stag->chainhandler(['a', 'b'], $processor, 'xml');
$stag = Data::Stag->parse(-str=>"(...)", -handler=>$chainh)
If the inner handler has a method
CONSUMES(), this method will determine
the blocked events if none are specified.
see also the script
stag-handle.pl
RECURSIVE SEARCHING¶
find (f)
Title: find
Synonym: f
Args: element str
Returns: node[] or ANY
Example: @persons = stag_find($struct, 'person');
Example: @persons = $struct->find('person');
recursively searches tree for all elements of the given type, and returns all
nodes or data elements found.
if the element found is a non-terminal node, will return the node if the element
found is a terminal (leaf) node, will return the data value
the element argument can be a path
@names = $struct->find('department/person/name');
will find name in the nested structure below:
(department
(person
(name "foo")))
findnode (fn)
Title: findnode
Synonym: fn
Args: element str
Returns: node[]
Example: @persons = stag_findnode($struct, 'person');
Example: @persons = $struct->findnode('person');
recursively searches tree for all elements of the given type, and returns all
nodes found.
paths can also be used (see
find)
findval (fv)
Title: findval
Synonym: fv
Args: element str
Returns: ANY[] or ANY
Example: @names = stag_findval($struct, 'name');
Example: @names = $struct->findval('name');
Example: $firstname = $struct->findval('name');
recursively searches tree for all elements of the given type, and returns all
data values found. the data values could be primitive scalars or nodes.
paths can also be used (see
find)
sfindval (sfv)
Title: sfindval
Synonym: sfv
Args: element str
Returns: ANY
Example: $name = stag_sfindval($struct, 'name');
Example: $name = $struct->sfindval('name');
as findval, but returns the first value found
paths can also be used (see
find)
findvallist (fvl)
Title: findvallist
Synonym: fvl
Args: element str[]
Returns: ANY[]
Example: ($name, $phone) = stag_findvallist($personstruct, 'name', 'phone');
Example: ($name, $phone) = $personstruct->findvallist('name', 'phone');
recursively searches tree for all elements in the list
DEPRECATED
DATA ACCESSOR METHODS¶
these allow getting and setting of elements directly underneath the current one
get (g)
Title: get
Synonym: g
Args: element str
Return: node[] or ANY
Example: $name = $person->get('name');
Example: @phone_nos = $person->get('phone_no');
gets the value of the named sub-element
if the sub-element is a non-terminal, will return a node(s) if the sub-element
is a terminal (leaf) it will return the data value(s)
the examples above would work on a data structure like this:
[person => [ [name => 'fred'],
[phone_no => '1-800-111-2222'],
[phone_no => '1-415-555-5555']]]
will return an array or single value depending on the context
[equivalent to
findval(), except that only direct children (as opposed to
all descendents) are checked]
paths can also be used, like this:
@phones_nos = $struct->get('person/phone_no')
sget (sg)
Title: sget
Synonym: sg
Args: element str
Return: ANY
Example: $name = $person->sget('name');
Example: $phone = $person->sget('phone_no');
Example: $phone = $person->sget('department/person/name');
as
get but always returns a single value
[equivalent to
sfindval(), except that only direct children (as opposed
to all descendents) are checked]
getl (gl getlist)
Title: gl
Synonym: getl
Synonym: getlist
Args: element str[]
Return: node[] or ANY[]
Example: ($name, @phone) = $person->getl('name', 'phone_no');
returns the data values for a list of sub-elements of a node
[equivalent to
findvallist(), except that only direct children (as
opposed to all descendents) are checked]
getn (gn getnode)
Title: getn
Synonym: gn
Synonym: getnode
Args: element str
Return: node[]
Example: $namestruct = $person->getn('name');
Example: @pstructs = $person->getn('phone_no');
as
get but returns the whole node rather than just the data value
[equivalent to
findnode(), except that only direct children (as opposed
to all descendents) are checked]
sgetmap (sgm)
Title: sgetmap
Synonym: sgm
Args: hash
Return: hash
Example: %h = $person->sgetmap('social-security-no'=>'id',
'name' =>'label',
'job' =>0,
'address' =>'location');
returns a hash of key/val pairs based on the values of the data values of the
subnodes in the current element; keys are mapped according to the hash passed
(a value of '' or 0 will map an identical key/val).
no multivalued data elements are allowed
set (s)
Title: set
Synonym: s
Args: element str, datavalue ANY (list)
Return: ANY
Example: $person->set('name', 'fred'); # single val
Example: $person->set('phone_no', $cellphone, $homephone);
sets the data value of an element for any node. if the element is multivalued,
all the old values will be replaced with the new ones specified.
ordering will be preserved, unless the element specified does not exist, in
which case, the new tag/value pair will be placed at the end.
for example, if we have a stag node $person
person:
name: shuggy
job: bus driver
if we do this
$person->set('name', ());
we will end up with
person:
job: bus driver
then if we do this
$person->set('name', 'shuggy');
the 'name' node will be placed as the last attribute
person:
job: bus driver
name: shuggy
You can also use
magic methods, for example
$person->set_name('shuggy');
$person->set_job('bus driver', 'poet');
print $person->itext;
will print
person:
name: shuggy
job: bus driver
job: poet
note that if the datavalue is a non-terminal node as opposed to a primitive
value, then you have to do it like this:
$people = Data::Stag->new(people=>[
[person=>[[name=>'Sherlock Holmes']]],
[person=>[[name=>'Moriarty']]],
]);
$address = Data::Stag->new(address=>[
[address_line=>"221B Baker Street"],
[city=>"London"],
[country=>"Great Britain"]]);
($person) = $people->qmatch('person', (name => "Sherlock Holmes"));
$person->set("address", $address->data);
If you are using XML data, you can set attributes like this:
$person->set('@'=>[[id=>$id],[foo=>$foo]]);
unset (u)
Title: unset
Synonym: u
Args: element str, datavalue ANY
Return: ANY
Example: $person->unset('name');
Example: $person->unset('phone_no');
prunes all nodes of the specified element from the current node
You can use
magic methods, like this
$person->unset_name;
$person->unset_phone_no;
free
Title: free
Synonym: u
Args:
Return:
Example: $person->free;
removes all data from a node. If that node is a subnode of another node, it is
removed altogether
for instance, if we had the data below:
<person>
<name>fred</name>
<address>
..
</address>
</person>
and called
$person->get_address->free
then the person node would look like this:
<person>
<name>fred</name>
</person>
add (a)
Title: add
Synonym: a
Args: element str, datavalues ANY[]
OR
Data::Stag
Return: ANY
Example: $person->add('phone_no', $cellphone, $homephone);
Example: $person->add_phone_no('1-555-555-5555');
Example: $dataset->add($person)
adds a datavalue or list of datavalues. appends if already existing, creates new
element value pairs if not already existing.
if the argument is a stag node, it will add this node under the current one.
For example, if we have the following node in $dataset
<dataset>
<person>
<name>jim</name>
</person>
</dataset>
And then we add data to it:
($person) = $dataset->qmatch('person', name=>'jim');
$person->add('phone_no', '555-1111', '555-2222');
We will be left with:
<dataset>
<person>
<name>jim</name>
<phone_no>555-1111</phone_no>
<phone_no>555-2222</phone_no>
</person>
</dataset>
The above call is equivalent to:
$person->add_phone_no('555-1111', '555-2222');
As well as adding data values, we can add whole nodes:
$dataset->add(person=>[[name=>"fred"],
[phone_no=>"555-3333"]]);
Which is equivalent to
$dataset->add_person([[name=>"fred"],
[phone_no=>"555-3333"]]);
Remember, the value has to be specified as an array reference of nodes. In
general, you should use the
addkid() method to add nodes and used
add() to add values
element (e name)
Title: element
Synonym: e
Synonym: name
Args:
Return: element str
Example: $element = $struct->element
returns the
element name of the current node.
This is illustrated in the different representation formats below
- sxpr
-
(element "data")
or
(element
(sub_element "..."))
- xml
-
<element>data</element>
or
<element>
<sub_element>...</sub_element>
</element>
- perl
-
[element => $data ]
or
[element => [
[sub_element => "..." ]]]
- itext
-
element: data
or
element:
sub_element: ...
- indent
-
element "data"
or
element
sub_element "..."
kids (k children)
Title: kids
Synonym: k
Synonym: children
Args:
Return: ANY or ANY[]
Example: @nodes = $person->kids
Example: $name = $namestruct->kids
returns the data value(s) of the current node; if it is a terminal node, returns
a single value which is the data. if it is non-terminal, returns an array of
nodes
addkid (ak addchild)
Title: addkid
Synonym: ak
Synonym: addchild
Args: kid node
Return: ANY
Example: $person->addkid($job);
adds a new child node to a non-terminal node, after all the existing child nodes
You can use this method/procedure to add XML attribute data to a node:
$person->addkid(['@'=>[[id=>$id]]]);
subnodes
Title: subnodes
Args:
Return: ANY[]
Example: @nodes = $person->subnodes
returns the child nodes; returns empty list if this is a terminal node
ntnodes
Title: ntnodes
Args:
Return: ANY[]
Example: @nodes = $person->ntnodes
returns all non-terminal children of current node
tnodes
Title: tnodes
Args:
Return: ANY[]
Example: @nodes = $person->tnodes
returns all terminal children of current node
QUERYING AND ADVANCED DATA MANIPULATION¶
ijoin (j)
Title: ijoin
Synonym: j
Synonym: ij
Args: element str, key str, data Node
Return: undef
does a relational style inner join - see previous example in this doc
key can either be a single node name that must be shared (analagous to SQL INNER
JOIN .. USING), or a key1=key2 equivalence relation (analagous to SQL INNER
JOIN ... ON)
qmatch (qm)
Title: qmatch
Synonym: qm
Args: return-element str, match-element str, match-value str
Return: node[]
Example: @persons = $s->qmatch('person', 'name', 'fred');
Example: @persons = $s->qmatch('person', (job=>'bus driver'));
queries the node tree for all elements that satisfy the specified key=val match
- see previous example in this doc
for those inclined to thinking relationally, this can be thought of as a query
that returns a stag object:
SELECT <return-element> FROM <stag-node> WHERE <match-element> = <match-value>
this always returns an array; this means that calling in a scalar context will
return the number of elements; for example
$n = $s->qmatch('person', (name=>'fred'));
the value of $n will be equal to the number of persons called fred
tmatch (tm)
Title: tmatch
Synonym: tm
Args: element str, value str
Return: bool
Example: @persons = grep {$_->tmatch('name', 'fred')} @persons
returns true if the the value of the specified element matches - see previous
example in this doc
tmatchhash (tmh)
Title: tmatchhash
Synonym: tmh
Args: match hashref
Return: bool
Example: @persons = grep {$_->tmatchhash({name=>'fred', hair_colour=>'green'})} @persons
returns true if the node matches a set of constraints, specified as hash.
tmatchnode (tmn)
Title: tmatchnode
Synonym: tmn
Args: match node
Return: bool
Example: @persons = grep {$_->tmatchnode([person=>[[name=>'fred'], [hair_colour=>'green']]])} @persons
returns true if the node matches a set of constraints, specified as node
cmatch (cm)
Title: cmatch
Synonym: cm
Args: element str, value str
Return: bool
Example: $n_freds = $personset->cmatch('name', 'fred');
counts the number of matches
where (w)
Title: where
Synonym: w
Args: element str, test CODE
Return: Node[]
Example: @rich_persons = $data->where('person', sub {shift->get_salary > 100000});
the tree is queried for all elements of the specified type that satisfy the
coderef (must return a boolean)
my @rich_dog_or_cat_owners =
$data->where('person',
sub {my $p = shift;
$p->get_salary > 100000 &&
$p->where('pet',
sub {shift->get_type =~ /(dog|cat)/})});
iterate (i)
Title: iterate
Synonym: i
Args: CODE
Return: Node[]
Example: $data->iterate(sub {
my $stag = shift;
my $parent = shift;
if ($stag->element eq 'pet') {
$parent->set_pet_name($stag->get_name);
}
});
iterates through whole tree calling the specified subroutine.
the first arg passed to the subroutine is the stag node representing the tree at
that point; the second arg is for the parent.
for instance, the example code above would turn this
(person
(name "jim")
(pet
(name "fluffy")))
into this
(person
(name "jim")
(pet_name "fluffy")
(pet
(name "fluffy")))
maptree
Title: maptree
Args: CODE
Return: Node[]
Example: $data->maptree(sub {
my $stag = shift;
my $parent = shift;
if ($stag->element eq 'pet') {
[pet=>$stag->sget_foo]
}
else {
$stag
}
});
MISCELLANEOUS METHODS¶
duplicate (d)
Title: duplicate
Synonym: d
Args:
Return: Node
Example: $node2 = $node->duplicate;
does a deep copy of a stag structure
isanode
Title: isanode
Args:
Return: bool
Example: if (stag_isanode($node)) { ... }
hash
Title: hash
Args:
Return: hash
Example: $h = $node->hash;
turns a tree into a hash. all data values will be arrayrefs
pairs
Title: pairs
turns a tree into a hash. all data values will be scalar (IMPORTANT: this means
duplicate values will be lost)
write
Title: write
Args: filename str, format str[optional]
Return:
Example: $node->write("myfile.xml");
Example: $node->write("myfile", "itext");
will try and guess the format from the extension if not specified
xml
Title: xml
Args: filename str, format str[optional]
Return:
Example: $node->write("myfile.xml");
Example: $node->write("myfile", "itext");
Args:
Return: xml str
Example: print $node->xml;
XML METHODS¶
xslt
Title: xslt
Args: xslt_file str
Return: Node
Example: $new_stag = $stag->xslt('mytransform.xsl');
transforms a stag tree using XSLT
xsltstr
Title: xsltstr
Args: xslt_file str
Return: str
Example: print $stag->xsltstr('mytransform.xsl');
As above, but returns the string of the resulting transform, rather than a stag
tree
sax
Title: sax
Args: saxhandler SAX-CLASS
Return:
Example: $node->sax($mysaxhandler);
turns a tree into a series of SAX events
xpath (xp tree2xpath)
Title: xpath
Synonym: xp
Synonym: tree2xpath
Args:
Return: xpath object
Example: $xp = $node->xpath; $q = $xp->find($xpathquerystr);
xpquery (xpq xpathquery)
Title: xpquery
Synonym: xpq
Synonym: xpathquery
Args: xpathquery str
Return: Node[]
Example: @nodes = $node->xqp($xpathquerystr);
STAG SCRIPTS¶
The following scripts come with the stag module
- stag-autoschema.pl
- writes the implicit stag-schema for a stag file
- stag-db.pl
- persistent storage and retrieval for stag data (xml, sxpr, itext)
- stag-diff.pl
- finds the difference between two stag files
- stag-drawtree.pl
- draws a stag file (xml, itext, sxpr) as a PNG diagram
- stag-filter.pl
- filters a stag file (xml, itext, sxpr) for nodes of interest
- stag-findsubtree.pl
- finds nodes in a stag file
- stag-flatten.pl
- turns stag data into a flat table
- stag-grep.pl
- filters a stag file (xml, itext, sxpr) for nodes of interest
- stag-handle.pl
- streams a stag file through a handler into a writer
- stag-join.pl
- joins two stag files together based around common key
- stag-mogrify.pl
- mangle stag files
- stag-parse.pl
- parses a file and fires events (e.g. sxpr to xml)
- stag-query.pl
- aggregare queries
- stag-split.pl
- splits a stag file (xml, itext, sxpr) into multiple files
- stag-splitter.pl
- splits a stag file into multiple files
- stag-view.pl
- draws an expandable Tk tree diagram showing stag data
To get more documentation, type
stag_<script> -h
BUGS¶
none known so far, possibly quite a few undocumented features!
Not a bug, but the underlying default datastructure of nested arrays is more
heavyweight than it needs to be. More lightweight implementations are
possible. Some time I will write a C implementation.
WEBSITE¶
<
http://stag.sourceforge.net>
AUTHOR¶
Chris Mungall <
cjm AT fruitfly DOT org>
COPYRIGHT¶
Copyright (c) 2004 Chris Mungall
This module is free software. You may distribute this module under the same
terms as perl itself