Parsers

• What is a parser?
Formal
grammar

Input Analyzed
Parser
Data

The structure(s) of the input,

according to the atomic elements and
their relationships (as described in the
grammar) 1
 XML-Parsing Standards

• We will consider two parsing methods that

implement W3C standards for accessing XML
• DOM
- convert XML into a tree of objects
- “random access” protocol
• SAX
- “serial access” protocol
- event-driven parsing

2
XML Examples

3
 root element
<?xml version="1.0"?> world.xml
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> validating DTD file
reference to an
<name>Israel</name> entity
<population year="2001">6,199,008</population>
<city capital="yes"><name>Jerusalem</name></city>
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
4
 XML Tree Model
element
countries
element

country
continent

name city
Asia city
capital
capital name
Israel name
population country

no Ashdod population
year
6,199,008 year
yes continent name
Jerusalem 60,424,213
2001
Europe
France 2004
attribute simple 5
content
<!ELEMENT countries (country*)> world.dtd
<!ELEMENT country (name,population?,city*)>
<!ATTLIST country continent CDATA #REQUIRED>
<!ELEMENT name (#PCDATA)>
parsed
<!ELEMENT city (name)> Not parsed default

<!ATTLIST city capital (yes|no) "no"> value

<!ELEMENT population (#PCDATA)>

<!ATTLIST population year CDATA #IMPLIED>
<!ENTITY eu "Europe">
<!ENTITY as "Asia"> As opposed
to required
<!ENTITY af "Africa">
<!ENTITY am "America">
<!ENTITY au "Australia">
Open world.xml in your browser
6
Check world2.xml for #PCDATA exmaple
 Namespaces
<?xml version="1.0"?> sales.xml
<forsale date="12/2/03"
xmlns:xhtml="http://www.w3.org/1999/xhtml">
<book> “xhtml” namespace
<title> <xhtml:em>DBI:</xhtml:em> declaration

<![CDATA[Where I Learned <xhtml>.]]>

(non-parsed)
</title> character data
<comment
xmlns="http://www.cs.huji.ac.il/~dbi/comments">
<par>My <xhtml:b> favorite </xhtml:b> book!</par>
</comment>
</book> default namespace namespace
declaration overriding
7
</forsale>
<?xml version="1.0"?> sales.xml
<forsale date="12/2/03"
xmlns:xhtml="http://www.w3.org/1999/xhtml">
<book>
<title> <xhtml:h1> DBI </xhtml:h1>
<![CDATA[Where I Learned <xhtml>.]]>
</title>
<comment
xmlns="http://www.cs.huji.ac.il/~dbi/comments">
Namespace: “http://www.w3.org/1999/xhtml”
<par>My <xhtml:b> favorite </xhtml:b> book!</par>
Local name: “h1”
</comment>
Qualified name: “xhtml:h1”
</book>
</forsale> 8
<?xml version="1.0"?> sales.xml
<forsale date="12/2/03"
xmlns:xhtml="http://www.w3.org/1999/xhtml">
<book>
Namespace: “http://www.cs.huji.ac.il/~dbi/comments”
<title> <xhtml:h1> DBI </xhtml:h1>
Local name: “par” I Learned <xhtml>.]]>
<![CDATA[Where
Qualified name: “par”
</title>
<comment
xmlns="http://www.cs.huji.ac.il/~dbi/comments">
<par>My <xhtml:b> favorite </xhtml:b> book!</par>
</comment>
</book>
</forsale> 9
<?xml version="1.0"?> sales.xml
<forsale date="12/2/03"
xmlns:xhtml="http://www.w3.org/1999/xhtml">
<book>
<title> <xhtml:h1>DBI</xhtml:h1>
<![CDATA[Where I Learned <xhtml>.]]>
</title>
<comment
xmlns="http://www.cs.huji.ac.il/~dbi/comments">
<par>My <xhtml:b> favorite </xhtml:b> book!</par>
Namespace: “”
</comment>
Local name: “title”
</book>
</forsale> Qualified name: “title” 10
<?xml version="1.0"?> sales.xml
<forsale date="12/2/03"
xmlns:xhtml="http://www.w3.org/1999/xhtml">
<book>
<title> <xhtml:h1>DBI</xhtml:h1>
Namespace: “http://www.w3.org/1999/xhtml”
<![CDATA[Where
Local name: “b” I Learned <xhtml>.]]>
</title>
Qualified name: “xhtml:b”
<comment
xmlns="http://www.cs.huji.ac.il/~dbi/comments">
<par>My <xhtml:b> favorite </xhtml:b> book!</par>
</comment>
</book>
</forsale> 11
DOM – Document Object
Model

12
 DOM Parser

• DOM = Document Object Model

• Parser creates a tree object out of the document
• User accesses data by traversing the tree
- The tree and its traversal conform to a W3C standard
• The API allows for constructing, accessing and
manipulating the structure and content of XML
documents

13
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;">
<name>Israel</name>
<population year="2001">6,199,008</population>
<city capital="yes"><name>Jerusalem</name></city>
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
14
 Document
The DOM Tree
countries

country
continent

name city
Asia city
capital
capital name
Israel name
population country

no Ashdod population
year
6,199,008 year
yes continent name
Jerusalem 60,424,213
2001
Europe
France 2004 15
 Using a DOM Tree

A
P Application
I
XML File DOM Parser DOM Tree

in memory

16
17
 Creating a DOM Tree

• A DOM tree is generated by a DocumentBuilder

• The builder is generated by a factory, in order to be
implementation independent
• The factory is chosen according to the system
configuration
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse("world.xml");
18
 Configuring the Factory

• The methods of the document-builder factory

enable you to configure the properties of the
document building
• For example
- factory.setValidating(true)
- factory.setIgnoringComments(false)

Read more about DocumentBuilderFactory Class,

DocumentBuilder Class 19
 The Node Interface
• The nodes of the DOM tree include
- a special root (denoted document)
• The Document interface retrieved by builder.parse(…)
actually extends the Node Interface
- element nodes This is very
unintuitive
- text nodes and CDATA sections (some
- attributes would even
say this is
- comments a bloated
- and more ... design)
• Every node in the DOM tree implements the Node
interface
20
 Figure as appears in : “The XML Companion” - Neil Bradley

A light- Interfaces in a DOM Tree

weight
fragment DocumentFragment
of the Document
document. Text CDATASection
Can hold CharacterData
several Comment
sub-trees Attr
Element
Node
DocumentType
Notation NodeList

Entity NamedNodeMap
EntityReference
Run
ProcessingInstruction FragmentVsElement
with 1st argument
DocumentType fragment/element
21
 Interfaces in the DOM Tree
Document

Document Type Element

Attribute Attribute Element Element Text

Text Element Entity Reference Text Text

Comment Text

22
 Node Navigation

• Every node has a specific location in tree

• Node interface specifies methods for tree navigation
- Node getFirstChild();
- Node getLastChild();
- Node getNextSibling();
- Node getPreviousSibling();
- Node getParentNode();
- NodeList getChildNodes();
- NamedNodeMap getAttributes()

23
 Node Navigation (cont)

getPreviousSibling()
getFirstChild()

getParentNode() getChildNodes()

getLastChild()
getNextSibling()

24
Not a very OO
approach… reminds Only Element
one of simulating OO Node Properties Nodes have
using unions in C…. attributes…
some would
• Every node has (a dubious design and…) say this
- a type Very few nodes have should’ve been
- a name both a significant name
and a significant value
a property of
the Element
- a value derived class
and not of
- attributes Node.
• The roles of these properties differ according to the
node types
• Nodes of different types implement different interfaces
(that extend Node)

25
 Names, Values and Attributes
Interface nodeName nodeValue attributes
Attr name of attribute value of attribute null
CDATASection "#cdata-section" content of the Section null
Comment "#comment" content of the comment null
Document "#document" null null
DocumentFragment "#document-fragment" null null
DocumentType doc-type name null null
Element tag name null NodeMap
Entity entity name null null
EntityReference name of entity referenced null null
Notation notation name null null
ProcessingInstruction target entire content null
Text "#text" content of the text node null

26
 Node Types - getNodeType()
ELEMENT_NODE = 1 PROCESSING_INSTRUCTION_NODE = 7
ATTRIBUTE_NODE = 2 COMMENT_NODE = 8
TEXT_NODE = 3 DOCUMENT_NODE = 9
CDATA_SECTION_NODE = 4 DOCUMENT_TYPE_NODE = 10
ENTITY_REFERENCE_NODE = 5 DOCUMENT_FRAGMENT_NODE = 11
ENTITY_NODE = 6 NOTATION_NODE = 12

if (myNode.getNodeType() == Node.ELEMENT_NODE) {
//process node
…
}
Read more about Node Interface
27
import org.w3c.dom.*;
import javax.xml.parsers.*;

public class EchoWithDom {

public static void main(String[] args) throws Exception {

DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
factory.setIgnoringElementContentWhitespace(true);
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(“world.xml");
new EchoWithDom().echo(doc);
} e.g white spaces used for indentation in non mixed
28
data elements
private void echo(Node n) {
print(n);
if (n.getNodeType() == Node.ELEMENT_NODE) {
NamedNodeMap atts = n.getAttributes();
++depth;
for (int i = 0; i < atts.getLength(); i++) echo(atts.item(i));
--depth; }

depth++;
for (Node child = n.getFirstChild(); child != null;
child = child.getNextSibling()) echo(child);
depth--;
Attribute nodes
} are not included… 29
private int depth = 0;
private String[] NODE_TYPES = {
"", "ELEMENT", "ATTRIBUTE", "TEXT", "CDATA",
"ENTITY_REF", "ENTITY", "PROCESSING_INST",
"COMMENT", "DOCUMENT", "DOCUMENT_TYPE",
"DOCUMENT_FRAG", "NOTATION" };
private void print(Node n) {
for (int i = 0; i < depth; i++) System.out.print(" ");

System.out.print(NODE_TYPES[n.getNodeType()] + ":");
System.out.print("Name: "+ n.getNodeName());
System.out.print(" Value: "+ n.getNodeValue()+"\n");
}} run EchoWithDom,
30
pay attention to the default values
 Another Example
public class WorldParser {

public static void main(String[] args) throws Exception {

DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
factory.setIgnoringElementContentWhitespace(true);
DocumentBuilder builder =
factory.newDocumentBuilder();
Document doc = builder.parse("world.xml");
printCities(doc);
}
31
 Another Example (cont)
public static void printCities(Document doc) {
NodeList cities = doc.getElementsByTagName("city");
for(int i=0; i<cities.getLength(); ++i) {
printCity((Element)cities.item(i)); Searches within
descendents
}
}
public static void printCity(Element city) {
Node nameNode =
city.getElementsByTagName("name").item(0);
String cName = nameNode.getFirstChild().getNodeValue();
System.out.println("Found City: " + cName);
32
} run WorldParser
 Normalizing the DOM Tree

• Normalizing a DOM Tree has two effects:

- Combine adjacent textual nodes Created by node
- Eliminate empty textual nodes manipulation…

• To normalize, apply the normalize()

method to the document element

33
 Node Manipulation
• Children of a node in a DOM tree can be manipulated -
added, edited, deleted, moved, copied, etc.
• To constructs new nodes, use the methods of
Document
- createElement, createAttribute, createTextNode,
createCDATASection etc.
• To manipulate a node, use the methods of Node
- appendChild, insertBefore, removeChild, replaceChild,
setNodeValue, cloneNode(boolean deep) etc.

34
 Figure as appears in “The XML Companion” - Neil Bradley

Node Manipulation (cont)

Old

New New
Ref
insertBefore replaceChild

deep = 'false'

cloneNode deep = 'true'

35
SAX – Simple API for
XML

36
 SAX Parser
• SAX = Simple API for XML
• XML is read sequentially
• When a parsing event happens, the parser
invokes the corresponding method of the
corresponding handler.
• This is called event-driven programming. Most
GUI programs are written using this paradigm.
• The handlers are programmer’s implementation
of standard Java API (i.e., interfaces and classes)
37
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
<city capital="yes"><name>Jerusalem</name></city>
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
38
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
Start
<city capital="yes"><name>Jerusalem</name></city>
Document
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
39
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
Start
<city capital="yes"><name>Jerusalem</name></city>
Element
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
40
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
Start
<city capital="yes"><name>Jerusalem</name></city>
Element
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
41
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
Comment
<city capital="yes"><name>Jerusalem</name></city>
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
42
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
Start
<city capital="yes"><name>Jerusalem</name></city>
Element
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
43
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
Characters
<city capital="yes"><name>Jerusalem</name></city>
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
44
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
<city capital="yes"><name>Jerusalem</name></city>
End
<city><name>Ashdod</name></city>
</country> Element
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
45
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
End
<city capital="yes"><name>Jerusalem</name></city>
Element
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
46
<?xml version="1.0"?>
<!DOCTYPE countries SYSTEM "world.dtd">
<countries>
<country continent="&as;"> <!--israel-->
<name>Israel</name>
<population year="2001">6,199,008</population>
End
<city capital="yes"><name>Jerusalem</name></city>
Document
<city><name>Ashdod</name></city>
</country>
<country continent="&eu;">
<name>France</name>
<population year="2004">60,424,213</population>
</country>
</countries>
47
 SAX Parsers

<?xml version="1.0"?>
.
.
. When you see
the start of the
document do …
SAX Parser When you see
the start of an
element do … When you see
the end of an
element do …

48
Used to create a
SAX Parser Handles document
events: start tag,
XML-Reader end tag, etc.
Factory
Handles
Content Parser
Handler Errors

Error
XML Handler Handles
XML Reader DTD
DTD
Handler

Entity Handles
Resolver Entities
49
 Creating a Parser
• The SAX interface is an accepted standard
• There are many implementations of many
vendors
- Standard API does not include an actual
implementation, but Sun provides one with JDK
• We would like to be able to change the
implementation used, without changing any code
in the program
- How is this done?

50
 Factory Design Pattern
• Have a “factory” class that creates the actual parsers
- org.xml.sax.helpers.XMLReaderFactory
• The factory checks configurations, mainly the value of a
system property, that specify the implementation
- Can be set outside the Java code: a configuration file, a
command-line argument, etc.
• In order to change the implementation, simply change
the system property

Read more about XMLReaderFactory Class

51
 Creating a SAX Parser
import org.xml.sax.*;
import org.xml.sax.helpers.*;
public class EchoWithSax {
public static void main(String[] args) throws Exception {
System.setProperty("org.xml.sax.driver",
Implements
"org.apache.xerces.parsers.SAXParser"); XMLReader
XMLReader reader =
XMLReaderFactory.createXMLReader();
reader.parse("world.xml");
}
Read more about XMLReader Interface, Xerces SAXParser class
} 52
 Implementing the Content Handler

• A SAX parser invokes methods such as

startDocument, startElement and
endElement of its content handler as it runs
• In order to react to parsing events we must:
- implement the ContentHandler interface
- set the parser’s content handler with an instance of
our ContentHandler implementation

53
 ContentHandler Methods
• startDocument - parsing begins
• endDocument - parsing ends
• startElement - an opening tag is encountered
• endElement - a closing tag is encountered
• characters - text (CDATA) is encountered
• ignorableWhitespace - white spaces that should
be ignored (according to the DTD)
• and more ...
Read more about ContentHandler Interface
54
 The Default Handler

• The class DefaultHandler implements all

handler interfaces (usually, in an empty manner)
- i.e., ContentHandler, EntityResolver,
DTDHandler, ErrorHandler

• An easy way to implement the ContentHandler

interface is to extend DefaultHandler

Read more about DefaultHandler Class

55
 A Content Handler Example
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.*;

public class EchoHandler extends DefaultHandler {

int depth = 0;

public void print(String line) {

for(int i=0; i<depth; ++i) System.out.print(" ");
System.out.println(line);
} 56
 A Content Handler Example
public void startDocument() throws SAXException {
print("BEGIN"); }
public void endDocument() throws SAXException {
print("END"); }

public void startElement(String ns, String localName,

String qName, Attributes attrs) throws SAXException {
print("Element " + qName + "{"); We will discuss this
interface later…
++depth;
for (int i = 0; i < attrs.getLength(); ++i)
print(attrs.getLocalName(i) + "=" + attrs.getValue(i));
57 }
 A Content Handler Example
public void endElement(String ns, String lName,
String qName) throws SAXException {
--depth;
print("}"); }

public void characters(char buf[], int offset, int len)

throws SAXException {
String s = new String(buf, offset, len).trim();
++depth; print(s); --depth; } }

58
 Fixing The Parser
public class EchoWithSax {
public static void main(String[] args) throws Exception {
XMLReader reader =
XMLReaderFactory.createXMLReader();
reader.setContentHandler(new EchoHandler());
reader.parse("world.xml");
}
}

What would happen

without this line?
run EchoWithSax
run the EchoWithSax2 59
 Empty Elements

• What do you think happens when the parser

parses an empty element?
<rating stars="five" />

run EchoWithSax3
60
 Attributes Interface
• The Attributes interface provides an access to all
attributes of an element
- getLength(), getQName(i), getValue(i),
getType(i), getValue(qname), etc. #attributes
• The following are possible types for attributes:
CDATA, ID, IDREF, IDREFS, NMTOKEN, NMTOKENS,
ENTITY, ENTITIES, NOTATION
• There is no distinction between attributes that are
defined explicitly from those that are specified in the
DTD (with a default value)
Read more about Attributes Interface
run EchoWithSax and check “capital” attribute, compare to xml
61 source
 ErrorHandler Interface
• We implement ErrorHandler to receive error events
(similar to implementing ContentHandler)
• DefaultHandler implements ErrorHandler in
an empty fashion, so we can extend it (as before)
• An ErrorHandler is registered with
- reader.setErrorHandler(handler);

• Three methods:
- void error(SAXParseException ex);
- void fatalError(SAXParserExcpetion ex);
- void warning(SAXParserException ex);
62
 Parsing Errors
• Fatal errors disable the parser from continuing parsing
- For example, the document is not well formed, an unknown
XML version is declared, etc.
• Errors (that is recoverable ones) occur for example
when the parser is validating and validity constrains are
violated
• Warnings occur when abnormal (yet legal) conditions
are encountered
- For example, an entity is declared twice in the DTD

Read more about ErrorHandler Interface

63
 EntityResolver and DTDHandler

• The interface EntityResolver enables the

programmer to specify a new source for
translation of external entities e.g. external
DTD

• The interface DTDHandler enables the

programmer to react to notations and unparsed
entities declarations inside the DTD
Usually appear with external non-xml
resources and describe their type
Read more about EntityResolver Interface,
DTDHandler Interface 64
 Features and Properties
• SAX parsers can be configured by setting their features and
properties
• Syntax:
- reader.setFeature("feature-url", boolean)
- reader.setProperty("property-url", Object)

• Standard feature URLs have the form:

http://xml.org/sax/features/feature-name

• Standard property URLs have the form

http://xml.org/sax/properties/prop-name

• Using URLs is a (confusing) technique used to ensure unique

names for non-standard features and properties added by different
implementations. These URLs do not represent web addresses!
65
 Feature/Property Examples
• Features:
- namespaces - are namespaces supported?
- validation - does the parser validate (against the
declared DTD) ?
- http://apache.org/xml/features/nonvalidating/load-external-dtd
• Ignore the DTD? (spec. to Xerces implementation)
Read more about Features

• Properties:
- xml-string - the actual text that caused the
current event (read-only with getProperty())
- lexical-handler - see the next slide...
Read more about Properties
66
 Lexical Events

• Lexical events have to do with the way that a document

was written and not with its content
• Examples:
- A comment is a lexical event (<!-- comment -->)
- The use of an entity is a lexical event (&gt;)

• These can be dealt with by implementing the

LexicalHandler interface, and setting the lexical-
handler property to an instance of the handler

67
 LexicalHandler Methods

• comment(char[] ch, int start, int length)

• startCDATA()
• endCDATA()
• startEntity(java.lang.String name)
• endEntity(java.lang.String name)
• and more...

Read more about LexicalHandler Interface

68
SAX vs. DOM

69
 Parser Efficiency
• The DOM object built by DOM parsers is usually
complicated (composed of many, many objects) and
requires more memory storage than the XML file itself.
- A lot of time is spent on construction before use.
- For some very large documents, this may be impractical.
• SAX parsers store only local information that is
encountered during the serial traversal and do not create
many temporary objects during traversal.
• Hence, programming with SAX parsers is, in general,
more efficient.

70
 Programming using SAX is
Difficult
• In some cases, programming with SAX might
seem difficult at a first glance:
- How can we find, using a SAX parser, elements e1
with ancestor e2?
- How can we find, using a SAX parser, elements e1
that have a descendant element e2?
- How can we find the element e1 referenced by the
IDREF attribute of e2?
• In other cases, using SAX can be more elegant.
71
 Node Navigation
• SAX parsers do not provide access to elements other
than the one currently visited in the serial (DFS)
traversal of the document
• In particular,
- They do not read backwards
- They do not enable access to elements by ID or name
• DOM parsers enable any traversal method
• Hence, using DOM parsers can be more comfortable

72
 More DOM Advantages

• DOM object  compiled XML

• You can save time and effort if you send and
receive DOM objects instead of XML files
- But, DOM object are generally larger than the source
• DOM parsers provide a natural integration of
XML reading and manipulating
- e.g., “cut and paste” of XML fragments

73
 Which should we use?
DOM vs. SAX
• If your document is very large and you only need
a few elements – use SAX
• If you need to manipulate (i.e., change) the XML
– use DOM
• If you need to access the XML many times – use
DOM (assuming the file is not too large)
• Depending on the task it hand, it might be easier
for you to visualize it implemented using one of
the APIs and not the other – so use it!
74