1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
NAME
XML::Handler::Trees - PerlSAX handlers for building tree structures
SYNOPSIS
use XML::Handler::Trees;
use XML::Parser::PerlSAX;
my $p=XML::Parser::PerlSAX->new();
my $h=XML::Handler::Tree->new();
my $tree=$p->parse(Handler=>$h,Source=>{SystemId=>'file.xml'});
my $p=XML::Parser::PerlSAX->new();
my $h=XML::Handler::EasyTree->new(Noempty=>1);
my $easytree=$p->parse(Handler=>$h,Source=>{SystemId=>'file.xml'});
my $p=XML::Parser::PerlSAX->new();
my $h=XML::Handler::TreeBuilder->new();
$h->store_pis(1);
my $tree=$p->parse(Handler=>$h,Source=>{SystemId=>'file.xml'});
DESCRIPTION
XML::Handler::Trees provides three PerlSAX handler classes for building
tree structures. XML::Handler::Tree builds the same type of tree as the
"Tree" style in XML::Parser. XML::Handler::EasyTree builds the same type
of tree as the "EasyTree" style added to XML::Parser by
XML::Parser::EasyTree. XML::Handler::TreeBuilder builds the same type of
tree as Sean M. Burke's XML::TreeBuilder. These classes make it possible
to construct these tree structures from sources other than XML::Parser.
All three handlers can be driven by either PerlSAX 1 or PerlSAX 2
drivers. In all cases, the end_document() method returns a reference to
the constructed tree, which normally becomes the return value of the
PerlSAX driver.
CLASS XML::Handler::Tree
This handler builds the same type of tree structure as the "Tree" style
in XML::Parser. Some modules such as Dan Brian's XML::SimpleObject work
with this type of tree. See the documentation for XML::Parser for
details.
METHODS
$handler = XML::Handler::Tree->new()
Creates a handler object.
CLASS XML::Handler::EasyTree
This handler builds a lightweight tree structure representing the XML
document. This structure is, at least in this author's opinion, easier
to work with than the "standard" style of tree. It is the same type of
structure as built by XML::Parser when using XML::Parser::EasyTree, or
by the get_simple_tree method in XML::Records.
The tree is returned as a reference to an array of tree nodes, each of
which is a hash reference. All nodes have a 'type' key whose value is
the type of the node: 'e' for element nodes, 't' for text nodes, and 'p'
for processing instruction nodes. All nodes also have a 'content' key
whose value is a reference to an array holding the element's child nodes
for element nodes, the string value for text nodes, and the data value
for processing instruction nodes. Element nodes also have an 'attrib'
key whose value is a reference to a hash of attribute names and values.
Processing instructions also have a 'target' key whose value is the PI's
target.
EasyTree nodes are ordinary Perl hashes and are not objects. Contiguous
runs of text are always returned in a single node.
The reason the parser returns an array reference rather than the root
element's node is that an XML document can legally contain processing
instructions outside the root element (the xml-stylesheet PI is commonly
used this way).
If namespace information is available (only possible with PerlSAX 2),
element and attribute names will be prefixed with their (possibly empty)
namespace URI enclosed in curly brackets, and namespace prefixes will be
stripped from names.
METHODS
$handler = XML::Handler::EasyTree->new([options])
Creates a handler object. Options can be provided hash-style:
Noempty
If this is set to a true value, text nodes consisting entirely
of whitespace will not be stored in the tree. The default is
false.
Latin
If this is set to a true value, characters with Unicode values
in the Latin-1 range (160-255) will be stored in the tree as
Latin-1 rather than UTF-8. The default is false.
CLASS XML::Handler::TreeBuilder
This handler builds XML document trees constructed of XML::Element
objects (XML::Element is a subclass of HTML::Element adapted for XML).
To use it, XML::TreeBuilder and its prerequisite HTML::Tree need to be
installed. See the documentation for those modules for information on
how to work with these tree structures.
METHODS
$handler = XML::Handler::TreeBuilder->new()
Creates a handler which builds a tree rooted in an XML::Element.
$root->store_comments(value)
This determines whether comments will be stored in the tree (not all
SAX drivers generate comment events). Currently, this is off by
default.
$root->store_declarations(value)
This determines whether markup declarations will be stored in the
tree. Currently, this is off by default. The present implementation
does not store markup declarations in any case; this method is
provided for future use.
$root->store_pis(value)
This determines whether processing instructions will be stored in
the tree. Currently, this is off (false) by default.
AUTHOR
Eric Bohlman (ebohlman@omsdev.com)
Copyright (c) 2001 Eric Bohlman. All rights reserved. This program is
free software; you can redistribute it and/or modify it under the same
terms as Perl itself.
SEE ALSO
L<perl>
L<XML::Parser>
L<XML::SimpleObject>
L<XML::Parser::EasyTree>
L<XML::TreeBuilder>
L<XML::Element>
L<HTML::Element>
L<PerlSAX>
|
