Index

Symbols

#FIXED keyword, To be or not to be
#IMPLIED keyword, To be or not to be
#PCDATA keyword, Parsed data
#REQUIRED keyword, To be or not to be
& ampersand, Referring to XML “Constants”
* asterisk, Using XPath for filtering
* recurrence operator, Zero, one, or more
+ recurrence operator, Zero, one, or more
- hyphen, XML Data Elements
. period, XML Data Elements
/ forward slash, XML Data Elements
; semicolon, Referring to XML “Constants”
? recurrence operator, Zero, one, or more
@ sign, Choosing elements to process
[ ] brackets, Using XPath for filtering
: colon, Identifying XML with Namespaces
:: double colon, Using XPath for filtering
_ underscore, XML Data Elements
| pipe operator, Either or

A

AbstractBuilder (JDOM), AbstractBuilder
AbstractDOMAdapter (JDOM), AbstractDOMAdapter
addAttribute(Attribute attribute), Attributes
addAttribute(String name, String value), Attributes
addChild(Comment), Comments
addChild(Element), Elements
addChild(String content), Elements
addComment(Comment), Comments
addEvent( ), A Shared Handler
addHandler( ), Writing the Server
Adobe Acrobat, Viewing PDFs from XML
ampersand (&) in entity references, Referring to XML “Constants”
Ant tool, Getting Ant
generating documentation or Javadoc, Building Cocoon
ANY keyword, Specifying Elements
Apache Cocoon (see Cocoon)
Apache Xalan (see Xalan processor)
Apache Xerces (see Xerces parser)
API reference, API Reference, XMLOutputter
APIs for XML, How Do I Use It?, JAXP
application clients, The Client of the Client of the Client
application portability, Turning on Validation
applications
transforming information between, XML for communication, XML for communication
XML used in, XML Today, XML for configuration
asterisk (*) indicating value, Using XPath for filtering
ATTLIST construct, Defining Attributes
Attribute (JDOM), Attribute
Attribute constructor, Attributes
attribute element, The definition
AttributeList interface (SAX), AttributeList
AttributeListImpl class (SAX), AttributeListImpl
attributes, Element Attributes
creating, Elements and Attributes, Elements and Attributes
defining, Defining Attributes, To be or not to be
in XML Schema, Defining Attributes, Required attributes, default values, and enumerations
elements and, Attributes
ordering of, Element Callbacks
types of, Attribute types
when to use vs. elements, Element Attributes
Attributes interface (SAX), Element Callbacks, Attributes
AttributesImpl class (SAX), AttributesImpl

B

base keyword, Required attributes, default values, and enumerations
binary data, unparsed entities and, Unparsed Entity Declarations
brackets [ ] ending selection criteria, Using XPath for filtering
browsers (see web browsers)
Builder interface (JDOM), Building a Document from XML, Builder
business-to-business communication, Business-to-business, Business-to-Business, What’s Next?
evaluating requirements, Evaluating the Requirements
validation and, Portability

C

card element, WAP and WML
cards, WAP and WML
Cascading Style Sheets (CSS), Web Publishing Frameworks
case sensitivity, element names, XML Data Elements
case statement, Determining a node’s type
Castor project, XML Versus Databases, XML Versus Directory Services and LDAP
CDATA keyword, Attribute types
CDATA section, Unparsed Data
whitespace and, Element Data
CDATASection interface (DOM), CDATASection
channels, Rich Site Summary, Validating the RSS Channel, Using the Channel
future trends, RSS Channels: Here to Stay?
Character Data (see CDATA)
CharacterData interface (DOM), CharacterData
characters( ), Element Data
character arrays and, Getting Ahead of the Data
whitespace reported by, Element Data
Clark, James, Writing the Server
clients, The Client of the Client of the Client
types of, XML for communication
updating, Updating the client, Updating the client
closing opened elements, XML Data Elements
Cocoon
building, Building Cocoon, Building Cocoon
installing, Installation
making logicsheets available to, Using XSP Tag Libraries
project, XSP
publishing framework, Processing instructions
Release 1.x.dev, obtaining, Getting Cocoon
Release 2.0+, Cocoon 2.0 and Beyond, Producers and Processors
cocoon-format, WAP and WML
cocoon.jar, Building Cocoon
cocoon.properties file, Building Cocoon, Configuring the Servlet Engine
colon (:) with namespaces/elements, Identifying XML with Namespaces
com.oreilly.xml package, A Configurable Server
Comment (JDOM), Comment
Comment class, Comments
Comment constructor, Comments
Comment interface (DOM), Comment
Comment object, Comments
comments, Comments
comments ( ), Comments
complex data types, Start at the bottom
complexType element, User-defined data types
components, The Components, XML Path Language (XPath)
Concurrent Versioning System (CVS), Installation
configuration data
displaying, Displaying the Configuration, Displaying the Configuration
LDAP and, XML Versus Directory Services and LDAP
loading, Loading the Data, Displaying the Configuration
modifying, Modifying the Data, Updating the Configuration Information
XML and, XML for Configurations, DOM
configuration files
creating, Creating an XML Configuration File, Final Preparations
design decisions for, Final Preparations
information contained in, Creating an XML Configuration File
organization and, Organization
reading, Reading an XML Configuration File, Updating the client
getting configuration information, Getting the Configuration Information, Getting the Configuration Information
loading configuration information, Loading the Configuration Information, Loading the Configuration Information
using configuration information, Using the Configuration Information, Updating the client
XML-RPC server, A Configurable Server, A Configurable Server
configuration repositories, Configuration repositories, Configuration repositories
configuration, XML for, XML for configuration
conformity to XML specification, parsers and, Parsers
constants, Referring to XML “Constants”
constraining XML documents, Constraining XML, What’s Next?
constraints, The Basics
configuration files and, Document Constraints
ease of with schemas, Enhanced Document Constraints
constructors, invoking, Starting from Scratch
content, The Content, Unparsed Data
vs. presentation, XML for presentation
separated from presentation, XSP
content attribute, The definition
content handlers, Content Handlers, The Results
ContentHandler instance, The Misplaced Locator
ContentHandler interface (SAX), Content Handlers, Content Handlers, ContentHandler
control structures, Control Structures, Choosing elements to process
core DOM object interfaces, Using a DOM Tree
count( ) function, XML Path Language (XPath)
createAttribute( ), DOM
createElement( ), DOM
createElementNS( ), DOM
createTextNode( ), DOM
creating
configuration files, Creating an XML Configuration File, Final Preparations
XML documents, Creating XML, What’s Next?
XML from scratch, XML from Scratch, XML from Scratch
XSP pages, Creating an XSP Page, Creating an XSP Page
cross-platform portability, Document Type Declarations
CSS (Cascading Style Sheets), Web Publishing Frameworks
CVS (Concurrent Versioning System), Installation

D

data
contained in elements, Element Data, Element Data
parsed, Parsed data
specifying elements as, Data . . . Just the Data, Data . . . Just the Data
textual, Element Data
data constraints, ease of with schemas, Enhanced Document Constraints
data elements (see elements)
data types
complex, Start at the bottom
user-defined, Specifying Elements, User-defined data types, User-defined data types
XML Schema, Specifying Elements
database queries, represented by XQL, XQL
databases
XML and, XML Versus Databases, Databases and XML, Databases and XML
DataConversionException (JDOM), Attributes, DataConversionException
Davidson, James Duncan, JDOM: Another API?, Getting Ant
DECHandler interface (SAX), DeclHandler
decks, WAP and WML
declaration handler property (SAX), Declaration Handler
default attribute, Required attributes, default values, and enumerations
default keyword (Java), Choosing elements to process
default namespace, The Schema Namespace
DefaultHandler helper class, DefaultHandler
deployment descriptors
EJB, EJB Deployment Descriptors, Organization
XML and, XML for configuration
directory services vs. XML, XML Versus Directory Services and LDAP
distributed systems, XML-RPC and Distributed Systems
docs target, Building Cocoon
DocType (JDOM), The Document DocType, DocType
DOCTYPE declaration, Document Type Declarations
Document (JDOM), Document
Document interface (DOM), Getting the ball rolling, Document
document locator, The Document Locator
Document node, The Document node
Document object (JDOM), Using a DOM Tree, Getting the ball rolling, Getting a Document, Building a Document from XML, Loading the Configuration Information
building from scratch, sample code, Putting JDOM to Work
firing off SAX events, Firing Off SAX Events
Document Object Model (see DOM)
Document Type Definitions (see DTDs)
documentation
generating with Ant, Building Cocoon
online, for DOC, The DOM Node Types
self-, Self-Documentation, Self-Documentation
DocumentBuilder class (JAXP), DocumentBuilder
DocumentBuilderFactory class (JAXP), DocumentBuilderFactory
DocumentFragment interface (DOM), DocumentFragment
DocumentHandler interface (SAX), DocumentHandler
documents, start/end of, The Start and the End of a Document
DocumentType interface (DOM), Document types, DocumentType
doGet( ), Displaying the Configuration, Where Did That XmlRpcConfiguration Go?
DOM (Document Object Model), DOM, The Document Object Model (DOM), Mutability of a DOM Tree
as alternative for accessing XML, DOM, DOM
as alternative to JDOM for writing or modifying XML, DOM, DOM
caution when using with large data, Memory and Performance with DOM
elements, DOM elements, DOM elements
importance for XSLT processors, Mutability of a DOM Tree
Level 2, DOM Level 2, Text
node types, The DOM Node Types, Entity references
online documentation, The DOM Node Types
parsers (see DOM parsers)
tree
mutability of, Mutability of a DOM Tree
serializing, DOM
using, Using a DOM Tree, Determining a node’s type
DOM node property (SAX), DOM Node
DOM Nodes, DOM
DOM parsers
building, Getting a DOM Parser, Getting a DOM Parser
output, DOM Parser Output, DOM Parser Output
formatting, Applying formatting, Applying formatting
throwing SAX exceptions, DOM Parsers Throwing SAX Exceptions
DOMAdapter (JDOM), DOMAdapter
DOMBuilder class (JDOM), DOMBuilder, Loading the Configuration Information, DOMBuilder
DOMException class, DOMException
DOMImplementation interface, DOMImplementation
DOMOutputter class, Firing Off SAX Events
DOMParser class, Getting a DOM Parser
doPost( ), Displaying the Configuration, Where Did That XmlRpcConfiguration Go?
double colon (::) separating keywords and elements, Using XPath for filtering
downloads
com.oreilly.xml, A Configurable Server
JDOM, JDOM: Another API?
UP.SDK software, WAP and WML
DTD references, Document types
DTDHandler interface (SAX), The DTDHandler Interface, The Rest of the Story . . ., DTDHandler
registering, Registering the Handler
DTDs (Document Type Definitions), DTD, Document Type Declarations, Document Type Definitions, Things Left Out, XML Schema, Document types
(see also XML Schema)
constraining XML Schema, XML Schema
handling, Handling Validation and Handling DTDs, Handling Validation and Handling DTDs
namespaces and, Namespace Issues with DTDs
non-fatal errors and, Non-Fatal Errors
RSS and, Rich Site Summary
vs. XML Schema, To DTD or Not To DTD, Namespace Issues with DTDs
dynamic content generation, Web Publishing Frameworks

E

EDI vs. XML, XML Versus EDI
EJB (Enterprise JavaBeans)
distributed systems and, XML-RPC and Distributed Systems
enterprise-beans element, Organization
XML and, XML for configuration
EJB deployment descriptors, EJB Deployment Descriptors, Organization
ejb-jar root element, The Basics
Element (JDOM), Element
element attributes (see attributes)
Element class, Elements
element element, Specifying Elements
element equivalence, Equivalence, Equivalence
Element interface (DOM), Element
element names, case sensitivity and, XML Data Elements
elements, XML Data Elements, XML Data Elements, Elements, Attributes
child vs. parent, Element Data
choosing which to process, Choosing elements to process, Choosing elements to process
closing opened, XML Data Elements
creating, Elements and Attributes, Elements and Attributes
data contained in, Element Data, Element Data
empty, Empty elements
nesting, Nesting elements
primitive, Start at the bottom
SAX callbacks, Element Callbacks, Element Callbacks
specifying, Specifying Elements
data as, Data . . . Just the Data, Data . . . Just the Data
in XML Schema, Specifying Elements, How many?
when to use vs. attributes, Element Attributes
embedded spaces, XML Data Elements
empty content, Implicit types and empty content
empty data type, removed from XML Schema specification, Implicit types and empty content
empty elements, XML Data Elements, Empty elements
EMPTY keyword, Empty elements
end of document, The Start and the End of a Document
end users, The Client of the Client of the Client
endDocument( ), The Start and the End of a Document
endElement( ), Element Callbacks
Enterprise JavaBeans (see EJB)
enterprise-beans element, Organization
entities
skipped (see skipped entities)
unparsed, Unparsed Entity Declarations
Entity (DOM), Entity
entity references, Referring to XML “Constants”, Entity references, Entity references
EntityReference interface (DOM), Entity references, EntityReference
EntityResolver interface (SAX), EntityResolver
enumeration element, Required attributes, default values, and enumerations
enumerations, Attribute types, Required attributes, default values, and enumerations
equivalence, Equivalence, Equivalence
error handlers, Error Handlers, Breaking the Data
error testing, Putting JDOM to Work
ErrorHandler interface (SAX), Error Handlers, ErrorHandler
adding to import statement, Error Handlers
errors
document not well-formed, Breaking the Data
during parsing, The Start and the End of a Document
fatal, Fatal Errors, Fatal Errors
finding with Xalan processor, Getting the Output
non-fatal, Non-Fatal Errors, Non-Fatal Errors
syntax, Fatal Errors
version of XML and, Breaking the Data
events
adding/removing, A Shared Handler, A Shared Handler
returning list of, A Shared Handler
sorting, A Shared Handler, A Shared Handler
events vector variable, A Shared Handler
exclude-result-prefixes attribute, WAP and WML
execute( ), Writing the Client
exemplar, Equivalence
ExoLab, XML Versus Databases
explicit types, Implicit types and empty content
Extensible Markup Language (see XML)
Extensible Server Pages (see XSP)
Extensible Stylesheet Language (see XSL)
Extensible Stylesheet Language Transformation (see XSLT)

F

FactoryConfigurationException (JAXP), FactoryConfigurationException
FAQs, Cocoon, Installation
fatal errors, Fatal Errors, Fatal Errors
features, setting (parser configuration), Setting Properties and Features
focus attribute, To be or not to be, Required attributes, default values, and enumerations, Choosing elements to process
FOP (Formatting Objects Processor), When Text Just Isn’t Good Enough, Viewing PDFs from XML
formatting model, Formatting objects
formatting objects, XSL and XSLT, Formatting objects
formatting processors, When Text Just Isn’t Good Enough
forward slash (/) in ending element tags, XML Data Elements
frameworks (see web publishing frameworks)

G

GET method, Displaying the Configuration
GET requests, Displaying the Configuration
getAttribute(String name), Attributes
getAttributes( ), DOM elements
getBooleanValue( ), Attributes
getByteValue( ), Attributes
getChild( ), Loading the Configuration Information, Updating the Configuration Information
getChildNodes( ), DOM elements
getChildren( ), Elements, Loading the Configuration Information
getColumnNumber( ), The Document Locator
getContent( ), Elements, Comments, Loading the Configuration Information
getDocumentElement( ), The Document node
getDraftDate( ), tag libraries and, Using XSP Tag Libraries
getException( ), The Start and the End of a Document
getFeature( ), Setting Properties and Features, Core Features
getFloatValue( ), Attributes
getHandlers( ), Updating the server
getInstance( ), Shared Instances
getIntValue( ), Attributes
getLineNumber( ), The Document Locator
getLocalName(int index), Element Callbacks
getMixedContent( ), Elements, Comments
getNodeName( ), DOM elements
getNodeType( ), Determining a node’s type
getNodeValue( ), DOM elements
textual data, printing, Textual nodes
getProperty( ), Setting Properties and Features
getTitle( ), tag libraries and, Using XSP Tag Libraries
getURI(int index), Element Callbacks
grouping elements, Grouping

H

handler classes, XML-RPC server configuration file, A Configurable Server, A Configurable Server
handler elements, XML-RPC handlers
configuration data and, Updating the Configuration Information
handler information, Organization
HandlerBase class, Using JAXP with SAX
Hashtable, A Shared Handler, A Configurable Server
header, The Header, Document Type Declarations
helma.xmlrpc.WebServer class, Writing the Server
helma.xmlrpc.XmlRpcClient class, Writing the Client
helma.xmlrpc.XmlRpcServer class, Writing the Handler
hierarchy of elements, Nesting elements
HndlerBase helper class (SAX), HandlerBase
HTML
leaving unprocessed, Data . . . Just the Data, Data . . . Just the Data
outputting XML document to, The Syntax
XML converted to, viewing, Viewing XML Converted to HTML
HTTP transport protocol
RPC with, What Is RPC?
used for business-to-business communication, Business-to-Business
Hunter, Jason, JDOM: Another API?
hyphen (-) in element names, XML Data Elements

I

ignorableWhitespace( ), Element Data, Whitespace, Just the Whitespace, Output of XML Validation
images
formatting objects for, Formatting objects
unparsed entities and, Unparsed Entity Declarations
implicit types, Implicit types and empty content
import statements, Parsing the Document, Content Handlers
include (Java), Using XSP Tag Libraries
InputSource class (SAX), Using an InputSource, InputSource
installing Cocoon, Installation
IOException, DOM Parsers Throwing SAX Exceptions
items, Rich Site Summary
iteration, Looping and iteration, Looping and iteration

J

Jakarta Tomcat servlet engine, Configuring the Servlet Engine
jar files, Getting the SAX Classes and Interfaces
placing logicsheets in, Using XSP Tag Libraries
Java
code, using XML-RPC, Saying Hello, Talk to Me
complementing with XML Schema, Complementing Java with XML Schema, Complementing Java with XML Schema
creating XML with, Creating XML with Java, What’s Next?
DOM and, The DOM and Java
JDOM and, Java-Optimized
parallels with XML Schema, Java Parallels, Databases and XML
perfect match with XML, Java and XML: A Perfect Match
portability and, Portability
properties files, XML for Configurations
servlet, displaying configuration data, Displaying the Configuration
Java API for XML Parsing (see JAXP)
Java Development Kit (JDK), XML for Configurations
Java Document Object Model (see JDOM)
Java language bindings, The DOM and Java
Java Naming and Directory Interface (JNDI), What Is RMI?
Java Server Pages (JSP), Web Publishing Frameworks, XSP
Java Servlet API, resources for further information, Displaying the Configuration
java.io.IOException, Writing the Client
java.net.MalformedURLException, Writing the Client
java.text.SimpleDateFormat class, A Shared Handler
java.util.Properties class, XML for Configurations
Javadoc, generating with Ant, Building Cocoon
javax.xml.parsers package, Parsers and the Java API for XML Parsing, Package: javax.xml.parsers, SAXParserFactory
JAXP (Java API for XML Parsing), JAXP, Parsers and the Java API for XML Parsing, Selecting the Parser to Use
Release 1.0, JAXP 1.0, SAXParserFactory
using with DOM, Using JAXP with DOM
using with SAX, Using JAXP with SAX, Using JAXP with SAX
which parser to use, Selecting the Parser to Use
JDK (Java Development Kit), XML for Configurations
JDOM, JDOM, JDOM: Another API?, What’s Next?
JDOM (Java Document Object Model)
accessing XML, JDOM, SAX, or DOM
alternatives to for writing/modifying XML, JDOM, SAX, or DOM, Revisited, DOM
documents (see JDOM documents)
download, JDOM: Another API?
later releases and implementations, DOM
Release 1.0, JDOM 1.0, XMLOutputter
JDOM Document object (see Document object)
JDOM documents, Getting a Document, Putting JDOM to Work
obtaining, Getting a Document, DOMBuilder
building from XML, Building a Document from XML, DOMBuilder
from scratch, Starting from Scratch
outputting, Outputting a Document, Putting JDOM to Work
using, Using a Document, Comments
JDOMException, JDOMException
JDOMTest class, Putting JDOM to Work
JNDI (Java Naming and Directory Interface), What Is RMI?
JSP (Java Server Pages), Web Publishing Frameworks, XSP

K

keywords for web browsers, Browser-Dependent Styling

L

language bindings, The DOM and Java
LDAP (Lightweight Directory Access Protocol), What Is RMI?
vs. XML, XML Versus Directory Services and LDAP
legacy data, XML Versus Databases
levels of DOM, The Document Object Model (DOM)
lexical handler property (SAX), Lexical Handler
LexicalHandler interface (SAX), LexicalHandler
Lightweight Directory Access Protocol (see LDAP)
literal (XML) string (SAX), Literal (XML) String
Locator class (SAX), The Document Locator, Locator
Locator instance, The Misplaced Locator
LocatorImpl class (SAX), LocatorImpl
logicsheets, Using XSP Tag Libraries
making available to Cocoon, Using XSP Tag Libraries
placing in jar files, Using XSP Tag Libraries
looping, Looping and iteration, Looping and iteration

M

mailing lists
Cocoon, Installation, The Sitemap
Xerces parser, Obtaining a Parser
XSL, advanced, Elements and Attributes
maxOccurs attribute, How many?
McLaughlin, Brett, JDOM: Another API?
media files, unparsed entities and, Unparsed Entity Declarations
memory, DOM and, Memory and Performance with DOM
methods
making available in RPC/RMI, Writing the Server
mutator, An Entry Point for Modification, Displaying the Configuration
Microsoft Word documents, formatting objects for, Formatting objects
minOccurs attribute, How many?, Required attributes, default values, and enumerations
mixed content, Elements
MSXML parser, caution with, Parsers
mutability of DOM tree, Mutability of a DOM Tree
mutator methods, An Entry Point for Modification, Displaying the Configuration
MySQL, XML Versus Databases

N

name attribute, Elements and Attributes
NamedNodeMap interface (DOM), NamedNodeMap
nameless types, Implicit types and empty content
names of elements, Element Callbacks
Namespace class (JDOM), Namespace
namespace definitions, omitting with XML Schema, What’s left out
namespace prefix reporting (SAX), Namespace Prefix Reporting
namespace processing (SAX), Namespace Processing
namespaces, Namespaces
for configuration files, Getting Started
DTDs and, Namespace Issues with DTDs
elements and, Namespaces
identifying XML with, Identifying XML with Namespaces, Identifying XML with Namespaces
JDOM and, Putting JDOM to Work
multiple, caution with, Identifying XML with Namespaces
root elements and, The Basics
SAX callbacks, Namespace Callbacks, Namespace Callbacks
support for with SAX, Output of XML Validation
XML Schema, The Schema Namespace, The Schema Namespace
NamespaceSupport (SAX), NamespaceSupport
NDATA keyword, Unparsed Entity Declarations
nested tags, XML Data Elements
networks, XML and, XML for communication
Node central interface (DOM), Node
Node implementation, DOM elements
Node interface, Using a DOM Tree, Determining a node’s type
node sets, XML Path Language (XPath)
node types, DOM, The DOM Node Types, Entity references
nodes, XPath, DOM
determining type of, Determining a node’s type
textual, Textual nodes
non-fatal errors, Non-Fatal Errors, Non-Fatal Errors
non-validating parsers, Element Data
skipped entities, Skipped Entities
NoSuchAttributeException (JDOM), NoSuchAttributeException
NoSuchElementException (JDOM), NoSuchElementException
NoSuchProcessingInstructionException (JDOM), NoSuchProcessingInstructionException
not( ) function, XML Path Language (XPath), Using XPath for filtering
NOTATION construct, Notation Declarations
notation declaration, Notation Declarations
Notation interface (DOM), Notation
notation names, Unparsed Entity Declarations
notationDecl( ), Notation Declarations
NoteList interface (DOM), NodeList

O

OODBMS (object-oriented database management systems), XML Versus Databases
Open Source Software (OSS), Publishing frameworks
or function/operator, Either or
Oracle, XML Versus Databases
ordering of attributes, Element Callbacks
org.jdom package, Package: org.jdom , ProcessingInstruction
org.jdom.adapters package, DOMBuilder, Package: org.jdom.adapters
org.jdom.input package, Building a Document from XML, Package: org.jdom.input
org.jdom.input.DOMBuilder class, DOMBuilder
org.jdom.input.SAXBuilder class, SAXBuilder
org.jdom.output package, Outputting a Document, Package: org.jdom.output
org.jdom.output.XMLOutputter class, Standard XML Output
org.jdom.SAXOutputter class, Firing Off SAX Events
org.w3c.dom package, Package: org.w3c.dom, Text
org.xml.sax package, Package: org.xml.sax, XMLReader
org.xml.sax.Attributes instance, Element Callbacks
org.xml.sax.ContentHandler, Content Handlers
org.xml.sax.DTDHandler, Content Handlers
org.xml.sax.EntityResolver., Content Handlers
org.xml.sax.ErrorHandler, Content Handlers
org.xml.sax.ext package, Package: org.xml.sax.ext
org.xml.sax.helpers package, Package: org.xml.sax.helpers, XMLReaderFactory
org.xml.sax.helpers.ParserAdapter class, My Parser Doesn’t Support SAX 2.0: What Can I Do?
organization, configuration files and, Organization, Organization
OSS (Open Source Software), Publishing frameworks
output
from XSLT processors, Getting the Output
standard XML, Standard XML Output, Standard XML Output
OutputStream, Standard XML Output

P

parentheses used in grouping, Grouping
Parse interface (SAX), Parser
parse( ), Getting a DOM Parser
parseConfiguration( )
using DOM, DOM
using SAX, SAX
Parsed Character Data (#PCDATA), Parsed data
parsed data, Parsed data
ParserAdapter helper class (SAX), ParserAdapter
ParserConfigurationException (JAXP), ParserConfigurationException
ParserFactory class (SAX), ParserFactory
parsers, Parsers
configuring, Configuring the Parser, Turning on Validation
non-validating (see non-validating parsers)
not reentrant, The SAX XMLReader: Reused and Reentrant
obtaining, Obtaining a Parser
portability and, A Better Way to Load a Parser, A Better Way to Load a Parser
SAX 2.0 not supported, My Parser Doesn’t Support SAX 2.0: What Can I Do?
schema validation and, XML Schema
setting validation feature, Handling Validation and Handling DTDs
validating (see validating parsers)
XML Schema not supported/partially supported, XML Schema
parsing XML documents, Parsing the Document
pattern matching, Pattern Matching
PDF (Portable Document Format), When Text Just Isn’t Good Enough
formatting objects for, Formatting objects
viewing from XML, Viewing PDFs from XML, Viewing PDFs from XML
period (.) in element names, XML Data Elements
pipe operator (|), Either or
PIs (processing instructions), PI, XML Instructions, Processing Instructions
DOM and, Processing instructions, Processing instructions
DTDs and, Things Left Out
SAX and, Processing Instructions
pluggability, Parsers and the Java API for XML Parsing
portability, Introduction
application, Turning on Validation
constraining XML and, Portability
cross-platform, Document Type Declarations
DTDs and, DTD, Things Left Out
EJB and, XML for configuration
Portable Document Format (see PDF)
position( ), WAP and WML
POST method, Displaying the Configuration
POST requests, Displaying the Configuration
prefix mapping, Namespace Callbacks
presentation vs. content, XML for presentation
primitive elements, Start at the bottom
process external entities (SAX), Process External Entities (General)
processing instructions (see PIs)
ProcessingInstruction (JDOM), ProcessingInstruction
ProcessingInstruction class, Processing Instructions
ProcessingInstruction interface (DOM), Processing instructions, Processing instructions, ProcessingInstruction
processors, Processors, It’s Greek to Me, Producers and Processors
producers, Producers and Processors
properties files (Java), XML for Configurations
properties parameter, Configuring the Servlet Engine
properties. setting (parser configuration), Setting Properties and Features
public ID, Document types
publishing frameworks (see web publishing frameworks)
push vs. pull, Push Versus Pull, Using the Channel

R

RDF (Resource Description Framework), And All the Rest . . .
recurrence, Say It Again One More Time, Either or
XML Schema and, How many?
recurrence operators, Zero, one, or more
applied to groups, Grouping
ref attribute, User-defined data types
relational databases vs. XML, XML Versus Databases
relative paths, XML Path Language (XPath)
Remote Method Invocation (RMI), XML-RPC
Remote Procedure Calls (RPC), XML-RPC
removeChildren( ), Updating the Configuration Information
removeEvent( ), A Shared Handler
repositories, configuration, Configuration repositories, Configuration repositories
request variable (XSP), Creating an XSP Page
Resource Description Framework (RDF), And All the Rest . . .
resource-ref element, Organization
resources for further information
formatting objects, Formatting objects
RMI, RPC Versus RMI
servlets, To Servlet or Not To Servlet
sorting algorithms, A Shared Handler
WAP, WAP and WML
WML, WAP and WML
XML, Creating XML
transformations, Transforming XML
XSL, advanced, Elements and Attributes
response handlers, Writing the Handler
Rich Site Summary (see RSS)
RMI (Remote Method Invocation), XML-RPC, XML-RPC, What Is RMI?
making methods available, Writing the Server
vs. RPC[RMI (Remote Method Invocation)
RPC}, RPC Versus RMI, XML-RPC
Rocha, Ricardo, XSP
root element, The Root Element, Elements
for configuration file, Getting Started
RPC (Remote Procedure Calls), XML-RPC, XML-RPC, What Is RPC?
(see also XML-RPC)
making methods available, Writing the Server
vs. RMI, RPC Versus RMI, XML-RPC
RSS (Rich Site Summary), Business-to-Business, Rich Site Summary, Using the Channel
channels, Rich Site Summary, Validating the RSS Channel, Using the Channel
future trends, RSS Channels: Here to Stay?

S

saveConfiguration( ), Displaying the Configuration
SAX (Simple API for XML), SAX
as alternative for accessing XML, SAX, SAX
as alternative to JDOM for writing/modifying XML, SAX
API Javadocs, Getting the SAX Classes and Interfaces
classes, Getting the SAX Classes and Interfaces
events, firing off, Firing Off SAX Events
exceptions, thrown by DOM parsers, DOM Parsers Throwing SAX Exceptions
namespace support, Output of XML Validation
parsers, SAX Readers, Using an InputSource
reasons for using, Why Use SAX At All?
Release 2.0, SAX 2.0, XMLReaderFactory
features, Core Features
not supported by parsers, My Parser Doesn’t Support SAX 2.0: What Can I Do?
properties, Core Properties, Literal (XML) String
sequential model, SAX Is Sequential
siblings and, SAX Siblings
SAXBuilder class (JDOM), SAXBuilder
SAXBuilder constructor (JDOM), SAXBuilder
SAXException class, The Start and the End of a Document
SAXExceptions, The Start and the End of a Document, SAXException
SAXNotRecognizedException, SAXNotRecognizedException
SAXNotSupportedException, SAXNotSupportedException
SAXParseException class, SAXParseException
adding to import statement, Error Handlers
SAXParseExceptions, Error Handlers
SAXParser class (JAXP), SAXParser
SAXParser class (JDOM), Using JAXP with SAX
SAXParserFactory class (JAXP), SAXParserFactory
SAXParserFactory class (JDOM), Using JAXP with SAX
SAXTest class, Standard XML Output
Scheduler class, A Shared Handler
schema root element, The Schema Namespace
schema validation, XML Schema
schema-valid documents, XML Schema
select attribute, XSL Templates, Using XPath for filtering, Looping and iteration
selecting axes, Using XPath for filtering
self keyword, Using XPath for filtering
self-documentation, Self-Documentation, Self-Documentation
semicolon (;) in entity references, Referring to XML “Constants”
serialize( ), DOM
server, updating, Updating the server, Updating the server
servlet configuration, XML and, XML for configuration
servlet engine, configuring for Cocoon, Configuring the Servlet Engine
servlet mapping, Servlet Engine Mappings
servlets, To Servlet or Not To Servlet
XSLT from, XSLT from a Servlet, XSLT from a Servlet
setContent( ), Updating the Configuration Information
setContent(String content), Elements
setContentHandler( ), The Results
setDocumentLocator( ), Locator instance, The Misplaced Locator
setDriver( ), Writing the Server, Writing the Client
setDTDHandler( ), Registering the Handler
setErrorHandler( ), Error Handlers
setFeature( ), Setting Properties and Features, Core Features
setNodeValue( ), DOM
setProperty( ), Setting Properties and Features
shared information, Organization, Shared information
shared instances, Shared Instances
Simple API for XML (see SAX)
simpleType element, Required attributes, default values, and enumerations
single tag, XML Data Elements
singletons, Shared Instances
sitemap, The Sitemap
skeletons, What Is RMI?
skipped entities, Skipped Entities
SAX and, My Parser Doesn’t Support SAX 2.0: What Can I Do?
sorting algorithms, A Shared Handler
spaces, embedded, XML Data Elements
specifying elements (see elements, specifying)
speed
parsers, Parsers
processors, Processors
standard XML output, Standard XML Output, Standard XML Output
start of document, The Start and the End of a Document
startDocument( ), The Start and the End of a Document
startElement( ), Element Callbacks
startPrefixMapping( ), Namespace Callbacks
static content generation, Web Publishing Frameworks
string interning (SAX), String Interning
stubs, What Is RMI?
stylesheets
CSS, Web Publishing Frameworks
using with WAP devices, WAP and WML, WAP and WML
support for XML, Support for XML, XML editors and IDEs
switch construct (Java), Determining a node’s type
switch statement (Java), Choosing elements to process
synchronized keyword, Threading, Writing, and Arithmetic
syntax errors, Fatal Errors
system ID, Document types
system resources, DOM and, Memory and Performance with DOM

T

tag, Elements and Attributes, Using XSP Tag Libraries
tag libraries
using, Using XSP Tag Libraries, Using XSP Tag Libraries
tags, nested, XML Data Elements
target namespace, Specifying Elements, User-defined data types
targetNamespace attribute, The Schema Namespace
targets, Building Cocoon
telecommunications, XML and, Business-to-business
template element, XSL Templates
test attribute, Choosing elements to process
testing cycles, validation and, Turning on Validation
text editors, XML editors and IDEs
Text interface (DOM), Text
textual data, Element Data
textual nodes, Textual nodes
threads, A Shared Handler, Threading, Writing, and Arithmetic
Tomcat servlet engine, Configuring the Servlet Engine
tools (see web publishing frameworks)
tree model, DOM
tree structure
DOM, Using a DOM Tree, Determining a node’s type
XSL and, XSL and trees
try-catch block, A Configurable Server

U

underscore (_) in element names, XML Data Elements
Uniform Resource Indicator (URI), Document Type Declarations
Uniform Resource Locators (see URLs)
unparsed data, Unparsed Data
unparsed entities, Unparsed Entity Declarations
unparsed entity declarations, Unparsed Entity Declarations
unparsedEntityDecl( ), Unparsed Entity Declarations
UP.SDK software, WAP and WML
URI (Uniform Resource Indicator), Document Type Declarations
URLs
Adobe Acrobat, Viewing PDFs from XML
Ant tool, Getting Ant
Apache Jetspeed project, Rich Site Summary
Apache XML Group, When Text Just Isn’t Good Enough
API Javadocs, Getting the SAX Classes and Interfaces
Castor project, XML Versus Databases
Cocoon, Installation
code for business-to-business applications, Entering Books
CVS, Installation
DOM, DOM
documentation, The DOM Node Types
Level One/Level Two, The Document Object Model (DOM)
JAXP, JAXP
JDOM, JDOM: Another API?, Specification Slowdown, DOM
namespaces, Namespaces
Netscape channel validation mechanism, Validating the RSS Channel
processors, Processors
publishing frameworks, Publishing frameworks
SAX, SAX
W3C, What Is It?
WML, WAP and WML
Xalan processor, Getting the Output
Xerces parser, Obtaining a Parser
XML 1.0 Specification, XML
XML editors, XML editors and IDEs
XML Schema, XML Schema, XML Schema, Stability of the XML Schema Specification
XML-RPC, XML-RPC, Getting XML-RPC Libraries
XPath, XPath
XQL, XQL
XSL, XSL and XSLT
advanced, Elements and Attributes
XSP, XSP
user agents (see web browsers)
user lag, Where Did That XmlRpcConfiguration Go?, Where Did That XmlRpcConfiguration Go?
user-defined data types, Specifying Elements, User-defined data types, User-defined data types

V

valid documents, XML Data Elements
validating parsers, Parsers, Element Data
validating XML, Portability
handling, Handling Validation and Handling DTDs, Handling Validation and Handling DTDs
turning on, Turning on Validation, Turning on Validation
when to/not to, Validate in Development, Cruise in Production
validation (SAX), Validation
Vector, A Shared Handler
version attribute, XSL Is XML

W

W3C (World Wide Web Consortium), What Is It?
WAP (Wireless Application Protocol), WAP and WML
devices, WML and, WAP and WML, WAP and WML
warnings, Warnings
validation and, Warnings
web browsers, media-specific XML transformations, Browser-Dependent Styling
web publishing frameworks, Publishing frameworks , Web Publishing Frameworks, What’s Next?
selecting, Selecting a Framework, Making the Decision
list of software, Selecting a Framework
using, Using a Publishing Framework, WAP and WML
WebServer class, Writing the Server
well-formed documents, XML Data Elements
whitespace
reporting, Element Data
RSS and, Creating an RSS XML Document
treatment during validation, Output of XML Validation
Wireless Application Protocol (see WAP)
wireless devices (see WAP, devices)
Wireless Markup Language (see WML)
WML (Wireless Markup Language), XML for presentation
resources for further information, WAP and WML
software for testing pages, WAP and WML
WAP and, WAP and WML, WAP and WML
wml element, WAP and WML
WORA (Write Once Run Anywhere), EJB Deployment Descriptors
Word (Microsoft), formatting objects for, Formatting objects
World Wide Web Consortium (W3C), What Is It?
Write Once Run Anywhere (WORA), EJB Deployment Descriptors

X

Xalan processor, Getting the Output, XSLT from a Servlet
supplied with Cocoon, Building Cocoon
Xerces parser, Obtaining a Parser
supplied with Cocoon, Building Cocoon
used with Xalan, Getting the Output
XHTML, And All the Rest . . .
XLink, And All the Rest . . .
XLL (XML Link Language), And All the Rest . . .
XML (Extensible Markup Language), Introduction, What’s Next?
1.0 Specification, XML
APIs for, How Do I Use It?, JAXP
for configuration, XML for configuration
configuration data and, XML for Configurations, DOM
configuration files (see configuration files)
converted to HTML, viewing, Viewing XML Converted to HTML
creating
from scratch, XML from Scratch, XML from Scratch
with Java, Creating XML with Java, What’s Next?
as data, What’s Next?
databases and, XML Versus Databases, Databases and XML, Databases and XML
vs. directory services, XML Versus Directory Services and LDAP
documents (see XML documents)
vs. EDI, XML Versus EDI
errors involving version of, Breaking the Data
future trends, XML Tomorrow, What’s Next?
how it is used today in applications, XML Today, XML for configuration
for communication, XML for communication, Business-to-business
for configuration, XML for configuration
for presentation, XML for presentation
identifying with namespaces, Identifying XML with Namespaces, Identifying XML with Namespaces
vs. LDAP, XML Versus Directory Services and LDAP
perfect match with Java, Java and XML: A Perfect Match
reasons for using, Why Should I Use It?, XSP
RSS, future trends and, RSS Channels: Here to Stay?
support for, Support for XML, XML editors and IDEs
transformations, The Purpose
(see also XML transformations)
media-specific, Browser-Dependent Styling
validating, Portability
viewing PDFs from, Viewing PDFs from XML, Viewing PDFs from XML
XML declaration, The Document node
XML documents
constraining, Constraining XML, What’s Next?
reasons for, Why Constrain XML Data?, Portability
creating, Creating XML, What’s Next?
locator, The Document Locator
outputting in HTML format, The Syntax
parsing, Parsing the Document
well-formed vs. valid, XML Data Elements
XML editors, XML editors and IDEs
XML instructions, XML Instructions
XML Link Language (XLL), And All the Rest . . .
XML parser classes, Obtaining a Parser
XML parsers, DOM and, The DOM and Java
XML Path Language (see XPath)
XML Schema, XML Schema, Identifying XML with Namespaces, Identifying XML with Namespaces, XML Schema, Required attributes, default values, and enumerations, XML Schema, What’s Next?
complementing Java with, Complementing Java with XML Schema, Complementing Java with XML Schema
constrained DTDs, XML Schema
data types, Specifying Elements
vs. DTDs, To DTD or Not To DTD, Namespace Issues with DTDs
namespace, The Schema Namespace, The Schema Namespace
omitting namespace definitions, What’s left out
parallels with Java, Java Parallels, Databases and XML
specification revisions, Stability of the XML Schema Specification
XML transformations
purpose of, The Purpose, It’s Greek to Me
syntax for, The Syntax, When Text Just Isn’t Good Enough
with Xalan processor, Getting the Output
xml-cocoon directory, Getting Cocoon
XML-RPC, XML-RPC, XML-RPC, To Servlet or Not To Servlet, XML-RPC and Distributed Systems
client, Writing the Client, Writing the Client, A Useful Client, A Useful Client
code using, Saying Hello, Talk to Me
handlers, Writing the Handler, Writing the Handler, A Shared Handler, A Shared Handler, XML-RPC handlers, XML-RPC handlers
libraries, obtaining, Getting XML-RPC Libraries
server, Writing the Server, Writing the Server, Putting the Load on the Server, Talk to Me (Again)
configuration file, A Configurable Server, A Configurable Server
supported Java types, Writing the Handler
XMLFilter class (SAX), XMLFilter
XMLFilterImpl class (SAX), XMLFilterImpl
xmlns attribute, Attribute types, What’s left out
default namespace and, The Schema Namespace
xmlns:xs attribute, What’s left out
xmlns:[namespace prefix] attribute, Namespaces
xmlns:[Namespace] attribute, What’s left out
XMLOutputter class (JDOM), XMLOutputter
XMLReader interface (SAX), Configuring the Parser, Turning on Validation, XMLReader
XMLReaderAdapter helper class (SAX), XMLReaderAdapter
XMLReaderFactory class (SAX), XMLReaderFactory
XmlRpcClient class, Writing the Client
XmlRpcConfiguration utility class, Where Did That XmlRpcConfiguration Go?, Where Did That XmlRpcConfiguration Go?
XmlRpcException class, Writing the Client
XMLSerializer class, DOM
XPath (XML Path Language), XPath, XML Path Language (XPath)
using for filtering, Using XPath for filtering, Using XPath for filtering
XPath expressions, Using XPath for filtering
XPointer, And All the Rest . . .
XQL, XQL
xsi:schemaLocation attribute, What’s left out
XSL (Extensible Stylesheet Language), XSL and XSLT, XSL and XSLT, The Extensible Stylesheet Language (XSL), Formatting objects
stylesheets
in business-to-business communication, Filtering the XML Data, Filtering the XML Data
using with XSLT processors, Getting the Output
templates, XSL Templates, XSL Templates
in business-to-business communication, Filtering the XML Data
XSL transformations, XSL Transformations (XSLT)
XSLT (Extensible Stylesheet Language Transformation), XSL and XSLT, XSL and XSLT
in business-to-business communication, XSLT from a Servlet, XSLT from a Servlet
processors, Getting the Output
importance of DOM for, Mutability of a DOM Tree
xsl:apply-templates construct, SAX Siblings
xsl:attribute construct, Elements and Attributes
xsl:choose construct, Choosing elements to process
xsl:copy-of construct, Data . . . Just the Data
xsl:element construct, Elements and Attributes
xsl:for-each construct, Looping and iteration
xsl:if construct, Choosing elements to process
xsl:number element, WAP and WML
xsl:otherwise construct, Choosing elements to process
xsl:when construct, Choosing elements to process
XSP (Extensible Server Pages), XSP, XSP, XSP, Using XSP Tag Libraries
creating pages, Creating an XSP Page, Creating an XSP Page
tag libraries, using, Using XSP Tag Libraries, Using XSP Tag Libraries
xsp:include, Using XSP Tag Libraries
xsp:logic element, XSP
xsp:structure, Using XSP Tag Libraries
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.188.152.157