You are previewing Beginning XML, 4th Edition.
O'Reilly logo
Beginning XML, 4th Edition

Book Description

When the first edition of this book was written, XML was a relatively new language but already gaining ground fast and becoming more and more widely used in a vast range of applications. By the time of the second edition, XML had already proven itself to be more than a passing fad, and was in fact being used throughout the industry for an incredibly wide range of uses. With the third edition, it was clear that XML was a mature technology, but more important, it became evident that the XML landscape was dividing into several areas of expertise. Now in this edition, we needed to categorize the increasing number of specifications surrounding XML, which either use XML or provide functionality in addition to the XML core specification.

So what is XML? It's a markup language, used to describe the structure of data in meaningful ways. Anywhere that data is input/output, stored, or transmitted from one place to another, is a potential fit for XML's capabilities. Perhaps the most well-known applications are web-related (especially with the latest developments in handheld web access—for which some of the technology is XML-based). However, there are many other non-web-based applications for which XML is useful—for example, as a replacement for (or to complement) traditional databases, or for the transfer of financial information between businesses. News organizations, along with individuals, have also been using XML to distribute syndicated news stories and blog entries.

This book aims to teach you all you need to know about XML—what it is, how it works, what technologies surround it, and how it can best be used in a variety of situations, from simple data transfer to using XML in your web pages. It answers the fundamental questions:

  • What is XML?

  • How do you use XML?

  • How does it work?

* What can you use it for, anyway?

This book is for people who know that it would be a pretty good idea to learn XML but aren't 100 percent sure why. You've heard the hype but haven't seen enough substance to figure out what XML is and what it can do. You may be using development tools that try to hide the XML behind user interfaces and scripts, but you want to know what is really happening behind the scenes. You may already be somehow involved in web development and probably even know the basics of HTML, although neither of these qualifications is absolutely necessary for this book.

What you don't need is knowledge of markup languages in general. This book assumes that you're new to the concept of markup languages, and we have structured it in a way that should make sense to the beginner and yet quickly bring you to XML expert status.

The word "Beginning" in the title refers to the style of the book, rather than the reader's experience level. There are two types of beginner for whom this book is ideal:

  • Programmers who are already familiar with some web programming or data exchange techniques. Programmers in this category will already understand some of the concepts discussed here, but you will learn how you can incorporate XML technologies to enhance those solutions you currently develop.

  • Those working in a programming environment but with no substantial knowledge or experience of web development or data exchange applications. In addition to learning how XML technologies can be applied to such applications, you will be introduced to some new concepts to help you understand how such systems work.

The subjects covered in this book are arranged to take you from novice to expert in as logical a manner as we could. This Fourth Edition is structured in sections based on various areas of XML expertise. Unless you are already using XML, you should start by reading the introduction to XML in Part I. From there, you can quickly jump into specific areas of expertise, or, if you prefer, you can read through the book in order. Keep in mind that there is quite a lot of overlap in XML, and that some of the sections make use of techniques described elsewhere in the book.

  • The book begins by explaining what exactly XML is and why the industry felt that a language like this was needed.

  • After covering the why, the next logical step is the how, so it shows you how to create well-formed XML.

  • Once you understand the whys and hows of XML, you'll go on to some more advanced things you can do when creating your XML documents, to make them not only well formed, but valid. (And you'll learn what "valid" really means.)

  • After you're comfortable with XML and have seen it in action, the book unleashes the programmer within and looks at an XML-based programming language that you can use to transform XML documents from one format to another.

  • Eventually, you will need to store and retrieve XML information from databases. At this point, you will learn not only the state of the art for XML and databases, but also how to query XML information using an SQL-like syntax called XQuery.

  • XML wouldn't really be useful unless you could write programs to read the data in XML documents and create new XML documents, so we'll get back to programming and look at a couple of ways that you can do that.

  • Understanding how to program and use XML within your own business is one thing, but sending that information to a business partner or publishing it to the Internet is another. You'll learn about technologies that use XML that enable you to send messages across the Internet, publish information, and discover services that provide information.

  • Since you have all of this data in XML format, it would be great if you could easily display it to people, and it turns out you can. You'll see an XML version of HTML called XHTML. You'll also look at a technology you may already be using in conjunction with HTML documents called CSS. CSS enables you to add visual styles to your XML documents. In addition, you'll learn how to design stunning graphics and make interactive forms using XML.

  • Finally, the book ends with a case study, which should help to give you ideas about how XML can be used in real-life situations, and which could be used in your own applications.

This book builds on the strengths of the earlier editions, and provides new material to reflect the changes in the XML landscape—notably XQuery, RSS and Atom, and AJAX. Updates have been made to reflect the most recent versions of specifications and best practices throughout the book. In addition to the many changes, each chapter has a set of exercise questions to test your understanding of the material. Possible solutions to these questions appear in Appendix A.

Part I: Introduction: The introduction is where most readers should begin. The first three chapters introduce some of the goals of XML as well as the specific rules for constructing XML. Once you have read this part you should be able to read and create your own XML documents.

Chapter 1: What Is XML?: This chapter cover some basic concepts, introducing the fact that XML is a markup language (a bit like HTML) whereby you can define your own elements, tags, and attributes (known as a vocabulary). You'll see that tags have no presentation meaning—they're just a way to describe the structure of the data.

Chapter 2: Well-Formed XML: In addition to explaining what well-formed XML is, we offer a look at the rules that exist (the XML 1.0 and 1.1 Recommendations) for naming and structuring elements—you need to comply with these rules in order to produce well-formed XML.

Chapter 3: XML Namespaces: Because tags can be made up, you need to avoid name conflicts when sharing documents. Namespaces provide a way to uniquely identify a group of tags, using a URI. This chapter explains how to use namespaces.

Part II: Validation: In addition to the well-formedness rules you learn in Part I, you will most likely want to learn how to create and use different XML vocabularies. This Part introduces you to DTDs, XML Schemas, and RELAX NG: three languages that define custom XML vocabularies. It also shows you how to utilize these definitions to validate your XML documents.

Chapter 4: Document Type Definitions: You can specify how an XML document should be structured, and even provide default values, using Document Type Definitions (DTDs). If XML conforms to the associated DTD, it is known as valid XML. This chapter covers the basics of using DTDs.

Chapter 5: XML Schemas: XML Schemas, like DTDs, enable you to define how a document should be structured. In addition to defining document structure, they enable you to specify the individual datatypes of attribute values and element content. They are a more powerful alternative to DTDs.

Chapter 6: RELAX NG: RELAX NG is a third technology used to define the structure of documents. In addition to a new syntax and new features, it takes the best from XML Schemas and DTDs, and is therefore very simple and very powerful. RELAX NG has two syntaxes; both the full syntax and compact syntax are discussed.

Part III: Processing: In addition to defining and creating XML documents, you need to know how to work with documents to extract information and convert it to other formats. In fact, easily extracting information and converting it to other formats is what makes XML so powerful.

Chapter 7: XPath: The XPath language is used to locate sections and data in the XML document, and it's important in many other XML technologies.

Chapter 8: XSLT: XML can be transformed into other XML documents, HTML, and other formats using XSLT stylesheets, which are introduced in this chapter.

Part IV: Databases: Creating and processing XML documents is good, but eventually you will want to store those documents. This section describes strategies for storing and retrieving XML documents and document fragments from different databases.

Chapter 9: XQuery, the XML Query Language: Very often, you will need to retrieve information from within a database. XQuery, which is built on XPath and XPath2, enables you to do this in an elegant way.

Chapter 10: XML and Databases: XML is perfect for structuring data, and some traditional databases are beginning to offer support for XML. This chapter discusses these, and provides a general overview of how XML can be used in an n-tier architecture. In addition, new databases based on XML are introduced.

Part V: Programming: At some point in your XML career, you will need to work with an XML document from within a custom application. The two most popular methodologies, the Document Object Model (DOM) and the Simple API for XML (SAX), are explained in this part.

Chapter 11: The Document Object Model (DOM): Programmers can use a variety of programming languages to manipulate XML using the Document Object Model's objects, interfaces, methods, and properties, which are described in this chapter.

Chapter 12: Simple API for XML (SAX): An alternative to the DOM for programmatically manipulating XML data is to use the Simple API for XML (SAX) as an interface. This chapter shows how to use SAX and utilizes examples from the Java SAX API.

Part VI: Communication: Sending and receiving data from one computer to another is often difficult, but several technologies have been created to make communication with XML much easier. This part discusses RSS and content syndication, as well as web services and SOAP. This edition includes a new chapter on Ajax techniques.

Chapter 13: RSS, Atom, and Content Syndication: RSS is an actively evolving technology that is used to publish syndicated news stories and website summaries on the Internet. This chapter not only discusses how to use the different versions of RSS and Atom, it also covers the future direction of the technology. In addition, it demonstrates how to create a simple newsreader application that works with any of the currently published versions.

Chapter 14: Web Services: Web services enable you to perform cross-computer communications. This chapter describes web services and introduces you to using remote procedure calls in XML (using XML-RPC and REST), as well as giving you a brief look at major topics such as SOAP. Finally, it breaks down the assortment of specifications designed to work in conjunction with web services.

Chapter 15: SOAP and WSDL: Fundamental to XML web services, the Simple Object Access Protocol (SOAP) is one of the most popular specifications for allowing cross-computer communications. Using SOAP, you can package up XML documents and send them across the Internet to be processed. This chapter explains SOAP and the Web Services Description Language (WSDL) that is used to publish your service.

Chapter 16: Ajax: Ajax enables you to utilize JavaScript with web services and SOAP, or REST communications. Additionally, Ajax patterns can be used within web pages to communicate with the web server without refreshing. This chapter is new to the Fourth Edition.

Part VII: Display: Several XML technologies are devoted to displaying the data stored inside of an XML document. Some of these technologies are web-based, and some are designed for applications and mobile devices. This part discusses the primary display strategies and formats used today.

Chapter 17: Cascading Style Sheets (CSS): Website designers have long been using Cascading Style Sheets (CSS) with their HTML to easily make changes to a website's presentation without having to touch the underlying HTML documents. This power is also available for XML, enabling you to display XML documents right in the browser. Or, if you need a bit more flexibility with your presentation, you can use XSLT to transform your XML to HTML or XHTML and then use CSS to style these documents.

Chapter 18: XHTML: XHTML is a new version of HTML that follows the rules of XML. This chapter discusses the differences between HTML and XHTML, and shows you how XHTML can help make your sites available to a wider variety of browsers, from legacy browsers to the latest browsers on mobile phones.

Chapter 19: Scalable Vector Graphics (SVG): Do you want to produce a custom graphic using XML? SVG enables you to describe a graphic using XML-based vector commands. This chapter teaches you the basics of SVG and then dives into a more complex SVG-based application that can be published to the Internet.

Chapter 20: XForms: XForms are XML-based forms that can be used to design desktop applications, paper-based forms, and of course XHTML-based forms. This chapter demonstrates both the basics and some of the more interesting uses of XForms.

Part VIII: Case Study: Throughout the book you'll gain an understanding of how XML is used in web, business-to-business (B2B), data storage, and many other applications. The case study covers an example application and shows how the theory can be put into practice in real-life situations. The case study is new to this edition.

Chapter 21: Case Study: Payment Calculator: This case study explores some of the possibilities and strategies for using XML in your website. It includes an example that demonstrates a loan payment calculator by creating a web page using XHTML and CSS, communicating with a local web service using AJAX, utilizing an XML Schema to build data structures in .NET, and ultimately using the Document Object Model to display the results in SVG. An online version of this case study on the book's website covers the same material using Ruby on Rails instead of .NET.

Appendixes: Appendix A provides answers to the exercise questions that appear throughout the book. The remaining appendixes provide reference material that you may find useful as you begin to apply the knowledge gained throughout the book in your own applications. These are: Appendix B: XPath Reference; Appendix C: XSLT Reference; Appendix D: The XML Document Object Model; Appendix E: XML Schema Element and Attribute Reference; Appendix F: XML Schema Datatypes Reference; Appendix G: SAX 2.0.2 Reference. Appendixes A, B, and C are included within the book; Appendixes D-G are available on the book's website.

Table of Contents

  1. Copyright
  2. About the Authors
  3. Credits
  4. Acknowledgments
  5. Introduction
    1. 0.1. Who Is This Book For?
    2. 0.2. How This Book Is Organized
    3. 0.3. What's Covered in This Book
      1. 0.3.1. Part I: Introduction
        1. 0.3.1.1. Chapter 1: What Is XML?
        2. 0.3.1.2. Chapter 2: Well-Formed XML
        3. 0.3.1.3. Chapter 3: XML Namespaces
      2. 0.3.2. Part II: Validation
        1. 0.3.2.1. Chapter 4: Document Type Definitions
        2. 0.3.2.2. Chapter 5: XML Schemas
        3. 0.3.2.3. Chapter 6: RELAX NG
      3. 0.3.3. Part III: Processing
        1. 0.3.3.1. Chapter 7: XPath
        2. 0.3.3.2. Chapter 8: XSLT
      4. 0.3.4. Part IV: Databases
        1. 0.3.4.1. Chapter 9: XQuery, the XML Query Language
        2. 0.3.4.2. Chapter 10: XML and Databases
      5. 0.3.5. Part V: Programming
        1. 0.3.5.1. Chapter 11: The Document Object Model (DOM)
        2. 0.3.5.2. Chapter 12: Simple API for XML (SAX)
      6. 0.3.6. Part VI: Communication
        1. 0.3.6.1. Chapter 13: RSS, Atom, and Content Syndication
        2. 0.3.6.2. Chapter 14: Web Services
        3. 0.3.6.3. Chapter 15: SOAP and WSDL
        4. 0.3.6.4. Chapter 16: Ajax
      7. 0.3.7. Part VII: Display
        1. 0.3.7.1. Chapter 17: Cascading Style Sheets (CSS)
        2. 0.3.7.2. Chapter 18: XHTML
        3. 0.3.7.3. Chapter 19: Scalable Vector Graphics (SVG)
        4. 0.3.7.4. Chapter 20: XForms
      8. 0.3.8. Part VIII: Case Study
        1. 0.3.8.1. Chapter 21: Case Study: Payment Calculator
      9. 0.3.9. Appendixes
    4. 0.4. What You Need to Use This Book
      1. 0.4.1. Programming Languages
    5. 0.5. Conventions
      1. 0.5.1. How It Works
    6. 0.6. Source Code
    7. 0.7. Errata
    8. 0.8. p2p.wrox.com
  6. I. Introduction
    1. 1. What Is XML?
      1. 1.1. Of Data, Files, and Text
        1. 1.1.1. Binary Files
        2. 1.1.2. Text Files
        3. 1.1.3. A Brief History of Markup
      2. 1.2. So What Is XML?
        1. 1.2.1.
          1. 1.2.1.1. How It Works
        2. 1.2.2. What Does XML Buy Us?
          1. 1.2.2.1. XML Parsers
          2. 1.2.2.2. Why "Extensible?"
        3. 1.2.3. HTML and XML: Apples and Red Delicious Apples
        4. 1.2.4. Hierarchies of Information
          1. 1.2.4.1. Hierarchies in HTML
          2. 1.2.4.2. Hierarchies in XML
        5. 1.2.5. What's a Document Type?
        6. 1.2.6. No, Really—What's a Document Type?
      3. 1.3. Origin of the XML Standards
        1. 1.3.1. What Is the World Wide Web Consortium?
        2. 1.3.2. Components of XML
      4. 1.4. Where XML Can Be Used, and What You Can Use It For
        1. 1.4.1. Reducing Server Load
        2. 1.4.2. Website Content
        3. 1.4.3. Distributed Computing
        4. 1.4.4. e-Commerce
      5. 1.5. Summary
      6. 1.6. Exercise Questions
        1. 1.6.1. Question 1
        2. 1.6.2. Question 2
    2. 2. Well-Formed XML
      1. 2.1. Parsing XML
      2. 2.2. Tags and Text and Elements, Oh My!
        1. 2.2.1.
          1. 2.2.1.1. How It Works
        2. 2.2.2. Rules for Elements
          1. 2.2.2.1. Every Start-Tag Must Have an End-Tag
          2. 2.2.2.2. Elements Must Be Properly Nested
          3. 2.2.2.3. An XML Document Can Have Only One Root Element
          4. 2.2.2.4. Elements Must Obey XML Naming Conventions
          5. 2.2.2.5. Case Sensitivity
          6. 2.2.2.6. Whitespace in PCDATA
            1. 2.2.2.6.1. End-of-Line Whitespace
            2. 2.2.2.6.2. Whitespace in Markup
      3. 2.3. Attributes
        1. 2.3.1.
          1. 2.3.1.1. How It Works
        2. 2.3.2. When to Use Attributes
          1. 2.3.2.1. Using Attributes to Separate Different Types of Information
          2. 2.3.2.2. What Attributes Offer That Elements Don't
          3. 2.3.2.3. Why Use Elements If Attributes Use So Much Less Space?
          4. 2.3.2.4. Elements Can Be More Complex Than Attributes
          5. 2.3.2.5. Sometimes Elements Can Get in the Way
          6. 2.3.2.6. Attributes Are Unordered
          7. 2.3.2.7. Visual Preferences
      4. 2.4. Comments
        1. 2.4.1.
          1. 2.4.1.1. How It Works
      5. 2.5. Empty Elements
      6. 2.6. XML Declarations
        1. 2.6.1. Version
        2. 2.6.2. Encoding
          1. 2.6.2.1. Unicode
          2. 2.6.2.2. Specifying a Character Encoding for XML
        3. 2.6.3. Standalone
          1. 2.6.3.1. How It Works
      7. 2.7. Processing Instructions
        1. 2.7.1.
          1. 2.7.1.1. How It Works
      8. 2.8. Illegal PCDATA Characters
        1. 2.8.1. Escaping Characters
        2. 2.8.2. CDATA Sections
          1. 2.8.2.1. How It Works
      9. 2.9. Errors in XML
      10. 2.10. Summary
      11. 2.11. Exercise Questions
        1. 2.11.1. Question 1
        2. 2.11.2. Question 2
    3. 3. XML Namespaces
      1. 3.1. Why We Need Namespaces
        1. 3.1.1. Using Prefixes
        2. 3.1.2. Why Doesn't XML Just Use These Prefixes?
      2. 3.2. How XML Namespaces Work
        1. 3.2.1.
          1. 3.2.1.1. How It Works
        2. 3.2.2. Default Namespaces
          1. 3.2.2.1. How It Works
          2. 3.2.2.2. Declaring Namespaces on Descendants
          3. 3.2.2.3. How It Works
          4. 3.2.2.4. Canceling Default Namespaces
        3. 3.2.3. Do Different Notations Make Any Difference?
        4. 3.2.4. Namespaces and Attributes
          1. 3.2.4.1. How It Works
      3. 3.3. Understanding URIs
        1. 3.3.1. URLs
        2. 3.3.2. URNs
        3. 3.3.3. Why Use URLs for Namespaces, Not URNs?
        4. 3.3.4. What Do Namespace URIs Really Mean?
        5. 3.3.5. RDDL
      4. 3.4. When to Use Namespaces
      5. 3.5. Summary
      6. 3.6. Exercise Questions
        1. 3.6.1. Question 1
        2. 3.6.2. Question 2
        3. 3.6.3. Question 3
  7. II. Validation
    1. 4. Document Type Definitions
      1. 4.1. Running the Samples
        1. 4.1.1. Preparing the Ground
          1. 4.1.1.1. How It Works
        2. 4.1.2. The Document Type Declaration
          1. 4.1.2.1. System Identifiers
          2. 4.1.2.2. Public Identifiers
          3. 4.1.2.3. How It Works
      2. 4.2. Sharing Vocabularies
      3. 4.3. Anatomy of a DTD
        1. 4.3.1. Element Declarations
          1. 4.3.1.1. Element Content
            1. 4.3.1.1.1. Sequences
            2. 4.3.1.1.2. Choices
            3. 4.3.1.1.3. Combining Sequences and Choices Using Groups
          2. 4.3.1.2. Mixed Content
          3. 4.3.1.3. Empty Content
          4. 4.3.1.4. Any Content
          5. 4.3.1.5. How It Works
          6. 4.3.1.6. Cardinality
          7. 4.3.1.7. How It Works
        2. 4.3.2. Attribute Declarations
          1. 4.3.2.1. Attribute Names
          2. 4.3.2.2. Attribute Types
            1. 4.3.2.2.1. CDATA
            2. 4.3.2.2.2. ID, IDREF, and IDREFS
            3. 4.3.2.2.3. ENTITY and ENTITIES
            4. 4.3.2.2.4. NMTOKEN and NMTOKENS
            5. 4.3.2.2.5. Enumerated Attribute Types
          3. 4.3.2.3. Attribute Value Declarations
            1. 4.3.2.3.1. Default Values
            2. 4.3.2.3.2. Fixed Values
            3. 4.3.2.3.3. Required Values
            4. 4.3.2.3.4. Implied Values
          4. 4.3.2.4. Specifying Multiple Attributes
          5. 4.3.2.5. How It Works
        3. 4.3.3. Entities
          1. 4.3.3.1. Built-in Entities
            1. 4.3.3.1.1. References to Built-in Entities
          2. 4.3.3.2. Character Entities
            1. 4.3.3.2.1. References to Character Entities
          3. 4.3.3.3. General Entities
            1. 4.3.3.3.1. References to General Entities
          4. 4.3.3.4. How It Works
          5. 4.3.3.5. Parameter Entities
          6. 4.3.3.6. References to Parameter Entities
          7. 4.3.3.7. How It Works
      4. 4.4. Developing DTDs
      5. 4.5. DTD Limitations
        1. 4.5.1. DTD Syntax
        2. 4.5.2. XML Namespaces
        3. 4.5.3. Data Typing
        4. 4.5.4. Limited Content Model Descriptions
      6. 4.6. Summary
      7. 4.7. Exercise Questions
        1. 4.7.1. Question 1
        2. 4.7.2. Question 2
        3. 4.7.3. Question 3
    2. 5. XML Schemas
      1. 5.1. Benefits of XML Schemas
        1. 5.1.1. XML Schemas Use XML Syntax
        2. 5.1.2. XML Schema Namespace Support
        3. 5.1.3. XML Schema Data Types
        4. 5.1.4. XML Schema Content Models
      2. 5.2. Do We Still Need DTDs?
      3. 5.3. XML Schemas
        1. 5.3.1. The XML Schema Document
        2. 5.3.2. Running the Samples
          1. 5.3.2.1. How It Works
        3. 5.3.3. <schema> Declarations
          1. 5.3.3.1. The XML Schema Namespace
          2. 5.3.3.2. Target Namespaces
          3. 5.3.3.3. Element and Attribute Qualification
        4. 5.3.4. <element> Declarations
          1. 5.3.4.1. Global versus Local
          2. 5.3.4.2. Creating a Local Type
          3. 5.3.4.3. Using a Global Type
          4. 5.3.4.4. How It Works
          5. 5.3.4.5. Referring to an Existing Global Element
          6. 5.3.4.6. How It Works
          7. 5.3.4.7. Naming Elements
          8. 5.3.4.8. Element Qualified Form
          9. 5.3.4.9. Cardinality
          10. 5.3.4.10. Default and Fixed Values
          11. 5.3.4.11. Element Wildcards
        5. 5.3.5. <complexType> Declarations
        6. 5.3.6. <group> Declarations
          1. 5.3.6.1. How It Works
        7. 5.3.7. Content Models
          1. 5.3.7.1. <sequence> Declarations
          2. 5.3.7.2. <choice> Declarations
          3. 5.3.7.3. <group> References
          4. 5.3.7.4. <all> Declarations
          5. 5.3.7.5. How It Works
        8. 5.3.8. <attribute> Declarations
          1. 5.3.8.1. Creating a Local Type
          2. 5.3.8.2. Using a Global Type
          3. 5.3.8.3. Referring to an Existing Global Attribute
          4. 5.3.8.4. Naming Attributes
          5. 5.3.8.5. Attribute Qualified Form
          6. 5.3.8.6. Attribute Use
          7. 5.3.8.7. Default and Fixed Values
          8. 5.3.8.8. Attribute Wildcards
          9. 5.3.8.9. How It Works
        9. 5.3.9. <attributeGroup> Declarations
          1. 5.3.9.1. How It Works
        10. 5.3.10. Creating Elements with Simple Content and Attributes
        11. 5.3.11. Datatypes
          1. 5.3.11.1. Built-in Datatypes
          2. 5.3.11.2. How It Works
          3. 5.3.11.3. User-Defined Datatypes
        12. 5.3.12. <simpleType> Declarations
          1. 5.3.12.1. <restriction> Declarations
          2. 5.3.12.2. How It Works
          3. 5.3.12.3. <list> Declarations
          4. 5.3.12.4. <union> Declarations
          5. 5.3.12.5. How It Works
      4. 5.4. Creating a Schema from Multiple Documents
        1. 5.4.1. <import> Declarations
          1. 5.4.1.1. How It Works
        2. 5.4.2. <include> Declarations
          1. 5.4.2.1. How It Works
      5. 5.5. Documenting XML Schemas
        1. 5.5.1. Comments
        2. 5.5.2. Attributes from Other Namespaces
        3. 5.5.3. Annotations
      6. 5.6. Summary
      7. 5.7. Exercise Questions
        1. 5.7.1. Question 1
        2. 5.7.2. Question 2
        3. 5.7.3. Question 3
    3. 6. RELAX NG
      1. 6.1. XML and Compact Syntaxes
        1. 6.1.1. Running the Samples
      2. 6.2. RELAX NG Patterns
        1. 6.2.1. Element, Attribute, and Text Patterns
          1. 6.2.1.1. How It Works
          2. 6.2.1.2. Elements and Attributes
          3. 6.2.1.3. Cardinality
          4. 6.2.1.4. Connector Patterns and Grouping
            1. 6.2.1.4.1. Sequences and Choices
            2. 6.2.1.4.2. Interleave
          5. 6.2.1.5. Enumerated Values
          6. 6.2.1.6. Co-Occurrence Constraints
          7. 6.2.1.7. Mixed Content Pattern
          8. 6.2.1.8. The Empty Pattern
          9. 6.2.1.9. How It Works
      3. 6.3. Combining and Reusing Patterns and Grammars
        1. 6.3.1. Named Patterns
          1. 6.3.1.1. How It Works
        2. 6.3.2. Combining Named Pattern Definitions
        3. 6.3.3. Schema Modularization Using the include Directive
        4. 6.3.4. Redefining Included Named Patterns
        5. 6.3.5. Removing Patterns with the notAllowed Pattern
        6. 6.3.6. Extensions and Restrictions
        7. 6.3.7. Nested Grammars
      4. 6.4. Additional RELAX NG Features
        1. 6.4.1. Namespaces
        2. 6.4.2. Name-Classes
          1. 6.4.2.1. Basic Names (Including Namespaces)
          2. 6.4.2.2. Name-Class Choices and Groups
          3. 6.4.2.3. Namespaces with Wildcards
          4. 6.4.2.4. Using AnyName
        3. 6.4.3. Datatypes
        4. 6.4.4. List Patterns
        5. 6.4.5. Comments and Divisions
      5. 6.5. Useful Resources
      6. 6.6. Summary
      7. 6.7. Exercise Questions
        1. 6.7.1. Question 1
        2. 6.7.2. Question 2
  8. III. Processing
    1. 7. XPath
      1. 7.1. Ways of Looking at an XML Document
      2. 7.2. Modeling XML Documents
      3. 7.3. Visualizing XPath
        1. 7.3.1. Understanding Context
        2. 7.3.2. What Is a Node?
          1. 7.3.2.1.
            1. 7.3.2.1.1. Root Node
            2. 7.3.2.1.2. Element Node
            3. 7.3.2.1.3. Attribute Node
            4. 7.3.2.1.4. Text Node
            5. 7.3.2.1.5. Namespace Node
            6. 7.3.2.1.6. Comment Node
            7. 7.3.2.1.7. Processing Instruction Node
        3. 7.3.3. XPath 1.0 Types
          1. 7.3.3.1.
            1. 7.3.3.1.1. Booleans
            2. 7.3.3.1.2. Node-Sets
            3. 7.3.3.1.3. Numbers
            4. 7.3.3.1.4. Strings
      4. 7.4. Abbreviated and Unabbreviated Syntax
      5. 7.5. XPath 1.0 Axes
        1. 7.5.1. Child Axis
        2. 7.5.2. attribute Axis
          1. 7.5.2.1. How It Works
        3. 7.5.3. ancestor Axis
        4. 7.5.4. ancestor-or-self Axis
        5. 7.5.5. descendant Axis
        6. 7.5.6. descendant-or-self Axis
        7. 7.5.7. following Axis
        8. 7.5.8. following-sibling Axis
        9. 7.5.9. namespace Axis
        10. 7.5.10. parent Axis
        11. 7.5.11. preceding Axis
        12. 7.5.12. preceding-sibling Axis
        13. 7.5.13. self Axis
      6. 7.6. XPath 1.0 Functions
        1. 7.6.1. Boolean Functions
        2. 7.6.2. Node-Set Functions
        3. 7.6.3. Numeric Functions
        4. 7.6.4. String Functions
      7. 7.7. Predicates
      8. 7.8. Structure of XPath Expressions
      9. 7.9. XPath 2.0
        1. 7.9.1. Revised XPath Data Model
        2. 7.9.2. W3C XML Schema Data Types
        3. 7.9.3. Additional XPath 2.0 Functions
        4. 7.9.4. XPath 2.0 Features
          1. 7.9.4.1. Better String Handling
          2. 7.9.4.2. Better Date and Time Handling
          3. 7.9.4.3. Creating New Sequences
          4. 7.9.4.4. Conditional Logic
          5. 7.9.4.5. Ability to Call User-Defined Functions
          6. 7.9.4.6. More Node Tests
      10. 7.10. Summary
      11. 7.11. Exercise Questions
        1. 7.11.1. Question 1
        2. 7.11.2. Question 2
    2. 8. XSLT
      1. 8.1. What Is XSLT?
        1. 8.1.1. Restructuring XML
        2. 8.1.2. Presenting XML Content
      2. 8.2. How an XSLT Processor Works
      3. 8.3. Running the Examples
        1. 8.3.1. Introducing the Saxon XSLT Processor
        2. 8.3.2. Installing the Saxon XSLT Processor
          1. 8.3.2.1. Installing the Java Version
          2. 8.3.2.2. Installing the .NET Version
      4. 8.4. Procedural versus Declarative Programming
        1. 8.4.1. Procedural Programming
        2. 8.4.2. Declarative Programming
      5. 8.5. Foundational XSLT Elements
        1. 8.5.1. The <xsl:stylesheet> Element
        2. 8.5.2. The <xsl:template> Element
        3. 8.5.3. The <xsl:apply-templates> Element
      6. 8.6. Getting Information from the Source Tree
        1. 8.6.1. The <xsl:value-of> Element
        2. 8.6.2. The <xsl:copy> Element
          1. 8.6.2.1. How It Works
          2. 8.6.2.2. How It Works
        3. 8.6.3. The <xsl:copy-of> Element
      7. 8.7. Influencing the Output with the <xsl:output> Element
      8. 8.8. Conditional Processing
        1. 8.8.1. The <xsl:if> Element
        2. 8.8.2. The <xsl:choose> Element
      9. 8.9. The <xsl:for-each> Element
      10. 8.10. The <xsl:sort> Element
      11. 8.11. XSLT Modes
      12. 8.12. XSLT Variables and Parameters
      13. 8.13. Named Templates and the <xsl:call-template> Element
      14. 8.14. XSLT Functions
      15. 8.15. XSLT 2.0
        1. 8.15.1. Grouping in Version 2.0
        2. 8.15.2. Non-XML Input and String Handling
          1. 8.15.2.1. How It Works
        3. 8.15.3. Multiple Outputs
        4. 8.15.4. User-Defined Functions
        5. 8.15.5. xsl:value-of changes
      16. 8.16. Summary
      17. 8.17. Exercise Questions
        1. 8.17.1. Question 1
        2. 8.17.2. Question 2
  9. IV. Databases
    1. 9. XQuery, the XML Query Language
      1. 9.1. Why XQuery?
        1. 9.1.1. Historical Factors
        2. 9.1.2. Technical Factors
        3. 9.1.3. Current Status
          1. 9.1.3.1. Developing XQuery, XSLT 2.0, and XPath 2.0
          2. 9.1.3.2. Using XSLT and XQuery
          3. 9.1.3.3. Comparing XSLT, XPath, and XQuery
      2. 9.2. XQuery Tools
        1. 9.2.1. Saxon
        2. 9.2.2. X-Hive.com Online
        3. 9.2.3. X-Hive Database
        4. 9.2.4. Tamino Database
        5. 9.2.5. Microsoft SQL Server 2005
        6. 9.2.6. Oracle
      3. 9.3. Some XQuery Examples
        1. 9.3.1. Input Functions
          1. 9.3.1.1. The doc() Function
          2. 9.3.1.2. The collection() Function
        2. 9.3.2. Retrieving Nodes
          1. 9.3.2.1. How It Works
        3. 9.3.3. Element Constructors
        4. 9.3.4. The XQuery Prolog
          1. 9.3.4.1. The XQuery Version Declaration
          2. 9.3.4.2. XQuery Modules
          3. 9.3.4.3. XQuery Prolog Continued
            1. 9.3.4.3.1. The base-uri Declaration
            2. 9.3.4.3.2. The namespace Declaration
            3. 9.3.4.3.3. Default namespace Declarations
            4. 9.3.4.3.4. Schema Imports
            5. 9.3.4.3.5. Variable Declarations
            6. 9.3.4.3.6. Validation Declaration
            7. 9.3.4.3.7. The boundary-space Declaration
        5. 9.3.5. Computed Constructors
        6. 9.3.6. Syntax
          1. 9.3.6.1. XQuery Comments
          2. 9.3.6.2. Delimiting Strings
      4. 9.4. The XQuery Data Model
        1. 9.4.1. Shared Data Model with XPath 2.0 and XSLT 2.0
        2. 9.4.2. Node Kinds
        3. 9.4.3. Sequences of Node-Sets
        4. 9.4.4. Document Order
        5. 9.4.5. Comparing Items and Nodes
        6. 9.4.6. Types in XQuery
        7. 9.4.7. Axes in XQuery
      5. 9.5. XQuery Expressions
        1. 9.5.1. FLWOR Expressions
          1. 9.5.1.1. for Expressions
          2. 9.5.1.2. Filtering with the where Clause
          3. 9.5.1.3. Sorting Using the order by Clause
          4. 9.5.1.4. Conditional Expressions
          5. 9.5.1.5. How It Works
      6. 9.6. XQuery Functions
        1. 9.6.1. The concat() Function
        2. 9.6.2. The count() Function
      7. 9.7. Using Parameters with XQuery
      8. 9.8. User-Defined Functions
      9. 9.9. Looking Ahead
        1. 9.9.1. Update Functionality
        2. 9.9.2. Full-Text Search
      10. 9.10. Summary
      11. 9.11. Exercise Questions
        1. 9.11.1. Question 1
        2. 9.11.2. Question 2
    2. 10. XML and Databases
      1. 10.1. The Need for Efficient XML Data Stores
        1. 10.1.1. The Increasing Amount of XML
        2. 10.1.2. Comparing XML-Based Data and Relational Data
      2. 10.2. Approaches to Storing XML
        1. 10.2.1. Storing XML on File Systems
          1. 10.2.1.1. Document Size
          2. 10.2.1.2. Updates
          3. 10.2.1.3. Indexes
          4. 10.2.1.4. Building Your Own
        2. 10.2.2. Using XML With Conventional Databases
          1. 10.2.2.1. Producing XML from Relational Databases
          2. 10.2.2.2. Moving XML to Relational Databases
          3. 10.2.2.3. Data Binding
        3. 10.2.3. Native XML Databases
      3. 10.3. Using Native XML Databases
        1. 10.3.1. Obtaining and Installing eXist
        2. 10.3.2. Interacting with eXist
          1. 10.3.2.1. Using the Web Interface
          2. 10.3.2.2. Using the eXist Client
          3. 10.3.2.3. Using WebDAV
          4. 10.3.2.4. Using an XML IDE
          5. 10.3.2.5. Using the REST Interface
          6. 10.3.2.6. Other Interfaces
          7. 10.3.2.7. Choosing an Interface
      4. 10.4. XML in Commercial RDBMSs
        1. 10.4.1. XML Functionality in SQL Server 2000
          1. 10.4.1.1. Returning Data as XML Using FOR XML
            1. 10.4.1.1.1. Using FOR XML RAW
            2. 10.4.1.1.2. Using FOR XML AUTO
          2. 10.4.1.2. How It Works
            1. 10.4.1.2.1. Using FOR XML EXPLICIT
            2. 10.4.1.2.2. Using FOR XML PATH
            3. 10.4.1.2.3. Using OPENXML
            4. 10.4.1.2.4. The xml Datatype
          3. 10.4.1.3. How It Works
            1. 10.4.1.3.1. XQuery in SQL Server 2005
            2. 10.4.1.3.2. Extensions to XQuery in SQL Server 2005
          4. 10.4.1.4. How It Works
          5. 10.4.1.5. How It Works
            1. 10.4.1.5.1. How It Works
            2. 10.4.1.5.2. The query() Method
            3. 10.4.1.5.3. W3C XML Schema in SQL Server 2005
        2. 10.4.2. Web Service Support
      5. 10.5. XML in Open Source RDBMS
        1. 10.5.1. Installing MySQL
        2. 10.5.2. Adding Information in MySQL
          1. 10.5.2.1. How It Works
        3. 10.5.3. Querying MySQL
          1. 10.5.3.1. How It Works
        4. 10.5.4. Updating XML in MySQL
        5. 10.5.5. Usability of XML in MySQL
        6. 10.5.6. Client-Side XML Support
      6. 10.6. Choosing a Database to Store XML
      7. 10.7. Looking Ahead
      8. 10.8. Summary
      9. 10.9. Exercise Questions
        1. 10.9.1. Question 1
        2. 10.9.2. Question 2
        3. 10.9.3. Question 3
  10. V. Programming
    1. 11. The XML Document Object Model (DOM)
      1. 11.1. Purpose of the XML DOM
        1. 11.1.1. Interfaces and Objects
      2. 11.2. The Document Object Model at the W3C
        1. 11.2.1. XML DOM Implementations
      3. 11.3. Two Ways to View DOM Nodes
        1. 11.3.1. Overview of the XML DOM
      4. 11.4. Tools to Run the Examples
        1. 11.4.1. Browser Differences
          1. 11.4.1.1. How It Works
      5. 11.5. The Node Object
        1. 11.5.1. Properties of the Node Object
          1. 11.5.1.1. How It Works
        2. 11.5.2. Methods of the Node Object
        3. 11.5.3. Loading an XML Document
          1. 11.5.3.1. How It Works
          2. 11.5.3.2. How It Works
        4. 11.5.4. The Effect of Text Nodes
        5. 11.5.5. The NamedNodeMap Object
          1. 11.5.5.1. How It Works
        6. 11.5.6. The NodeList Object
        7. 11.5.7. The DOMException Object
          1. 11.5.7.1. How It Works
      6. 11.6. The Document Interface
      7. 11.7. How the XML DOM Is Used in InfoPath 2007
      8. 11.8. Summary
      9. 11.9. Exercise Questions
        1. 11.9.1. Question 1
        2. 11.9.2. Question 2
    2. 12. Simple API for XML (SAX)
      1. 12.1. What Is SAX and Why Was It Invented?
        1. 12.1.1. A Brief History of SAX
        2. 12.1.2. Where to Get SAX
        3. 12.1.3. Setting Up SAX
      2. 12.2. Receiving SAX Events
        1. 12.2.1. ContentHandler Interface
          1. 12.2.1.1. How It Works
          2. 12.2.1.2. Handling Element Events
          3. 12.2.1.3. How It Works
          4. 12.2.1.4. Handling Character Content
          5. 12.2.1.5. How It Works
            1. 12.2.1.5.1. When to Ignore ignorableWhitespace
            2. 12.2.1.5.2. Skipped Entities
          6. 12.2.1.6. Handling Special Commands with Processing Instructions
          7. 12.2.1.7. Namespace Prefixes
          8. 12.2.1.8. Stopping the Process in Exceptional Circumstances
          9. 12.2.1.9. How It Works
          10. 12.2.1.10. Providing the Location of the Error
          11. 12.2.1.11. How It Works
        2. 12.2.2. ErrorHandler Interface
          1. 12.2.2.1. How It Works
        3. 12.2.3. DTDHandler Interface
        4. 12.2.4. EntityResolver Interface
        5. 12.2.5. Features and Properties
          1. 12.2.5.1. Working with Features
          2. 12.2.5.2. Working with Properties
        6. 12.2.6. Extension Interfaces
      3. 12.3. Good SAX and Bad SAX
      4. 12.4. Consumers, Producers, and Filters
      5. 12.5. Other Languages
      6. 12.6. Summary
      7. 12.7. Exercise Questions
        1. 12.7.1. Question 1
        2. 12.7.2. Question 2
  11. VI. Communication
    1. 13. RSS, Atom, and Content Syndication
      1. 13.1. Syndication and Meta Data
        1. 13.1.1. Syndication Systems
          1. 13.1.1.1. Server-Producer
          2. 13.1.1.2. Client-Consumer
          3. 13.1.1.3. Client-Producer
          4. 13.1.1.4. Server-Consumer
        2. 13.1.2. The Origin of RSS Species
          1. 13.1.2.1. Microsoft's Content Definition Format
          2. 13.1.2.2. UserLand and Scripting News
          3. 13.1.2.3. Netscape and RSS 0.9
          4. 13.1.2.4. Simply RDF
          5. 13.1.2.5. Netscape, UserLand, and RSS 0.9x
        3. 13.1.3. RSS-DEV and RSS 1.0
        4. 13.1.4. UserLand and RSS 2.0
        5. 13.1.5. Atom
      2. 13.2. Working with News Feeds
        1. 13.2.1. Newsreaders
        2. 13.2.2. Data Quality
      3. 13.3. A Simple Aggregator
        1. 13.3.1. Modeling Feeds
          1. 13.3.1.1. Syntax Isn't Model
          2. 13.3.1.2. SAX to the Rescue!
        2. 13.3.2. Program Flow
        3. 13.3.3. Implementation
          1. 13.3.3.1. Address List Reader: ListReader
          2. 13.3.3.2. How It Works
          3. 13.3.3.3. Application Controller: FeedReader
          4. 13.3.3.4. Model: Feed and Item
          5. 13.3.3.5. XML Markup Handler: FeedHandler
          6. 13.3.3.6. Handler Helpers
          7. 13.3.3.7. How It Works
          8. 13.3.3.8. Extending the Aggregator
          9. 13.3.3.9. How It Works
        4. 13.3.4. Transforming RSS with XSLT
          1. 13.3.4.1. Generating a Feed from Existing Data
          2. 13.3.4.2. How It Works
          3. 13.3.4.3. Processing Feed Data for Display
          4. 13.3.4.4. How It Works
          5. 13.3.4.5. Browser Processing
          6. 13.3.4.6. Pre-processing Feed Data
          7. 13.3.4.7. Reviewing the Different Formats
      4. 13.4. Useful Resources
      5. 13.5. Summary
      6. 13.6. Exercise Questions
        1. 13.6.1. Question 1
        2. 13.6.2. Question 2
    2. 14. Web Services
      1. 14.1. What Is an RPC?
      2. 14.2. RPC Protocols
        1. 14.2.1. DCOM
        2. 14.2.2. IIOP
        3. 14.2.3. Java RMI
      3. 14.3. The New RPC Protocol: Web Services
        1. 14.3.1. XML-RPC
          1. 14.3.1.1. The Target API
          2. 14.3.1.2. A Simple Request
          3. 14.3.1.3. Passing Parameters
          4. 14.3.1.4. Using a struct
        2. 14.3.2. The Network Transport
          1. 14.3.2.1. HTTP
          2. 14.3.2.2. Why HTTP for Web Services?
          3. 14.3.2.3. Widely Implemented
          4. 14.3.2.4. Request/Response
          5. 14.3.2.5. Firewall-Ready
          6. 14.3.2.6. Security
          7. 14.3.2.7. Using HTTP for XML-RPC
          8. 14.3.2.8. How It Works
          9. 14.3.2.9. Posting with Firefox and Netscape
          10. 14.3.2.10. How It Works
      4. 14.4. Taking a REST
        1. 14.4.1.
          1. 14.4.1.1. How It Works
      5. 14.5. The Web Services Stack
        1. 14.5.1. SOAP
        2. 14.5.2. WSDL
        3. 14.5.3. UDDI
        4. 14.5.4. Surrounding Specifications
          1. 14.5.4.1. Interoperability
          2. 14.5.4.2. Coordination
          3. 14.5.4.3. Security
      6. 14.6. Summary
      7. 14.7. Exercise Questions
        1. 14.7.1. Question 1
        2. 14.7.2. Question 2
    3. 15. SOAP and WSDL
      1. 15.1. Laying the Groundwork
      2. 15.2. Running Examples in Windows 2003, XP, and 2000
      3. 15.3. The New RPC Protocol: SOAP
        1. 15.3.1.
          1. 15.3.1.1. How It Works
        2. 15.3.2. Just RESTing
        3. 15.3.3. Basic SOAP Messages
          1. 15.3.3.1. <Envelope>
          2. 15.3.3.2. <Body>
          3. 15.3.3.3. Encoding Style
          4. 15.3.3.4. How It Works
        4. 15.3.4. More Complex SOAP Interactions
          1. 15.3.4.1. <Header>
            1. 15.3.4.1.1. The mustUnderstand Attribute
            2. 15.3.4.1.2. The role Attribute
            3. 15.3.4.1.3. The relay Attribute
          2. 15.3.4.2. <Fault>
          3. 15.3.4.3. How It Works
      4. 15.4. Defining Web Services: WSDL
        1. 15.4.1. <definitions>
        2. 15.4.2. <types>
        3. 15.4.3. <messages>
        4. 15.4.4. <portTypes>
        5. 15.4.5. <binding>
          1. 15.4.5.1. <soap:binding>
          2. 15.4.5.2. <soap:operation>
        6. 15.4.6. <soap:body>
        7. 15.4.7. <service>
          1. 15.4.7.1. How It Works
        8. 15.4.8. Other Bindings
      5. 15.5. Summary
      6. 15.6. Exercise Questions
        1. 15.6.1. Question 1
        2. 15.6.2. Question 2
    4. 16. Ajax
      1. 16.1. Early Attempts at Asynchronous Updates
        1. 16.1.1. Microsoft versus Mozilla
        2. 16.1.2. Cross-Browser Solutions
      2. 16.2. Basic Posting Techniques
        1. 16.2.1.
          1. 16.2.1.1. How It Works
      3. 16.3. Transport and Processing on the Server
        1. 16.3.1. JSON
        2. 16.3.2. Payment Card Validator
          1. 16.3.2.1. How It Works
        3. 16.3.3. The AutoSuggest Box
          1. 16.3.3.1. Class Design
            1. 16.3.3.1.1. Showing a Suggestion
            2. 16.3.3.1.2. Implementing the suggest Method
            3. 16.3.3.1.3. Handling Input and Control Keys
            4. 16.3.3.1.4. Creating the Suggestions List
            5. 16.3.3.1.5. Handling Mouse Actions
            6. 16.3.3.1.6. Adding the Suggestions
            7. 16.3.3.1.7. Handling Keyboard Selection
            8. 16.3.3.1.8. Coping with Speed Typists
            9. 16.3.3.1.9. Implementing the SuggestionProvider
            10. 16.3.3.1.10. Implementing the Web Service
          2. 16.3.3.2. How It Works
      4. 16.4. Server-Side Proxies
        1. 16.4.1. The Currency Converter Proxy
          1. 16.4.1.1. Creating the Web Service
          2. 16.4.1.2. Implementing the GetRate() Method
          3. 16.4.1.3. Creating the Client
      5. 16.5. Summary
      6. 16.6. Exercise Questions
        1. 16.6.1. Question 1
        2. 16.6.2. Question 2
        3. 16.6.3. Question 3
  12. VII. Display
    1. 17. Cascading Style Sheets (CSS)
      1. 17.1. Why Stylesheets?
      2. 17.2. Introducing CSS
        1. 17.2.1. CSS Properties
        2. 17.2.2. Inheritance
          1. 17.2.2.1. How It Works
        3. 17.2.3. Attaching the Stylesheet to an XML Document
        4. 17.2.4. Selectors
      3. 17.3. Using CSS for Layout of XML Documents
        1. 17.3.1. Understanding the Box Model
          1. 17.3.1.1. Block and Inline Boxes
          2. 17.3.1.2. How It Works
          3. 17.3.1.3. Anonymous Boxes
        2. 17.3.2. Positioning in CSS
          1. 17.3.2.1. Normal Flow
          2. 17.3.2.2. How It Works
            1. 17.3.2.2.1. Vertical Margins Collapse in Normal Flow
            2. 17.3.2.2.2. Relative Positioning
            3. 17.3.2.2.3. Overlapping Relative Positioning
          3. 17.3.2.3. Float Positioning
          4. 17.3.2.4. How It Works
            1. 17.3.2.4.1. Overlapping Floated Boxes
            2. 17.3.2.4.2. Using the Clear Property to Prevent an Overlap
          5. 17.3.2.5. Absolute Positioning
          6. 17.3.2.6. How It Works
            1. 17.3.2.6.1. Fixed Positioning
          7. 17.3.2.7. How It Works
            1. 17.3.2.7.1. Overlapping Absolutely Positioned Elements and Z-Index
      4. 17.4. Laying Out Tabular Data
        1. 17.4.1.
          1. 17.4.1.1. How It Works
      5. 17.5. Links in XML Documents
        1. 17.5.1. XLink Support in Firefox
          1. 17.5.1.1. How It Works
        2. 17.5.2. Forcing Links Using the XHTML Namespace
      6. 17.6. Images in XML Documents
      7. 17.7. Using CSS to Add Content to Documents
        1. 17.7.1.
          1. 17.7.1.1. How It Works
      8. 17.8. Attribute Content
        1. 17.8.1. Attribute Selectors
        2. 17.8.2. Using Attribute Values in Documents
          1. 17.8.2.1. How It Works
      9. 17.9. Summary
      10. 17.10. Exercise Questions
        1. 17.10.1. Question 1
        2. 17.10.2. Question 2
        3. 17.10.3. Question 3
        4. 17.10.4. Question 4
    2. 18. XHTML
      1. 18.1. Separating Style from Content
      2. 18.2. Learning XHTML 1.x
        1. 18.2.1. Document Type Definitions for XHTML
        2. 18.2.2. Basic Changes in Writing XHTML
          1. 18.2.2.1. XML Declaration
          2. 18.2.2.2. DOCTYPE Declaration
          3. 18.2.2.3. Case Sensitivity
          4. 18.2.2.4. Attribute Values
          5. 18.2.2.5. Well-Formedness and Validity of Documents
            1. 18.2.2.5.1. Unique Root HTML Element
            2. 18.2.2.5.2. Empty Elements
            3. 18.2.2.5.3. Correctly Nesting Elements
          6. 18.2.2.6. Names and IDs
          7. 18.2.2.7. Specifying Language
          8. 18.2.2.8. Character Encoding
            1. 18.2.2.8.1. How to Specify Character Encoding in XHTML
            2. 18.2.2.8.2. Server-Side Content Types
          9. 18.2.2.9. Summary of Changes Between Writing XHTML and HTML
          10. 18.2.2.10. How It Works
        3. 18.2.3. Styling XHTML Documents
          1. 18.2.3.1. How It Works
        4. 18.2.4. Stricter Documents Make Faster and Lighter Processors
        5. 18.2.5. XHTML Tools
        6. 18.2.6. Validating XHTML Documents
        7. 18.2.7. Validation Pitfalls
          1. 18.2.7.1. Including JavaScript in Your Page
          2. 18.2.7.2. Incorporating Content from Other People
        8. 18.2.8. Mime Types Pitfalls
      3. 18.3. Modularized XHTML
        1. 18.3.1. Module Implementations
        2. 18.3.2. XHTML 1.1
        3. 18.3.3. XHTML Basic
      4. 18.4. What's Next for XHTML
      5. 18.5. Summary
      6. 18.6. Exercise Questions
        1. 18.6.1. Question 1
        2. 18.6.2. Question 2
    3. 19. Scalable Vector Graphics (SVG)
      1. 19.1. What Is SVG?
        1. 19.1.1. Scalable, Vector, Graphics
        2. 19.1.2. Putting SVG to Work
          1. 19.1.2.1. Static Graphics
          2. 19.1.2.2. Self-Contained Applications
          3. 19.1.2.3. Server-Based Applications
        3. 19.1.3. An SVG Toolkit
          1. 19.1.3.1. Viewers
          2. 19.1.3.2. Editors
          3. 19.1.3.3. Programming Tools
      2. 19.2. Getting Started
        1. 19.2.1.
          1. 19.2.1.1. How It Works
        2. 19.2.2. Views and Units
        3. 19.2.3. The Painter's Model
          1. 19.2.3.1. How It Works
        4. 19.2.4. Grouping
        5. 19.2.5. Transformations
        6. 19.2.6. Paths
        7. 19.2.7. Images
        8. 19.2.8. Text
        9. 19.2.9. Comments, Annotation, and Metadata
        10. 19.2.10. Scripting
        11. 19.2.11. SVG on Your Website
      3. 19.3. Tangram: A Simple Application
        1. 19.3.1. XHTML Wrapper
        2. 19.3.2. SVG Shapes
          1. 19.3.2.1. How It Works
          2. 19.3.2.2. How It Works
        3. 19.3.3. Tangram Script
          1. 19.3.3.1. How It Works
          2. 19.3.3.2. Further Applications
      4. 19.4. Useful Resources
      5. 19.5. Summary
      6. 19.6. Exercise Questions
        1. 19.6.1. Question 1
        2. 19.6.2. Question 2
    4. 20. XForms
      1. 20.1. How XForms Improves on HTML Forms
      2. 20.2. XForms Tools
      3. 20.3. An Illustrative XForms Example
        1. 20.3.1.
          1. 20.3.1.1. How It Works
            1. 20.3.1.1.1. The XForms Model
            2. 20.3.1.1.2. The xforms:instance Element
            3. 20.3.1.1.3. The xforms:submission Element
            4. 20.3.1.1.4. The xforms:bind Element
            5. 20.3.1.1.5. XPath 1.0 in XForms
            6. 20.3.1.1.6. XML Namespaces in XForms Documents
      4. 20.4. XForms Form Controls
        1. 20.4.1. The xforms:input Element
        2. 20.4.2. The xforms:secret Element
        3. 20.4.3. The xforms:textarea Element
        4. 20.4.4. The xforms:output Element
        5. 20.4.5. The xforms:upload Element
        6. 20.4.6. The xforms:range Element
        7. 20.4.7. The xforms:trigger Element
        8. 20.4.8. The xforms:submit Element
        9. 20.4.9. The xforms:select Element
        10. 20.4.10. The xforms:select1 Element
          1. 20.4.10.1. How It Works.
      5. 20.5. Constraining XForms Instances
        1. 20.5.1. The xforms:bind Element
          1. 20.5.1.1. How It Works
        2. 20.5.2. W3C XML Schema in XForms
        3. 20.5.3. Schema or Bind Elements: Which One to Choose?
      6. 20.6. XForms Events
      7. 20.7. The XForms Action Module
        1. 20.7.1. Developing and Debugging XForms
      8. 20.8. Alternatives to XForms
        1. 20.8.1. Microsoft InfoPath
        2. 20.8.2. Adobe LiveCycle
        3. 20.8.3. HTML Forms
      9. 20.9. Summary
      10. 20.10. Exercise Questions
        1. 20.10.1. Question 1
        2. 20.10.2. Question 2
  13. VIII. Case Study
    1. 21. Case Study: Payment Calculator
      1. 21.1. Mortgage Calculations
      2. 21.2. What You'll Need
      3. 21.3. Online Loan Calculator
        1. 21.3.1.
          1. 21.3.1.1. How It Works
          2. 21.3.1.2. How It Works
        2. 21.3.2. Integrating the Calculation Web Service
          1. 21.3.2.1. Building a Proxy Web Service
          2. 21.3.2.2. How It Works
          3. 21.3.2.3. Modifying the Request and Response
          4. 21.3.2.4. How It Works
          5. 21.3.2.5. Communicating with the Proxy Web Service Using Ajax
          6. 21.3.2.6. How It Works
        3. 21.3.3. Enhancing the Display with SVG
          1. 21.3.3.1. How It Works
        4. 21.3.4. Adding the Frame to the Main Page
          1. 21.3.4.1. How It Works
      4. 21.4. Summary
    2. 22. Case Study: Payment Calculator — Ruby on Rails
      1. 22.1. Mortgage Calculations
      2. 22.2. What You Need for the Example
      3. 22.3. Creating the Project
      4. 22.4. Building the Online Loan Calculator
        1. 22.4.1.
          1. 22.4.1.1. Developing the Main Web Page
          2. 22.4.1.2. How It Works
          3. 22.4.1.3. How It Works
          4. 22.4.1.4. Integrating the Calculation Web Service
          5. 22.4.1.5. How It Works
          6. 22.4.1.6. How It Works
          7. 22.4.1.7. Adding Ajax Support
          8. 22.4.1.8. How It Works
          9. 22.4.1.9. How It Works
          10. 22.4.1.10. Enhancing the Display with SVG
          11. 22.4.1.11. How It Works
          12. 22.4.1.12. How It Works
      5. 22.5. Summary
  14. A. Exercise Solutions
    1. A.1. Chapter 1
      1. A.1.1.
        1. A.1.1.1. Question 1
        2. A.1.1.2. Solution
        3. A.1.1.3. Question 2
        4. A.1.1.4. Solution
    2. A.2. Chapter 2
      1. A.2.1.
        1. A.2.1.1. Question 1
        2. A.2.1.2. Solution
        3. A.2.1.3. Question 2
        4. A.2.1.4. Solution
    3. A.3. Chapter 3
      1. A.3.1.
        1. A.3.1.1. Question 1
        2. A.3.1.2. Solution
        3. A.3.1.3. Question 2
        4. A.3.1.4. Solution
        5. A.3.1.5. Question 3
        6. A.3.1.6. Solution
    4. A.4. Chapter 4
      1. A.4.1.
        1. A.4.1.1. Question 1
        2. A.4.1.2. Solution
        3. A.4.1.3. Question 2
        4. A.4.1.4. Solution
        5. A.4.1.5. Question 3
        6. A.4.1.6. Solution
    5. A.5. Chapter 5
      1. A.5.1.
        1. A.5.1.1. Question 1
        2. A.5.1.2. Solution
        3. A.5.1.3. Question 2
        4. A.5.1.4. Solution
        5. A.5.1.5. Question 3
        6. A.5.1.6. Solution
    6. A.6. Chapter 6
      1. A.6.1.
        1. A.6.1.1. Question 1
        2. A.6.1.2. Solution 1
        3. A.6.1.3. Question 2
        4. A.6.1.4. Solution 2
    7. A.7. Chapter 7
      1. A.7.1.
        1. A.7.1.1. Question 1
        2. A.7.1.2. Solution
        3. A.7.1.3. Question 2
        4. A.7.1.4. Solution
    8. A.8. Chapter 8
      1. A.8.1.
        1. A.8.1.1. Question 1
        2. A.8.1.2. Solution
        3. A.8.1.3. Question 2
        4. A.8.1.4. Solution
    9. A.9. Chapter 9
      1. A.9.1.
        1. A.9.1.1. Question 1
        2. A.9.1.2. Solution
        3. A.9.1.3. Question 2
        4. A.9.1.4. Solution
    10. A.10. Chapter 10
      1. A.10.1.
        1. A.10.1.1. Question 1
        2. A.10.1.2. Solution
        3. A.10.1.3. Question 2
        4. A.10.1.4. Solution
        5. A.10.1.5. Question 3
        6. A.10.1.6. Solution
    11. A.11. Chapter 11
      1. A.11.1.
        1. A.11.1.1. Question 1
        2. A.11.1.2. Solution
        3. A.11.1.3. Question 2
        4. A.11.1.4. Solution
    12. A.12. Chapter 12
      1. A.12.1.
        1. A.12.1.1. Question 1
        2. A.12.1.2. Solution
        3. A.12.1.3. Question 2
        4. A.12.1.4. Solution
    13. A.13. Chapter 13
      1. A.13.1.
        1. A.13.1.1. Question 1
        2. A.13.1.2. Solution
        3. A.13.1.3. Question 2
        4. A.13.1.4. Solution
    14. A.14. Chapter 14
      1. A.14.1.
        1. A.14.1.1. Question 1
        2. A.14.1.2. Solution
        3. A.14.1.3. Question 2
        4. A.14.1.4. Solution
    15. A.15. Chapter 15
      1. A.15.1.
        1. A.15.1.1. Question 1
        2. A.15.1.2. Solution
        3. A.15.1.3. Question 2
        4. A.15.1.4. Solution
    16. A.16. Chapter 16
      1. A.16.1.
        1. A.16.1.1. Question 1
        2. A.16.1.2. Solution
        3. A.16.1.3. Question 2
        4. A.16.1.4. Solution
        5. A.16.1.5. Question 3
        6. A.16.1.6. Solution
    17. A.17. Chapter 17
      1. A.17.1.
        1. A.17.1.1. Question 1
        2. A.17.1.2. Solution
        3. A.17.1.3. Question 2
        4. A.17.1.4. Solution
        5. A.17.1.5. Question 3
        6. A.17.1.6. Solution
        7. A.17.1.7. Question 4
        8. A.17.1.8. Solution
    18. A.18. Chapter 18
      1. A.18.1.
        1. A.18.1.1. Question 1
        2. A.18.1.2. Solution
        3. A.18.1.3. Question 2
        4. A.18.1.4. Solution
    19. A.19. Chapter 19
      1. A.19.1.
        1. A.19.1.1. Question 1
        2. A.19.1.2. Solution
        3. A.19.1.3. Question 2
        4. A.19.1.4. Solution
    20. A.20. Chapter 20
      1. A.20.1.
        1. A.20.1.1. Question 1
        2. A.20.1.2. Solution
        3. A.20.1.3. Question 2
        4. A.20.1.4. Solution
  15. B. XPath Reference
    1. B.1. XPath 2.0 Is Emerging Slowly
      1. B.1.1.
        1. B.1.1.1. The New Sequencing
        2. B.1.1.2. Datatyping Control
    2. B.2. Axes
      1. B.2.1.
        1. B.2.1.1. ancestor
        2. B.2.1.2. ancestor-or-self
        3. B.2.1.3. attribute
        4. B.2.1.4. child
        5. B.2.1.5. descendant
        6. B.2.1.6. descendant-or-self
        7. B.2.1.7. following
        8. B.2.1.8. following-sibling
        9. B.2.1.9. namespace
        10. B.2.1.10. parent
        11. B.2.1.11. preceding
        12. B.2.1.12. preceding-sibling
        13. B.2.1.13. self
    3. B.3. Node Tests
      1. B.3.1.
        1. B.3.1.1. Examples using the meta character *:
        2. B.3.1.2. comment( )
        3. B.3.1.3. node( )
        4. B.3.1.4. processing-instruction( Literal )
        5. B.3.1.5. text( )
    4. B.4. Functions
      1. B.4.1.
        1. B.4.1.1. XPath 2.0 Functions
  16. C. XSLT Reference
    1. C.1. Elements
      1. C.1.1.
        1. C.1.1.1. xsl:apply-imports
        2. C.1.1.2. xsl:apply-templates
        3. C.1.1.3. xsl:attribute
        4. C.1.1.4. xsl:attribute-set
        5. C.1.1.5. xsl:call-template
        6. C.1.1.6. xsl:choose
        7. C.1.1.7. xsl:comment
        8. C.1.1.8. xsl:copy
        9. C.1.1.9. xsl:copy-of
        10. C.1.1.10. xsl:decimal-format
        11. C.1.1.11. xsl:element
        12. C.1.1.12. xsl:fallback
        13. C.1.1.13. xsl:for-each
        14. C.1.1.14. xsl:if
        15. C.1.1.15. xsl:import
        16. C.1.1.16. xsl:include
        17. C.1.1.17. xsl:key
        18. C.1.1.18. xsl:message
        19. C.1.1.19. xsl:namespace-alias
        20. C.1.1.20. xsl:number
        21. C.1.1.21. xsl:otherwise
        22. C.1.1.22. xsl:output
        23. C.1.1.23. xsl:param
        24. C.1.1.24. xsl:preserve-space
        25. C.1.1.25. xsl:processing-instruction
        26. C.1.1.26. xsl:sort
        27. C.1.1.27. xsl:strip-space
        28. C.1.1.28. xsl:stylesheet
        29. C.1.1.29. xsl:template
        30. C.1.1.30. xsl:text
        31. C.1.1.31. xsl:transform
        32. C.1.1.32. xsl:value-of
        33. C.1.1.33. xsl:variable
        34. C.1.1.34. xsl:when
        35. C.1.1.35. xsl:with-param
    2. C.2. Functions
      1. C.2.1.
        1. C.2.1.1. Available XPath Functions
        2. C.2.1.2. Types
    3. C.3. New in XSLT 2.0
      1. C.3.1.
        1. C.3.1.1. More Powerful Expressions
        2. C.3.1.2. Muenchian's Everywhere
    4. C.4. Planning on Using XSLT 2.0
      1. C.4.1.
        1. C.4.1.1. New Functions
    5. C.5. A Quick Note on XSLT 2.0 and XQuery 1.0
  17. D. The XML Document Object Model
    1. D.1. Notation
    2. D.2. Basic Datatypes
      1. D.2.1.
        1. D.2.1.1. Strings
        2. D.2.1.2. User Data
        3. D.2.1.3. Objects
    3. D.3. Fundamental Interfaces: Core Module
      1. D.3.1.
        1. D.3.1.1. DOMException
        2. D.3.1.2. DOMError
        3. D.3.1.3. DOMErrorHandler
        4. D.3.1.4. Node
        5. D.3.1.5. Document
        6. D.3.1.6. DOMImplementation
        7. D.3.1.7. DOMImplementationSource
        8. D.3.1.8. DOMImplementationList
        9. D.3.1.9. DocumentFragment
        10. D.3.1.10. NodeList
        11. D.3.1.11. DOMStringList
        12. D.3.1.12. NameList
        13. D.3.1.13. Element
        14. D.3.1.14. NamedNodeMap
        15. D.3.1.15. Attr
        16. D.3.1.16. CharacterData
        17. D.3.1.17. Text
        18. D.3.1.18. Comment
        19. D.3.1.19. TypeInfo
        20. D.3.1.20. UserDataHandler
        21. D.3.1.21. DOMLocator
        22. D.3.1.22. DOMConfiguration
    4. D.4. Extended Interfaces: XML Module
      1. D.4.1.
        1. D.4.1.1. CDATASection
        2. D.4.1.2. ProcessingInstruction
        3. D.4.1.3. DocumentType
        4. D.4.1.4. Notation
        5. D.4.1.5. Entity
        6. D.4.1.6. EntityReference
    5. D.5. Load and Save Interfaces
      1. D.5.1.
        1. D.5.1.1. Data Types
        2. D.5.1.2. LSException
        3. D.5.1.3. DOMImplementationLS
        4. D.5.1.4. LSParser
        5. D.5.1.5. LSSerializer
        6. D.5.1.6. LSInput
        7. D.5.1.7. LSOutput
        8. D.5.1.8. LSResourceResolver
        9. D.5.1.9. LSParserFilter
        10. D.5.1.10. LSSerializerFilter
        11. D.5.1.11. LSProgressEvent
        12. D.5.1.12. LSLoadEvent
    6. D.6. Validation Interfaces
      1. D.6.1.
        1. D.6.1.1. ExceptionVAL
        2. D.6.1.2. NodeEditVAL
        3. D.6.1.3. DocumentEditVAL
        4. D.6.1.4. ElementEditVAL
        5. D.6.1.5. CharacterDataEditVAL
  18. E. XML Schema Element and Attribute Reference
    1. E.1. all
      1. E.1.1.
        1. E.1.1.1. all
        2. E.1.1.2. Example
        3. E.1.1.3. Attributes
        4. E.1.1.4. annotation
        5. E.1.1.5. Example
        6. E.1.1.6. any
        7. E.1.1.7. Example
        8. E.1.1.8. Attributes
        9. E.1.1.9. anyAttribute
        10. E.1.1.10. Example
        11. E.1.1.11. Attributes
        12. E.1.1.12. appinfo
        13. E.1.1.13. Example
        14. E.1.1.14. Attributes
        15. E.1.1.15. attribute
        16. E.1.1.16. Example
        17. E.1.1.17. Attributes
        18. E.1.1.18. attributeGroup
        19. E.1.1.19. Example
        20. E.1.1.20. Attributes
        21. E.1.1.21. choice
        22. E.1.1.22. Example
        23. E.1.1.23. Attributes
        24. E.1.1.24. complexContent
        25. E.1.1.25. Example
        26. E.1.1.26. Attributes
        27. E.1.1.27. complexType
        28. E.1.1.28. Example
        29. E.1.1.29. Attributes
        30. E.1.1.30. documentation
        31. E.1.1.31. Example
        32. E.1.1.32. Attributes
        33. E.1.1.33. element
        34. E.1.1.34. Example
        35. E.1.1.35. Attributes
        36. E.1.1.36. extension
        37. E.1.1.37. Example
        38. E.1.1.38. Attributes
        39. E.1.1.39. field
        40. E.1.1.40. Example
        41. E.1.1.41. Attributes
        42. E.1.1.42. group
        43. E.1.1.43. Example
        44. E.1.1.44. Attributes
        45. E.1.1.45. import
        46. E.1.1.46. Example
        47. E.1.1.47. Attributes
        48. E.1.1.48. include
        49. E.1.1.49. Example
        50. E.1.1.50. Attributes
        51. E.1.1.51. key
        52. E.1.1.52. Example
        53. E.1.1.53. Attributes
        54. E.1.1.54. keyref
        55. E.1.1.55. Example
        56. E.1.1.56. Attributes
        57. E.1.1.57. list
        58. E.1.1.58. Example
        59. E.1.1.59. Attributes
        60. E.1.1.60. notation
        61. E.1.1.61. Example
        62. E.1.1.62. Attributes
        63. E.1.1.63. redefine
        64. E.1.1.64. Example
        65. E.1.1.65. Attributes
        66. E.1.1.66. restriction
        67. E.1.1.67. Example
        68. E.1.1.68. Attributes
        69. E.1.1.69. schema
        70. E.1.1.70. Example
        71. E.1.1.71. Attributes
        72. E.1.1.72. selector
        73. E.1.1.73. Example
        74. E.1.1.74. Attributes
        75. E.1.1.75. sequence
        76. E.1.1.76. Example
        77. E.1.1.77. Attributes
        78. E.1.1.78. simpleContent
        79. E.1.1.79. Example
        80. E.1.1.80. Attributes
        81. E.1.1.81. simpleType
        82. E.1.1.82. Example
        83. E.1.1.83. Attributes
        84. E.1.1.84. union
        85. E.1.1.85. Example
        86. E.1.1.86. Attributes
        87. E.1.1.87. unique
        88. E.1.1.88. Example
        89. E.1.1.89. Attributes
    2. E.2. XML Schema Instance Attributes
  19. F. XML Schema Datatypes Reference
    1. F.1. XML Schema Built-in Datatypes
    2. F.2. Constraining Facets
      1. F.2.1.
        1. F.2.1.1. length
        2. F.2.1.2. Example
        3. F.2.1.3. Attributes
        4. F.2.1.4. minLength
        5. F.2.1.5. Example
        6. F.2.1.6. Attributes
        7. F.2.1.7. maxLength
        8. F.2.1.8. Example
        9. F.2.1.9. Attributes
        10. F.2.1.10. pattern
        11. F.2.1.11. Example
        12. F.2.1.12. Attributes
        13. F.2.1.13. enumeration
        14. F.2.1.14. Example
        15. F.2.1.15. Attributes
        16. F.2.1.16. whiteSpace
        17. F.2.1.17. Example
        18. F.2.1.18. Attributes
        19. F.2.1.19. maxInclusive
        20. F.2.1.20. Example
        21. F.2.1.21. Attributes
        22. F.2.1.22. minInclusive
        23. F.2.1.23. Example
        24. F.2.1.24. Attributes
        25. F.2.1.25. maxExclusive
        26. F.2.1.26. Example
        27. F.2.1.27. Attributes
        28. F.2.1.28. minExclusive
        29. F.2.1.29. Example
        30. F.2.1.30. Attributes
        31. F.2.1.31. totalDigits
        32. F.2.1.32. Example
        33. F.2.1.33. Attributes
        34. F.2.1.34. fractionDigits
        35. F.2.1.35. Example
        36. F.2.1.36. Attributes
  20. G. SAX 2.0.2 Reference
    1. G.1. Classes and Interfaces
      1. G.1.1.
        1. G.1.1.1. Interface org.xml.sax.Attributes
        2. G.1.1.2. Interface org.xml.sax.ext.Attributes2
        3. G.1.1.3. Interface org.xml.sax.ContentHandler
        4. G.1.1.4. Interface org.xml.sax.ext.DeclHandler
        5. G.1.1.5. Interface org.xml.sax.DTDHandler
        6. G.1.1.6. Interface org.xml.sax.EntityResolver
        7. G.1.1.7. Interface org.xml.sax.ext.EntityResolver2
        8. G.1.1.8. Interface org.xml.sax.ErrorHandler
        9. G.1.1.9. Class org.xml.sax.InputSource
        10. G.1.1.10. Interface org.xml.sax.ext.LexicalHandler
        11. G.1.1.11. Interface org.xml.sax.Locator
        12. G.1.1.12. Interface org.xml.sax.ext.Locator2
        13. G.1.1.13. Exception org.xml.sax.SAXException
        14. G.1.1.14. Exception org.xml.sax.SAXNotRecognizedException
        15. G.1.1.15. Exception org.xml.sax.SAXNotRecognizedException
        16. G.1.1.16. Exception org.xml.sax.SAXNotSupportedException
        17. G.1.1.17. Exception org.xml.sax.SAXParseException
        18. G.1.1.18. Interface org.xml.sax.XMLFilter
        19. G.1.1.19. Interface org.xml.sax.XMLFilter
        20. G.1.1.20. Interface org.xml.sax.XMLReader