From 9ecd03471f54de5411794e6fc58c48420564c192 Mon Sep 17 00:00:00 2001
From: Tom Tromey The attribute's effective value is determined as follows: if this
- * attribute has been explicitly assigned any value, that value is the
- * attribute's effective value; otherwise, if there is a declaration for
- * this attribute, and that declaration includes a default value, then that
- * default value is the attribute's effective value; otherwise, the
- * attribute does not exist on this element in the structure model until it
- * has been explicitly added. Note that the In XML, where the value of an attribute can contain entity references,
- * the child nodes of the See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Attr extends Node {
- /**
- * Returns the name of this attribute.
- */
- public String getName();
-
- /**
- * If this attribute was explicitly given a value in the original
- * document, this is The The See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface CDATASection extends Text {
-}
diff --git a/libjava/org/w3c/dom/CharacterData.java b/libjava/org/w3c/dom/CharacterData.java
deleted file mode 100644
index d459252..0000000
--- a/libjava/org/w3c/dom/CharacterData.java
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The As explained in the See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface CharacterData extends Node {
- /**
- * The character data of the node that implements this interface. The DOM
- * implementation may not put arbitrary limits on the amount of data
- * that may be stored in a See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Comment extends CharacterData {
-}
diff --git a/libjava/org/w3c/dom/DOMException.java b/libjava/org/w3c/dom/DOMException.java
deleted file mode 100644
index 41ad08a..0000000
--- a/libjava/org/w3c/dom/DOMException.java
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * DOM operations only raise exceptions in "exceptional" circumstances, i.e.,
- * when an operation is impossible to perform (either for logical reasons,
- * because data is lost, or because the implementation has become unstable).
- * In general, DOM methods return specific error values in ordinary
- * processing situations, such as out-of-bound errors when using
- * Implementations should raise other exceptions under other circumstances.
- * For example, implementations should raise an implementation-dependent
- * exception if a Some languages and object systems do not support the concept of
- * exceptions. For such systems, error conditions may be indicated using
- * native error reporting mechanisms. For some bindings, for example,
- * methods may return error codes similar to those listed in the
- * corresponding method descriptions.
- * See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public class DOMException extends RuntimeException {
- public DOMException(short code, String message) {
- super(message);
- this.code = code;
- }
- /** @serial */
- public short code;
- // ExceptionCode
- /**
- * If index or size is negative, or greater than the allowed value
- */
- public static final short INDEX_SIZE_ERR = 1;
- /**
- * If the specified range of text does not fit into a DOMString
- */
- public static final short DOMSTRING_SIZE_ERR = 2;
- /**
- * If any node is inserted somewhere it doesn't belong
- */
- public static final short HIERARCHY_REQUEST_ERR = 3;
- /**
- * If a node is used in a different document than the one that created it
- * (that doesn't support it)
- */
- public static final short WRONG_DOCUMENT_ERR = 4;
- /**
- * If an invalid or illegal character is specified, such as in a name. See
- * production 2 in the XML specification for the definition of a legal
- * character, and production 5 for the definition of a legal name
- * character.
- */
- public static final short INVALID_CHARACTER_ERR = 5;
- /**
- * If data is specified for a node which does not support data
- */
- public static final short NO_DATA_ALLOWED_ERR = 6;
- /**
- * If an attempt is made to modify an object where modifications are not
- * allowed
- */
- public static final short NO_MODIFICATION_ALLOWED_ERR = 7;
- /**
- * If an attempt is made to reference a node in a context where it does
- * not exist
- */
- public static final short NOT_FOUND_ERR = 8;
- /**
- * If the implementation does not support the requested type of object or
- * operation.
- */
- public static final short NOT_SUPPORTED_ERR = 9;
- /**
- * If an attempt is made to add an attribute that is already in use
- * elsewhere
- */
- public static final short INUSE_ATTRIBUTE_ERR = 10;
- /**
- * If an attempt is made to use an object that is not, or is no longer,
- * usable.
- * @since DOM Level 2
- */
- public static final short INVALID_STATE_ERR = 11;
- /**
- * If an invalid or illegal string is specified.
- * @since DOM Level 2
- */
- public static final short SYNTAX_ERR = 12;
- /**
- * If an attempt is made to modify the type of the underlying object.
- * @since DOM Level 2
- */
- public static final short INVALID_MODIFICATION_ERR = 13;
- /**
- * If an attempt is made to create or change an object in a way which is
- * incorrect with regard to namespaces.
- * @since DOM Level 2
- */
- public static final short NAMESPACE_ERR = 14;
- /**
- * If a parameter or an operation is not supported by the underlying
- * object.
- * @since DOM Level 2
- */
- public static final short INVALID_ACCESS_ERR = 15;
-
-}
diff --git a/libjava/org/w3c/dom/DOMImplementation.java b/libjava/org/w3c/dom/DOMImplementation.java
deleted file mode 100644
index b11d715..0000000
--- a/libjava/org/w3c/dom/DOMImplementation.java
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface DOMImplementation {
- /**
- * Test if the DOM implementation implements a specific feature.
- * @param featureThe name of the feature to test (case-insensitive). The
- * values used by DOM features are defined throughout the DOM Level 2
- * specifications and listed in the section. The name must be an XML
- * name. To avoid possible conflicts, as a convention, names referring
- * to features defined outside the DOM specification should be made
- * unique by reversing the name of the Internet domain name of the
- * person (or the organization that the person belongs to) who defines
- * the feature, component by component, and using this as a prefix.
- * For instance, the W3C SVG Working Group defines the feature
- * "org.w3c.dom.svg".
- * @param versionThis is the version number of the feature to test. In
- * Level 2, the string can be either "2.0" or "1.0". If the version is
- * not specified, supporting any version of the feature causes the
- * method to return Since elements, text nodes, comments, processing instructions, etc.
- * cannot exist outside the context of a See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Document extends Node {
- /**
- * The Document Type Declaration (see Furthermore, various operations -- such as inserting nodes as children
- * of another The children of a When a See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface DocumentFragment extends Node {
-}
diff --git a/libjava/org/w3c/dom/DocumentType.java b/libjava/org/w3c/dom/DocumentType.java
deleted file mode 100644
index 0bbcfac..0000000
--- a/libjava/org/w3c/dom/DocumentType.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * Each The DOM Level 2 doesn't support editing See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface DocumentType extends Node {
- /**
- * The name of DTD; i.e., the name immediately following the
- * See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Element extends Node {
- /**
- * The name of the element. For example, in:
- * The An XML processor may choose to completely expand entities before the
- * structure model is passed to the DOM; in this case there will be no
- * XML does not mandate that a non-validating XML processor read and
- * process entity declarations made in the external subset or declared in
- * external parameter entities. This means that parsed entities declared in
- * the external subset need not be expanded by some classes of applications,
- * and that the replacement value of the entity may not be available. When
- * the replacement value is available, the corresponding The DOM Level 2 does not support editing An See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Entity extends Node {
- /**
- * The public identifier associated with the entity, if specified. If the
- * public identifier was not specified, this is As for See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface EntityReference extends Node {
-}
diff --git a/libjava/org/w3c/dom/NamedNodeMap.java b/libjava/org/w3c/dom/NamedNodeMap.java
deleted file mode 100644
index d57ba8d..0000000
--- a/libjava/org/w3c/dom/NamedNodeMap.java
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * Objects implementing the See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface NamedNodeMap {
- /**
- * Retrieves a node specified by name.
- * @param nameThe The attributes See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Node {
- // NodeType
- /**
- * The node is an The items in the See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface NodeList {
- /**
- * Returns the The DOM Level 1 does not support editing A See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Notation extends Node {
- /**
- * The public identifier of this notation. If the public identifier was
- * not specified, this is See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface ProcessingInstruction extends Node {
- /**
- * The target of this processing instruction. XML defines this as being
- * the first token following the markup that begins the processing
- * instruction.
- */
- public String getTarget();
-
- /**
- * The content of this processing instruction. This is from the first non
- * white space character after the target to the character immediately
- * preceding the When a document is first made available via the DOM, there is only one
- * See also the Document Object Model (DOM) Level 2 Core Specification.
- */
-public interface Text extends CharacterData {
- /**
- * Breaks this node into two nodes at the specified See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public interface DocumentRange {
- /**
- * This interface can be obtained from the object implementing the
- * See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public interface Range {
- /**
- * Node within which the Range begins
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public class RangeException extends RuntimeException {
- public RangeException(short code, String message) {
- super(message);
- this.code = code;
- }
- public short code;
- // RangeExceptionCode
- /**
- * If the boundary-points of a Range do not meet specific requirements.
- */
- public static final short BAD_BOUNDARYPOINTS_ERR = 1;
- /**
- * If the container of an boundary-point of a Range is being set to either
- * a node of an invalid type or a node with an ancestor of an invalid
- * type.
- */
- public static final short INVALID_NODE_TYPE_ERR = 2;
-
-}
diff --git a/libjava/org/w3c/dom/traversal/DocumentTraversal.java b/libjava/org/w3c/dom/traversal/DocumentTraversal.java
deleted file mode 100644
index 88e7a92..0000000
--- a/libjava/org/w3c/dom/traversal/DocumentTraversal.java
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.traversal;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.DOMException;
-
-/**
- * See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public interface DocumentTraversal {
- /**
- * Create a new The DOM does not provide any filters. See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public interface NodeFilter {
- // Constants returned by acceptNode
- /**
- * Accept the node. Navigation methods defined for
- * See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public interface NodeIterator {
- /**
- * The root node of the Omitting nodes from the logical view of a subtree can result in a
- * structure that is substantially different from the same subtree in the
- * complete, unfiltered document. Nodes that are siblings in the
- * See also the Document Object Model (DOM) Level 2 Traversal and Range Specification.
- * @since DOM Level 2
- */
-public interface TreeWalker {
- /**
- * The This is the original SAX1 interface for reporting an element's
- * attributes. Unlike the new {@link org.xml.sax.Attributes Attributes}
- * interface, it does not support Namespace-related information. When an attribute list is supplied as part of a
- * {@link org.xml.sax.DocumentHandler#startElement startElement}
- * event, the list will return valid results only during the
- * scope of the event; once the event handler returns control
- * to the parser, the attribute list is invalid. To save a
- * persistent copy of the attribute list, use the SAX1
- * {@link org.xml.sax.helpers.AttributeListImpl AttributeListImpl}
- * helper class. An attribute list includes only attributes that have been
- * specified or defaulted: #IMPLIED attributes will not be included. There are two ways for the SAX application to obtain information
- * from the AttributeList. First, it can iterate through the entire
- * list: (Note that the result of getLength() will be zero if there
- * are no attributes.)
- *
- * As an alternative, the application can request the value or
- * type of specific attributes: The SAX parser may provide attributes in any
- * arbitrary order, regardless of the order in which they were
- * declared or specified. The number of attributes may be
- * zero. The names must be unique: the SAX parser shall not include the
- * same attribute twice. Attributes without values (those declared
- * #IMPLIED without a value specified in the start tag) will be
- * omitted from the list. If the attribute name has a namespace prefix, the prefix
- * will still be attached. The attribute type is one of the strings "CDATA", "ID",
- * "IDREF", "IDREFS", "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES",
- * or "NOTATION" (always in upper case). If the parser has not read a declaration for the attribute,
- * or if the parser does not report attribute types, then it must
- * return the value "CDATA" as stated in the XML 1.0 Recommentation
- * (clause 3.3.3, "Attribute-Value Normalization"). For an enumerated attribute that is not a notation, the
- * parser will report the type as "NMTOKEN". If the attribute value is a list of tokens (IDREFS,
- * ENTITIES, or NMTOKENS), the tokens will be concatenated
- * into a single string separated by whitespace. The return value is the same as the return value for
- * getType(int). If the attribute name has a namespace prefix in the document,
- * the application must include the prefix here. The return value is the same as the return value for
- * getValue(int). If the attribute name has a namespace prefix in the document,
- * the application must include the prefix here. This interface allows access to a list of attributes in
- * three different ways: The list will not contain attributes that were declared
- * #IMPLIED but not specified in the start tag. It will also not
- * contain attributes used as Namespace declarations (xmlns*) unless
- * the If the namespace-prefixes feature (see above) is false,
- * access by qualified name may not be available; if the
- * This interface replaces the now-deprecated SAX1 {@link
- * org.xml.sax.AttributeList AttributeList} interface, which does not
- * contain Namespace support. In addition to Namespace support, it
- * adds the getIndex methods (below). The order of attributes in the list is unspecified, and will
- * vary from implementation to implementation. Once you know the number of attributes, you can iterate
- * through the list. The attribute type is one of the strings "CDATA", "ID",
- * "IDREF", "IDREFS", "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES",
- * or "NOTATION" (always in upper case). If the parser has not read a declaration for the attribute,
- * or if the parser does not report attribute types, then it must
- * return the value "CDATA" as stated in the XML 1.0 Recommentation
- * (clause 3.3.3, "Attribute-Value Normalization"). For an enumerated attribute that is not a notation, the
- * parser will report the type as "NMTOKEN". If the attribute value is a list of tokens (IDREFS,
- * ENTITIES, or NMTOKENS), the tokens will be concatenated
- * into a single string with each token separated by a
- * single space. See {@link #getType(int) getType(int)} for a description
- * of the possible types. See {@link #getType(int) getType(int)} for a description
- * of the possible types. See {@link #getValue(int) getValue(int)} for a description
- * of the possible values. See {@link #getValue(int) getValue(int)} for a description
- * of the possible values. This is the main interface that most SAX applications
- * implement: if the application needs to be informed of basic parsing
- * events, it implements this interface and registers an instance with
- * the SAX parser using the {@link org.xml.sax.XMLReader#setContentHandler
- * setContentHandler} method. The parser uses the instance to report
- * basic document-related events like the start and end of elements
- * and character data. The order of events in this interface is very important, and
- * mirrors the order of information in the document itself. For
- * example, all of an element's content (character data, processing
- * instructions, and/or subelements) will appear, in order, between
- * the startElement event and the corresponding endElement event. This interface is similar to the now-deprecated SAX 1.0
- * DocumentHandler interface, but it adds support for Namespaces
- * and for reporting skipped entities (in non-validating XML
- * processors). Implementors should note that there is also a Java class
- * {@link java.net.ContentHandler ContentHandler} in the java.net
- * package; that means that it's probably a bad idea to do In fact, "import ...*" is usually a sign of sloppy programming
- * anyway, so the user should consider this a feature rather than a
- * bug. SAX parsers are strongly encouraged (though not absolutely
- * required) to supply a locator: if it does so, it must supply
- * the locator to the application by invoking this method before
- * invoking any of the other methods in the ContentHandler
- * interface. The locator allows the application to determine the end
- * position of any document-related event, even if the parser is
- * not reporting an error. Typically, the application will
- * use this information for reporting its own errors (such as
- * character content that does not match an application's
- * business rules). The information returned by the locator
- * is probably not sufficient for use with a search engine. Note that the locator will return correct information only
- * during the invocation of the events in this interface. The
- * application should not attempt to use it at any other time. The SAX parser will invoke this method only once, before any
- * other event callbacks (except for {@link #setDocumentLocator
- * setDocumentLocator}). The SAX parser will invoke this method only once, and it will
- * be the last method invoked during the parse. The parser shall
- * not invoke this method until it has either abandoned parsing
- * (because of an unrecoverable error) or reached the end of
- * input. The information from this event is not necessary for
- * normal Namespace processing: the SAX XML reader will
- * automatically replace prefixes for element and attribute
- * names when the There are cases, however, when applications need to
- * use prefixes in character data or in attribute values,
- * where they cannot safely be expanded automatically; the
- * start/endPrefixMapping event supplies the information
- * to the application to expand prefixes in those contexts
- * itself, if necessary. Note that start/endPrefixMapping events are not
- * guaranteed to be properly nested relative to each other:
- * all startPrefixMapping events will occur immediately before the
- * corresponding {@link #startElement startElement} event,
- * and all {@link #endPrefixMapping endPrefixMapping}
- * events will occur immediately after the corresponding
- * {@link #endElement endElement} event,
- * but their order is not otherwise
- * guaranteed. There should never be start/endPrefixMapping events for the
- * "xml" prefix, since it is predeclared and immutable. See {@link #startPrefixMapping startPrefixMapping} for
- * details. These events will always occur immediately after the
- * corresponding {@link #endElement endElement} event, but the order of
- * {@link #endPrefixMapping endPrefixMapping} events is not otherwise
- * guaranteed. The Parser will invoke this method at the beginning of every
- * element in the XML document; there will be a corresponding
- * {@link #endElement endElement} event for every startElement event
- * (even when the element is empty). All of the element's content will be
- * reported, in order, before the corresponding endElement
- * event. This event allows up to three name components for each
- * element: Any or all of these may be provided, depending on the
- * values of the http://xml.org/sax/features/namespaces
- * and the http://xml.org/sax/features/namespace-prefixes
- * properties: Note that the attribute list provided will contain only
- * attributes with explicit values (specified or defaulted):
- * #IMPLIED attributes will be omitted. The attribute list
- * will contain attributes used for Namespace declarations
- * (xmlns* attributes) only if the
- * Like {@link #characters characters()}, attribute values may have
- * characters that need more than one The SAX parser will invoke this method at the end of every
- * element in the XML document; there will be a corresponding
- * {@link #startElement startElement} event for every endElement
- * event (even when the element is empty). For information on the names, see startElement. The Parser will call this method to report each chunk of
- * character data. SAX parsers may return all contiguous character
- * data in a single chunk, or they may split it into several
- * chunks; however, all of the characters in any single event
- * must come from the same external entity so that the Locator
- * provides useful information. The application must not attempt to read from the array
- * outside of the specified range. Individual characters may consist of more than one Java
- * Your code should not assume that algorithms using
- * Note that some parsers will report whitespace in element
- * content using the {@link #ignorableWhitespace ignorableWhitespace}
- * method rather than this one (validating parsers must
- * do so). Validating Parsers must use this method to report each chunk
- * of whitespace in element content (see the W3C XML 1.0 recommendation,
- * section 2.10): non-validating parsers may also use this method
- * if they are capable of parsing and using content models. SAX parsers may return all contiguous whitespace in a single
- * chunk, or they may split it into several chunks; however, all of
- * the characters in any single event must come from the same
- * external entity, so that the Locator provides useful
- * information. The application must not attempt to read from the array
- * outside of the specified range. The Parser will invoke this method once for each processing
- * instruction found: note that processing instructions may occur
- * before or after the main document element. A SAX parser must never report an XML declaration (XML 1.0,
- * section 2.8) or a text declaration (XML 1.0, section 4.3.1)
- * using this method. Like {@link #characters characters()}, processing instruction
- * data may have characters that need more than one The Parser will invoke this method each time the entity is
- * skipped. Non-validating processors may skip entities if they
- * have not seen the declarations (because, for example, the
- * entity was declared in an external DTD subset). All processors
- * may skip external entities, depending on the values of the
- * If a SAX application needs information about notations and
- * unparsed entities, then the application implements this
- * interface and registers an instance with the SAX parser using
- * the parser's setDTDHandler method. The parser uses the
- * instance to report notation and unparsed entity declarations to
- * the application. Note that this interface includes only those DTD events that
- * the XML recommendation requires processors to report:
- * notation and unparsed entity declarations. The SAX parser may report these events in any order, regardless
- * of the order in which the notations and unparsed entities were
- * declared; however, all DTD events must be reported after the
- * document handler's startDocument event, and before the first
- * startElement event.
- * (If the {@link org.xml.sax.ext.LexicalHandler LexicalHandler} is
- * used, these events must also be reported before the endDTD event.)
- * It is up to the application to store the information for
- * future use (perhaps in a hash table or object tree).
- * If the application encounters attributes of type "NOTATION",
- * "ENTITY", or "ENTITIES", it can use the information that it
- * obtained through this interface to find the entity and/or
- * notation corresponding with the attribute value. It is up to the application to record the notation for later
- * reference, if necessary;
- * notations may appear as attribute values and in unparsed entity
- * declarations, and are sometime used with processing instruction
- * target names. At least one of publicId and systemId must be non-null.
- * If a system identifier is present, and it is a URL, the SAX
- * parser must resolve it fully before passing it to the
- * application through this event. There is no guarantee that the notation declaration will be
- * reported before any unparsed entities that use it. Note that the notation name corresponds to a notation
- * reported by the {@link #notationDecl notationDecl} event.
- * It is up to the application to record the entity for later
- * reference, if necessary;
- * unparsed entities may appear as attribute values.
- * If the system identifier is a URL, the parser must resolve it
- * fully before passing it to the application. This was the main event-handling interface for SAX1; in
- * SAX2, it has been replaced by {@link org.xml.sax.ContentHandler
- * ContentHandler}, which provides Namespace support and reporting
- * of skipped entities. This interface is included in SAX2 only
- * to support legacy SAX1 applications. The order of events in this interface is very important, and
- * mirrors the order of information in the document itself. For
- * example, all of an element's content (character data, processing
- * instructions, and/or subelements) will appear, in order, between
- * the startElement event and the corresponding endElement event. Application writers who do not want to implement the entire
- * interface can derive a class from HandlerBase, which implements
- * the default functionality; parser writers can instantiate
- * HandlerBase to obtain a default handler. The application can find
- * the location of any document event using the Locator interface
- * supplied by the Parser through the setDocumentLocator method. SAX parsers are strongly encouraged (though not absolutely
- * required) to supply a locator: if it does so, it must supply
- * the locator to the application by invoking this method before
- * invoking any of the other methods in the DocumentHandler
- * interface. The locator allows the application to determine the end
- * position of any document-related event, even if the parser is
- * not reporting an error. Typically, the application will
- * use this information for reporting its own errors (such as
- * character content that does not match an application's
- * business rules). The information returned by the locator
- * is probably not sufficient for use with a search engine. Note that the locator will return correct information only
- * during the invocation of the events in this interface. The
- * application should not attempt to use it at any other time. The SAX parser will invoke this method only once, before any
- * other methods in this interface or in DTDHandler (except for
- * setDocumentLocator). The SAX parser will invoke this method only once, and it will
- * be the last method invoked during the parse. The parser shall
- * not invoke this method until it has either abandoned parsing
- * (because of an unrecoverable error) or reached the end of
- * input. The Parser will invoke this method at the beginning of every
- * element in the XML document; there will be a corresponding
- * endElement() event for every startElement() event (even when the
- * element is empty). All of the element's content will be
- * reported, in order, before the corresponding endElement()
- * event. If the element name has a namespace prefix, the prefix will
- * still be attached. Note that the attribute list provided will
- * contain only attributes with explicit values (specified or
- * defaulted): #IMPLIED attributes will be omitted. The SAX parser will invoke this method at the end of every
- * element in the XML document; there will be a corresponding
- * startElement() event for every endElement() event (even when the
- * element is empty). If the element name has a namespace prefix, the prefix will
- * still be attached to the name. The Parser will call this method to report each chunk of
- * character data. SAX parsers may return all contiguous character
- * data in a single chunk, or they may split it into several
- * chunks; however, all of the characters in any single event
- * must come from the same external entity, so that the Locator
- * provides useful information. The application must not attempt to read from the array
- * outside of the specified range. Note that some parsers will report whitespace using the
- * ignorableWhitespace() method rather than this one (validating
- * parsers must do so). Validating Parsers must use this method to report each chunk
- * of ignorable whitespace (see the W3C XML 1.0 recommendation,
- * section 2.10): non-validating parsers may also use this method
- * if they are capable of parsing and using content models. SAX parsers may return all contiguous whitespace in a single
- * chunk, or they may split it into several chunks; however, all of
- * the characters in any single event must come from the same
- * external entity, so that the Locator provides useful
- * information. The application must not attempt to read from the array
- * outside of the specified range. The Parser will invoke this method once for each processing
- * instruction found: note that processing instructions may occur
- * before or after the main document element. A SAX parser should never report an XML declaration (XML 1.0,
- * section 2.8) or a text declaration (XML 1.0, section 4.3.1)
- * using this method. If a SAX application needs to implement customized handling
- * for external entities, it must implement this interface and
- * register an instance with the SAX driver using the
- * {@link org.xml.sax.XMLReader#setEntityResolver setEntityResolver}
- * method. The XML reader will then allow the application to intercept any
- * external entities (including the external DTD subset and external
- * parameter entities, if any) before including them. Many SAX applications will not need to implement this interface,
- * but it will be especially useful for applications that build
- * XML documents from databases or other specialised input sources,
- * or for applications that use URI types other than URLs. The following resolver would provide the application
- * with a special character stream for the entity with the system
- * identifier "http://www.myhost.com/today": The application can also use this interface to redirect system
- * identifiers to local URIs or to look up replacements in a catalog
- * (possibly by using the public identifier). The parser will call this method before opening any external
- * entity except the top-level document entity. Such entities include
- * the external DTD subset and external parameter entities referenced
- * within the DTD (in either case, only if the parser reads external
- * parameter entities), and external general entities referenced
- * within the document element (if the parser reads external general
- * entities). The application may request that the parser locate
- * the entity itself, that it use an alternative URI, or that it
- * use data provided by the application (as a character or byte
- * input stream). Application writers can use this method to redirect external
- * system identifiers to secure and/or local URIs, to look up
- * public identifiers in a catalogue, or to read an entity from a
- * database or other input source (including, for example, a dialog
- * box). Neither XML nor SAX specifies a preferred policy for using
- * public or system IDs to resolve resources. However, SAX specifies
- * how to interpret any InputSource returned by this method, and that
- * if none is returned, then the system ID will be dereferenced as
- * a URL. If the system identifier is a URL, the SAX parser must
- * resolve it fully before reporting it to the application. If a SAX application needs to implement customized error
- * handling, it must implement this interface and then register an
- * instance with the XML reader using the
- * {@link org.xml.sax.XMLReader#setErrorHandler setErrorHandler}
- * method. The parser will then report all errors and warnings
- * through this interface. WARNING: If an application does not
- * register an ErrorHandler, XML parsing errors will go unreported
- * and bizarre behaviour may result. For XML processing errors, a SAX driver must use this interface
- * instead of throwing an exception: it is up to the application
- * to decide whether to throw an exception for different types of
- * errors and warnings. Note, however, that there is no requirement that
- * the parser continue to provide useful information after a call to
- * {@link #fatalError fatalError} (in other words, a SAX driver class
- * could catch an exception and report a fatalError). SAX parsers will use this method to report conditions that
- * are not errors or fatal errors as defined by the XML 1.0
- * recommendation. The default behaviour is to take no action. The SAX parser must continue to provide normal parsing events
- * after invoking this method: it should still be possible for the
- * application to process the document through to the end. Filters may use this method to report other, non-XML warnings
- * as well. This corresponds to the definition of "error" in section 1.2
- * of the W3C XML 1.0 Recommendation. For example, a validating
- * parser would use this callback to report the violation of a
- * validity constraint. The default behaviour is to take no
- * action. The SAX parser must continue to provide normal parsing events
- * after invoking this method: it should still be possible for the
- * application to process the document through to the end. If the
- * application cannot do so, then the parser should report a fatal
- * error even if the XML 1.0 recommendation does not require it to
- * do so. Filters may use this method to report other, non-XML errors
- * as well. This corresponds to the definition of "fatal error" in
- * section 1.2 of the W3C XML 1.0 Recommendation. For example, a
- * parser would use this callback to report the violation of a
- * well-formedness constraint. The application must assume that the document is unusable
- * after the parser has invoked this method, and should continue
- * (if at all) only for the sake of collecting addition error
- * messages: in fact, SAX parsers are free to stop reporting any
- * other events once this method has been invoked. This class implements the default behaviour for four SAX1
- * interfaces: EntityResolver, DTDHandler, DocumentHandler,
- * and ErrorHandler. It is now obsolete, but is included in SAX2 to
- * support legacy SAX1 applications. SAX2 applications should use
- * the {@link org.xml.sax.helpers.DefaultHandler DefaultHandler}
- * class instead. Application writers can extend this class when they need to
- * implement only part of an interface; parser writers can
- * instantiate this class to provide default handlers when the
- * application has not supplied its own. Note that the use of this class is optional. Always return null, so that the parser will use the system
- * identifier provided in the XML document. This method implements
- * the SAX default behaviour: application writers can override it
- * in a subclass to do special translations such as catalog lookups
- * or URI redirection. By default, do nothing. Application writers may override this
- * method in a subclass if they wish to keep track of the notations
- * declared in a document. By default, do nothing. Application writers may override this
- * method in a subclass to keep track of the unparsed entities
- * declared in a document. By default, do nothing. Application writers may override this
- * method in a subclass if they wish to store the locator for use
- * with other document events. By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the beginning
- * of a document (such as allocating the root node of a tree or
- * creating an output file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the beginning
- * of a document (such as finalising a tree or closing an output
- * file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the start of
- * each element (such as allocating a new tree node or writing
- * output to a file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the end of
- * each element (such as finalising a tree node or writing
- * output to a file). By default, do nothing. Application writers may override this
- * method to take specific actions for each chunk of character data
- * (such as adding the data to a node or buffer, or printing it to
- * a file). By default, do nothing. Application writers may override this
- * method to take specific actions for each chunk of ignorable
- * whitespace (such as adding data to a node or buffer, or printing
- * it to a file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions for each
- * processing instruction, such as setting status variables or
- * invoking other methods. The default implementation does nothing. Application writers
- * may override this method in a subclass to take specific actions
- * for each warning, such as inserting the message in a log file or
- * printing it to the console. The default implementation does nothing. Application writers
- * may override this method in a subclass to take specific actions
- * for each error, such as inserting the message in a log file or
- * printing it to the console. The default implementation throws a SAXParseException.
- * Application writers may override this method in a subclass if
- * they need to take specific actions for each fatal error (such as
- * collecting all of the errors into a single report): in any case,
- * the application must stop all regular processing when this
- * method is invoked, since the document is no longer reliable, and
- * the parser may no longer report parsing events. This class allows a SAX application to encapsulate information
- * about an input source in a single object, which may include
- * a public identifier, a system identifier, a byte stream (possibly
- * with a specified encoding), and/or a character stream. There are two places that the application can deliver an
- * input source to the parser: as the argument to the Parser.parse
- * method, or as the return value of the EntityResolver.resolveEntity
- * method. The SAX parser will use the InputSource object to determine how
- * to read XML input. If there is a character stream available, the
- * parser will read that stream directly, disregarding any text
- * encoding declaration found in that stream.
- * If there is no character stream, but there is
- * a byte stream, the parser will use that byte stream, using the
- * encoding specified in the InputSource or else (if no encoding is
- * specified) autodetecting the character encoding using an algorithm
- * such as the one in the XML specification. If neither a character
- * stream nor a
- * byte stream is available, the parser will attempt to open a URI
- * connection to the resource identified by the system
- * identifier. An InputSource object belongs to the application: the SAX parser
- * shall never modify it in any way (it may modify a copy if
- * necessary). However, standard processing of both byte and
- * character streams is to close them on as part of end-of-parse cleanup,
- * so applications should not attempt to re-use such streams after they
- * have been handed to a parser. Applications may use setPublicId to include a
- * public identifier as well, or setEncoding to specify
- * the character encoding, if known. If the system identifier is a URL, it must be fully
- * resolved (it may not be a relative URL). Application writers should use setSystemId() to provide a base
- * for resolving relative URIs, may use setPublicId to include a
- * public identifier, and may use setEncoding to specify the object's
- * character encoding. Application writers should use setSystemId() to provide a base
- * for resolving relative URIs, and may use setPublicId to include a
- * public identifier. The character stream shall not include a byte order mark. The public identifier is always optional: if the application
- * writer includes one, it will be provided as part of the
- * location information. The system identifier is optional if there is a byte stream
- * or a character stream, but it is still useful to provide one,
- * since the application can use it to resolve relative URIs
- * and can include it in error messages and warnings (the parser
- * will attempt to open a connection to the URI only if
- * there is no byte stream or character stream specified). If the application knows the character encoding of the
- * object pointed to by the system identifier, it can register
- * the encoding using the setEncoding method. If the system identifier is a URL, it must be fully
- * resolved (it may not be a relative URL). The getEncoding method will return the character encoding
- * of the object pointed to, or null if unknown. If the system ID is a URL, it will be fully resolved. The SAX parser will ignore this if there is also a character
- * stream specified, but it will use a byte stream in preference
- * to opening a URI connection itself. If the application knows the character encoding of the
- * byte stream, it should set it with the setEncoding method. The getEncoding method will return the character
- * encoding for this byte stream, or null if unknown. The encoding must be a string acceptable for an
- * XML encoding declaration (see section 4.3.3 of the XML 1.0
- * recommendation). This method has no effect when the application provides a
- * character stream. If there is a character stream specified, the SAX parser
- * will ignore any byte stream and will not attempt to open
- * a URI connection to the system identifier. If a SAX parser provides location information to the SAX
- * application, it does so by implementing this interface and then
- * passing an instance to the application using the content
- * handler's {@link org.xml.sax.ContentHandler#setDocumentLocator
- * setDocumentLocator} method. The application can use the
- * object to obtain the location of any other SAX event
- * in the XML source document. Note that the results returned by the object will be valid only
- * during the scope of each callback method: the application
- * will receive unpredictable results if it attempts to use the
- * locator at any other time, or after parsing completes. SAX parsers are not required to supply a locator, but they are
- * very strongly encouraged to do so. If the parser supplies a
- * locator, it must do so before reporting any other document events.
- * If no locator has been set by the time the application receives
- * the {@link org.xml.sax.ContentHandler#startDocument startDocument}
- * event, the application should assume that a locator is not
- * available. The return value is the public identifier of the document
- * entity or of the external parsed entity in which the markup
- * triggering the event appears. The return value is the system identifier of the document
- * entity or of the external parsed entity in which the markup
- * triggering the event appears. If the system identifier is a URL, the parser must resolve it
- * fully before passing it to the application. For example, a file
- * name must always be provided as a file:... URL, and other
- * kinds of relative URI are also resolved against their bases. Warning: The return value from the method
- * is intended only as an approximation for the sake of diagnostics;
- * it is not intended to provide sufficient information
- * to edit the character content of the original XML document.
- * In some cases, these "line" numbers match what would be displayed
- * as columns, and in others they may not match the source text
- * due to internal entity expansion. The return value is an approximation of the line number
- * in the document entity or external parsed entity where the
- * markup triggering the event appears. If possible, the SAX driver should provide the line position
- * of the first character after the text associated with the document
- * event. The first line is line 1. Warning: The return value from the method
- * is intended only as an approximation for the sake of diagnostics;
- * it is not intended to provide sufficient information
- * to edit the character content of the original XML document.
- * For example, when lines contain combining character sequences, wide
- * characters, surrogate pairs, or bi-directional text, the value may
- * not correspond to the column in a text editor's display. The return value is an approximation of the column number
- * in the document entity or external parsed entity where the
- * markup triggering the event appears. If possible, the SAX driver should provide the line position
- * of the first character after the text associated with the document
- * event. The first column in each line is column 1. This was the main event supplier interface for SAX1; it has
- * been replaced in SAX2 by {@link org.xml.sax.XMLReader XMLReader},
- * which includes Namespace support and sophisticated configurability
- * and extensibility. All SAX1 parsers must implement this basic interface: it allows
- * applications to register handlers for different types of events
- * and to initiate a parse from a URI, or a character stream. All SAX1 parsers must also implement a zero-argument constructor
- * (though other constructors are also allowed). SAX1 parsers are reusable but not re-entrant: the application
- * may reuse a parser object (possibly with a different input source)
- * once the first parse has completed successfully, but it may not
- * invoke the parse() methods recursively within a parse. SAX parsers are not required to provide localisation for errors
- * and warnings; if they cannot support the requested locale,
- * however, they must throw a SAX exception. Applications may
- * not request a locale change in the middle of a parse. If the application does not register an entity resolver, the
- * SAX parser will resolve system identifiers and open connections
- * to entities itself (this is the default behaviour implemented in
- * HandlerBase). Applications may register a new or different entity resolver
- * in the middle of a parse, and the SAX parser must begin using
- * the new resolver immediately. If the application does not register a DTD handler, all DTD
- * events reported by the SAX parser will be silently
- * ignored (this is the default behaviour implemented by
- * HandlerBase). Applications may register a new or different
- * handler in the middle of a parse, and the SAX parser must
- * begin using the new handler immediately. If the application does not register a document handler, all
- * document events reported by the SAX parser will be silently
- * ignored (this is the default behaviour implemented by
- * HandlerBase). Applications may register a new or different handler in the
- * middle of a parse, and the SAX parser must begin using the new
- * handler immediately. If the application does not register an error event handler,
- * all error events reported by the SAX parser will be silently
- * ignored, except for fatalError, which will throw a SAXException
- * (this is the default behaviour implemented by HandlerBase). Applications may register a new or different handler in the
- * middle of a parse, and the SAX parser must begin using the new
- * handler immediately. The application can use this method to instruct the SAX parser
- * to begin parsing an XML document from any valid input
- * source (a character stream, a byte stream, or a URI). Applications may not invoke this method while a parse is in
- * progress (they should create a new Parser instead for each
- * additional XML document). Once a parse is complete, an
- * application may reuse the same Parser object, possibly with a
- * different input source. This method is a shortcut for the common case of reading a
- * document from a system identifier. It is the exact
- * equivalent of the following: If the system identifier is a URL, it must be fully resolved
- * by the application before it is passed to the parser. This class can contain basic error or warning information from
- * either the XML parser or the application: a parser writer or
- * application writer can subclass it to provide additional
- * functionality. SAX handlers may throw this exception or
- * any exception subclassed from it. If the application needs to pass through other types of
- * exceptions, it must wrap those exceptions in a SAXException
- * or an exception derived from a SAXException. If the parser or application needs to include information about a
- * specific location in an XML document, it should use the
- * {@link org.xml.sax.SAXParseException SAXParseException} subclass. The existing exception will be embedded in the new
- * one, and its message will become the default message for
- * the SAXException. The existing exception will be embedded in the new
- * one, but the new exception will have its own message. If there is an embedded exception, and if the SAXException
- * has no detail message of its own, this method will return
- * the detail message from the embedded exception. An XMLReader will throw this exception when it finds an
- * unrecognized feature or property identifier; SAX applications and
- * extensions may use this class for other, similar purposes. An XMLReader will throw this exception when it recognizes a
- * feature or property identifier, but cannot perform the requested
- * operation (setting a state or value). Other SAX2 applications and
- * extensions may use this class for similar purposes. This exception may include information for locating the error
- * in the original XML document, as if it came from a {@link Locator}
- * object. Note that although the application
- * will receive a SAXParseException as the argument to the handlers
- * in the {@link org.xml.sax.ErrorHandler ErrorHandler} interface,
- * the application is not actually required to throw the exception;
- * instead, it can simply read the information in it and take a
- * different action. Since this exception is a subclass of {@link org.xml.sax.SAXException
- * SAXException}, it inherits the ability to wrap another exception. This constructor is especially useful when an application is
- * creating its own exception from within a {@link org.xml.sax.ContentHandler
- * ContentHandler} callback. This constructor is especially useful when an application is
- * creating its own exception from within a {@link org.xml.sax.ContentHandler
- * ContentHandler} callback, and needs to wrap an existing exception that is not a
- * subclass of {@link org.xml.sax.SAXException SAXException}. This constructor is most useful for parser writers. All parameters except the message are as if
- * they were provided by a {@link Locator}. For example, if the
- * system identifier is a URL (including relative filename), the
- * caller must resolve it fully before creating the exception. This constructor is most useful for parser writers who
- * need to wrap an exception that is not a subclass of
- * {@link org.xml.sax.SAXException SAXException}. All parameters except the message and exception are as if
- * they were provided by a {@link Locator}. For example, if the
- * system identifier is a URL (including relative filename), the
- * caller must resolve it fully before creating the exception. If the system identifier is a URL, it will have been resolved
- * fully. The first line is line 1. The first column in a line is position 1. An XML filter is like an XML reader, except that it obtains its
- * events from another XML reader rather than a primary source like
- * an XML document or database. Filters can modify a stream of
- * events as they pass on to the final application. The XMLFilterImpl helper class provides a convenient base
- * for creating SAX2 filters, by passing on all {@link org.xml.sax.EntityResolver
- * EntityResolver}, {@link org.xml.sax.DTDHandler DTDHandler},
- * {@link org.xml.sax.ContentHandler ContentHandler} and {@link org.xml.sax.ErrorHandler
- * ErrorHandler} events automatically. This method allows the application to link the filter to
- * a parent reader (which may be another filter). The argument
- * may not be null. This method allows the application to query the parent
- * reader (which may be another filter). It is generally a
- * bad idea to perform any operations on the parent reader
- * directly: they should all pass through this filter. Note: despite its name, this interface does
- * not extend the standard Java {@link java.io.Reader Reader}
- * interface, because reading XML is a fundamentally different activity
- * than reading character data. XMLReader is the interface that an XML parser's SAX2 driver must
- * implement. This interface allows an application to set and
- * query features and properties in the parser, to register
- * event handlers for document processing, and to initiate
- * a document parse. All SAX interfaces are assumed to be synchronous: the
- * {@link #parse parse} methods must not return until parsing
- * is complete, and readers must wait for an event-handler callback
- * to return before reporting the next event. This interface replaces the (now deprecated) SAX 1.0 {@link
- * org.xml.sax.Parser Parser} interface. The XMLReader interface
- * contains two important enhancements over the old Parser
- * interface (as well as some minor ones): There are adapters available to convert a SAX1 Parser to
- * a SAX2 XMLReader and vice-versa. The feature name is any fully-qualified URI. It is
- * possible for an XMLReader to recognize a feature name but
- * temporarily be unable to return its value.
- * Some feature values may be available only in specific
- * contexts, such as before, during, or after a parse.
- * Also, some feature values may not be programmatically accessible.
- * (In the case of an adapter for SAX1 {@link Parser}, there is no
- * implementation-independent way to expose whether the underlying
- * parser is performing validation, expanding external entities,
- * and so forth.) All XMLReaders are required to recognize the
- * http://xml.org/sax/features/namespaces and the
- * http://xml.org/sax/features/namespace-prefixes feature names. Typical usage is something like this: Implementors are free (and encouraged) to invent their own features,
- * using names built on their own URIs. The feature name is any fully-qualified URI. It is
- * possible for an XMLReader to expose a feature value but
- * to be unable to change the current value.
- * Some feature values may be immutable or mutable only
- * in specific contexts, such as before, during, or after
- * a parse. All XMLReaders are required to support setting
- * http://xml.org/sax/features/namespaces to true and
- * http://xml.org/sax/features/namespace-prefixes to false. The property name is any fully-qualified URI. It is
- * possible for an XMLReader to recognize a property name but
- * temporarily be unable to return its value.
- * Some property values may be available only in specific
- * contexts, such as before, during, or after a parse. XMLReaders are not required to recognize any specific
- * property names, though an initial core set is documented for
- * SAX2. Implementors are free (and encouraged) to invent their own properties,
- * using names built on their own URIs. The property name is any fully-qualified URI. It is
- * possible for an XMLReader to recognize a property name but
- * to be unable to change the current value.
- * Some property values may be immutable or mutable only
- * in specific contexts, such as before, during, or after
- * a parse. XMLReaders are not required to recognize setting
- * any specific property names, though a core set is defined by
- * SAX2. This method is also the standard mechanism for setting
- * extended handlers. If the application does not register an entity resolver,
- * the XMLReader will perform its own default resolution. Applications may register a new or different resolver in the
- * middle of a parse, and the SAX parser must begin using the new
- * resolver immediately. If the application does not register a DTD handler, all DTD
- * events reported by the SAX parser will be silently ignored. Applications may register a new or different handler in the
- * middle of a parse, and the SAX parser must begin using the new
- * handler immediately. If the application does not register a content handler, all
- * content events reported by the SAX parser will be silently
- * ignored. Applications may register a new or different handler in the
- * middle of a parse, and the SAX parser must begin using the new
- * handler immediately. If the application does not register an error handler, all
- * error events reported by the SAX parser will be silently
- * ignored; however, normal processing may not continue. It is
- * highly recommended that all SAX applications implement an
- * error handler to avoid unexpected bugs. Applications may register a new or different handler in the
- * middle of a parse, and the SAX parser must begin using the new
- * handler immediately. The application can use this method to instruct the XML
- * reader to begin parsing an XML document from any valid input
- * source (a character stream, a byte stream, or a URI). Applications may not invoke this method while a parse is in
- * progress (they should create a new XMLReader instead for each
- * nested XML document). Once a parse is complete, an
- * application may reuse the same XMLReader object, possibly with a
- * different input source. During the parse, the XMLReader will provide information
- * about the XML document through the registered event
- * handlers. This method is synchronous: it will not return until parsing
- * has ended. If a client application wants to terminate
- * parsing early, it should throw an exception. This method is a shortcut for the common case of reading a
- * document from a system identifier. It is the exact
- * equivalent of the following: If the system identifier is a URL, it must be fully resolved
- * by the application before it is passed to the parser. This is an optional extension handler for SAX2 to provide more
- * complete information about DTD declarations in an XML document.
- * XML readers are not required to recognize this handler, and it
- * is not part of core-only SAX2 distributions. Note that data-related DTD declarations (unparsed entities and
- * notations) are already reported through the {@link
- * org.xml.sax.DTDHandler DTDHandler} interface. If you are using the declaration handler together with a lexical
- * handler, all of the events will occur between the
- * {@link org.xml.sax.ext.LexicalHandler#startDTD startDTD} and the
- * {@link org.xml.sax.ext.LexicalHandler#endDTD endDTD} events. To set the DeclHandler for an XML reader, use the
- * {@link org.xml.sax.XMLReader#setProperty setProperty} method
- * with the property name
- * The content model will consist of the string "EMPTY", the
- * string "ANY", or a parenthesised group, optionally followed
- * by an occurrence indicator. The model will be normalized so
- * that all parameter entities are fully resolved and all whitespace
- * is removed,and will include the enclosing parentheses. Other
- * normalization (such as removing redundant parentheses or
- * simplifying occurrence indicators) is at the discretion of the
- * parser. Only the effective (first) declaration for an attribute will
- * be reported. The type will be one of the strings "CDATA",
- * "ID", "IDREF", "IDREFS", "NMTOKEN", "NMTOKENS", "ENTITY",
- * "ENTITIES", a parenthesized token group with
- * the separator "|" and all whitespace removed, or the word
- * "NOTATION" followed by a space followed by a parenthesized
- * token group with all whitespace removed. The value will be the value as reported to applications,
- * appropriately normalized and with entity and character
- * references expanded. Only the effective (first) declaration for each entity
- * will be reported. All parameter entities in the value
- * will be expanded, but general entities will not. Only the effective (first) declaration for each entity
- * will be reported. This is an optional extension handler for SAX2 to provide
- * lexical information about an XML document, such as comments
- * and CDATA section boundaries.
- * XML readers are not required to recognize this handler, and it
- * is not part of core-only SAX2 distributions. The events in the lexical handler apply to the entire document,
- * not just to the document element, and all lexical handler events
- * must appear between the content handler's startDocument and
- * endDocument events. To set the LexicalHandler for an XML reader, use the
- * {@link org.xml.sax.XMLReader#setProperty setProperty} method
- * with the property name
- * This method is intended to report the beginning of the
- * DOCTYPE declaration; if the document has no DOCTYPE declaration,
- * this method will not be invoked. All declarations reported through
- * {@link org.xml.sax.DTDHandler DTDHandler} or
- * {@link org.xml.sax.ext.DeclHandler DeclHandler} events must appear
- * between the startDTD and {@link #endDTD endDTD} events.
- * Declarations are assumed to belong to the internal DTD subset
- * unless they appear between {@link #startEntity startEntity}
- * and {@link #endEntity endEntity} events. Comments and
- * processing instructions from the DTD should also be reported
- * between the startDTD and endDTD events, in their original
- * order of (logical) occurrence; they are not required to
- * appear in their correct locations relative to DTDHandler
- * or DeclHandler events, however. Note that the start/endDTD events will appear within
- * the start/endDocument events from ContentHandler and
- * before the first
- * {@link org.xml.sax.ContentHandler#startElement startElement}
- * event. This method is intended to report the end of the
- * DOCTYPE declaration; if the document has no DOCTYPE declaration,
- * this method will not be invoked. The reporting of parameter entities (including
- * the external DTD subset) is optional, and SAX2 drivers that
- * report LexicalHandler events may not implement it; you can use the
- * General entities are reported with their regular names,
- * parameter entities have '%' prepended to their names, and
- * the external DTD subset has the pseudo-entity name "[dtd]". When a SAX2 driver is providing these events, all other
- * events must be properly nested within start/end entity
- * events. There is no additional requirement that events from
- * {@link org.xml.sax.ext.DeclHandler DeclHandler} or
- * {@link org.xml.sax.DTDHandler DTDHandler} be properly ordered. Note that skipped entities will be reported through the
- * {@link org.xml.sax.ContentHandler#skippedEntity skippedEntity}
- * event, which is part of the ContentHandler interface. Because of the streaming event model that SAX uses, some
- * entity boundaries cannot be reported under any
- * circumstances: These will be silently expanded, with no indication of where
- * the original entity boundaries were. Note also that the boundaries of character references (which
- * are not really entities anyway) are not reported. All start/endEntity events must be properly nested.
- *
- * @param name The name of the entity. If it is a parameter
- * entity, the name will begin with '%', and if it is the
- * external DTD subset, it will be "[dtd]".
- * @exception SAXException The application may raise an exception.
- * @see #endEntity
- * @see org.xml.sax.ext.DeclHandler#internalEntityDecl
- * @see org.xml.sax.ext.DeclHandler#externalEntityDecl
- */
- public abstract void startEntity (String name)
- throws SAXException;
-
-
- /**
- * Report the end of an entity.
- *
- * @param name The name of the entity that is ending.
- * @exception SAXException The application may raise an exception.
- * @see #startEntity
- */
- public abstract void endEntity (String name)
- throws SAXException;
-
-
- /**
- * Report the start of a CDATA section.
- *
- * The contents of the CDATA section will be reported through
- * the regular {@link org.xml.sax.ContentHandler#characters
- * characters} event; this event is intended only to report
- * the boundary. This callback will be used for comments inside or outside the
- * document element, including comments in the external DTD
- * subset (if read). Comments in the DTD must be properly
- * nested inside start/endDTD and start/endEntity events (if
- * used).
-This package contains interfaces to optional SAX2 handlers.
-
- See http://www.saxproject.org
-for more information about SAX.
-The package is independent of the SAX2 core, though the functionality
-exposed generally needs to be implemented within a parser.
-That independence has several consequences: This package, SAX2-ext, is a standardized extension to SAX2. It is
-designed both to allow SAX parsers to pass certain types of information
-to applications, and to serve as a simple model for other SAX2 parser
-extension packages. Not all such extension packages should need to
-be recognized directly by parsers, however.
-As an example, most schema systems can be cleanly layered on top
-of parsers supporting the standardized SAX2 interfaces. NOTE: this package alone does add any
-functionality; it simply provides optional interfaces for SAX2 drivers
-to use. You must use a SAX2 driver that recognizes these interfaces if
-you actually want to have access to lexical and declaration
-information. AttributeList implements the deprecated SAX1 {@link
- * org.xml.sax.AttributeList AttributeList} interface, and has been
- * replaced by the new SAX2 {@link org.xml.sax.helpers.AttributesImpl
- * AttributesImpl} interface. This class provides a convenience implementation of the SAX
- * {@link org.xml.sax.AttributeList AttributeList} interface. This
- * implementation is useful both for SAX parser writers, who can use
- * it to provide attributes to the application, and for SAX application
- * writers, who can use it to create a persistent copy of an element's
- * attribute specifications: Please note that SAX parsers are not required to use this
- * class to provide an implementation of AttributeList; it is
- * supplied only as an optional convenience. In particular,
- * parser writers are encouraged to invent more efficient
- * implementations. This constructor is most useful for parser writers, who
- * will use it to create a single, reusable attribute list that
- * can be reset with the clear method between elements. This constructor is most useful for application writers,
- * who will use it to create a persistent copy of an existing
- * attribute list. This method allows an application writer to reuse an
- * attribute list easily. This method is provided for SAX parser writers, to allow them
- * to build up an attribute list incrementally before delivering
- * it to the application. SAX application writers can use this method to filter an
- * attribute out of an AttributeList. Note that invoking this
- * method will change the length of the attribute list and
- * some of the attribute's indices. If the requested attribute is not in the list, this is
- * a no-op. SAX parser writers can use this method to reset the attribute
- * list between DocumentHandler.startElement events. Normally,
- * it will make sense to reuse the same AttributeListImpl object
- * rather than allocating a new one each time. This class provides a default implementation of the SAX2
- * {@link org.xml.sax.Attributes Attributes} interface, with the
- * addition of manipulators so that the list can be modified or
- * reused. There are two typical uses of this class: This class replaces the now-deprecated SAX1 {@link
- * org.xml.sax.helpers.AttributeListImpl AttributeListImpl}
- * class; in addition to supporting the updated Attributes
- * interface rather than the deprecated {@link org.xml.sax.AttributeList
- * AttributeList} interface, it also includes a much more efficient
- * implementation using a single array rather than a set of Vectors. This constructor is especially useful inside a
- * {@link org.xml.sax.ContentHandler#startElement startElement} event. In many cases, it will be more efficient to look up the name once and
- * use the index query methods rather than using the name query methods
- * repeatedly. Note that little memory is freed by this call:
- * the current array is kept so it can be
- * reused. It may be more efficient to reuse an existing object
- * rather than constantly allocating new ones. For the sake of speed, this method does no checking
- * to see if the attribute is already in the list: that is
- * the responsibility of the application. For the sake of speed, this method does no checking
- * for name conflicts or well-formedness: such checks are the
- * responsibility of the application. This class is available as a convenience base class for SAX2
- * applications: it provides default implementations for all of the
- * callbacks in the four core SAX2 handler classes: Application writers can extend this class when they need to
- * implement only part of an interface; parser writers can
- * instantiate this class to provide default handlers when the
- * application has not supplied its own. This class replaces the deprecated SAX1
- * {@link org.xml.sax.HandlerBase HandlerBase} class. Always return null, so that the parser will use the system
- * identifier provided in the XML document. This method implements
- * the SAX default behaviour: application writers can override it
- * in a subclass to do special translations such as catalog lookups
- * or URI redirection. By default, do nothing. Application writers may override this
- * method in a subclass if they wish to keep track of the notations
- * declared in a document. By default, do nothing. Application writers may override this
- * method in a subclass to keep track of the unparsed entities
- * declared in a document. By default, do nothing. Application writers may override this
- * method in a subclass if they wish to store the locator for use
- * with other document events. By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the beginning
- * of a document (such as allocating the root node of a tree or
- * creating an output file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the end
- * of a document (such as finalising a tree or closing an output
- * file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the start of
- * each Namespace prefix scope (such as storing the prefix mapping). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the end of
- * each prefix mapping. By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the start of
- * each element (such as allocating a new tree node or writing
- * output to a file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions at the end of
- * each element (such as finalising a tree node or writing
- * output to a file). By default, do nothing. Application writers may override this
- * method to take specific actions for each chunk of character data
- * (such as adding the data to a node or buffer, or printing it to
- * a file). By default, do nothing. Application writers may override this
- * method to take specific actions for each chunk of ignorable
- * whitespace (such as adding data to a node or buffer, or printing
- * it to a file). By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions for each
- * processing instruction, such as setting status variables or
- * invoking other methods. By default, do nothing. Application writers may override this
- * method in a subclass to take specific actions for each
- * processing instruction, such as setting status variables or
- * invoking other methods. The default implementation does nothing. Application writers
- * may override this method in a subclass to take specific actions
- * for each warning, such as inserting the message in a log file or
- * printing it to the console. The default implementation does nothing. Application writers
- * may override this method in a subclass to take specific actions
- * for each error, such as inserting the message in a log file or
- * printing it to the console. The default implementation throws a SAXParseException.
- * Application writers may override this method in a subclass if
- * they need to take specific actions for each fatal error (such as
- * collecting all of the errors into a single report): in any case,
- * the application must stop all regular processing when this
- * method is invoked, since the document is no longer reliable, and
- * the parser may no longer report parsing events. This class is available mainly for application writers, who
- * can use it to make a persistent snapshot of a locator at any
- * point during a document parse: Normally, parser writers will not use this class, since it
- * is more efficient to provide location information only when
- * requested, rather than constantly updating a Locator object. This will not normally be useful, since the main purpose
- * of this class is to make a snapshot of an existing Locator. Create a persistent copy of the current state of a locator.
- * When the original locator changes, this copy will still keep
- * the original values (and it can be used outside the scope of
- * DocumentHandler methods). This class encapsulates the logic of Namespace processing:
- * it tracks the declarations currently in force for each context
- * and automatically processes qualified XML 1.0 names into their
- * Namespace parts; it can also be used in reverse for generating
- * XML 1.0 from Namespaces. Namespace support objects are reusable, but the reset method
- * must be invoked between each session. Here is a simple session: Note that this class is optimized for the use case where most
- * elements do not contain Namespace declarations: if the same
- * prefix/URI mapping is repeated for each context (for example), this
- * class will be somewhat less efficient. Although SAX drivers (parsers) may choose to use this class to
- * implement namespace handling, they are not required to do so.
- * Applications must track namespace information themselves if they
- * want to use namespace information.
- *
- * @since SAX 2.0
- * @author David Megginson
- * @version 2.0.1 (sax2r2)
- */
-public class NamespaceSupport
-{
-
-
- ////////////////////////////////////////////////////////////////////
- // Constants.
- ////////////////////////////////////////////////////////////////////
-
-
- /**
- * The XML Namespace URI as a constant.
- * The value is This is the Namespace URI that is automatically mapped
- * to the "xml" prefix. It is necessary to invoke this method before reusing the
- * Namespace support object for a new session. Event callback code should start a new context once per element.
- * This means being ready to call this in either of two places.
- * For elements that don't include namespace declarations, the
- * ContentHandler.startElement() callback is the right place.
- * For elements with such a declaration, it'd done in the first
- * ContentHandler.startPrefixMapping() callback.
- * A boolean flag can be used to
- * track whether a context has been started yet. When either of
- * those methods is called, it checks the flag to see if a new context
- * needs to be started. If so, it starts the context and sets the
- * flag. After ContentHandler.startElement()
- * does that, it always clears the flag.
- *
- * Normally, SAX drivers would push a new context at the beginning
- * of each XML element. Then they perform a first pass over the
- * attributes to process all namespace declarations, making
- * ContentHandler.startPrefixMapping() callbacks.
- * Then a second pass is made, to determine the namespace-qualified
- * names for all attributes and for the element name.
- * Finally all the information for the
- * ContentHandler.startElement() callback is available,
- * so it can then be made.
- *
- * The Namespace support object always starts with a base context
- * already in force: in this context, only the "xml" prefix is
- * declared. Normally, you should pop the context at the end of each
- * XML element. After popping the context, all Namespace prefix
- * mappings that were previously in force are restored. You must not attempt to declare additional Namespace
- * prefixes after popping a context, unless you push another
- * context first. This method declares a prefix in the current Namespace
- * context; the prefix will remain in force until this context
- * is popped, unless it is shadowed in a descendant context. To declare the default element Namespace, use the empty string as
- * the prefix. Note that you must not declare a prefix after
- * you've pushed and popped another Namespace context, or
- * treated the declarations phase as complete by processing
- * a prefixed name. Note that there is an asymmetry in this library: {@link
- * #getPrefix getPrefix} will not return the "" prefix,
- * even if you have declared a default element namespace.
- * To check for a default namespace,
- * you have to look it up explicitly using {@link #getURI getURI}.
- * This asymmetry exists to make it easier to look up prefixes
- * for attribute names, where the default prefix is not allowed. This method processes a raw XML 1.0 name in the current
- * context by removing the prefix and looking it up among the
- * prefixes currently declared. The return value will be the
- * array supplied by the caller, filled in as follows: All of the strings in the array will be internalized. If
- * the raw name has a prefix that has not been declared, then
- * the return value will be null. Note that attribute names are processed differently than
- * element names: an unprefixed element name will received the
- * default Namespace (if any), while an unprefixed attribute name
- * will not. This method looks up the prefix in the current context.
- * Use the empty string ("") for the default Namespace. Note: if there is a default prefix, it will not be
- * returned in this enumeration; check for the default prefix
- * using the {@link #getURI getURI} with an argument of "". If more than one prefix is currently mapped to the same
- * URI, this method will make an arbitrary selection; if you
- * want all of the prefixes, use the {@link #getPrefixes}
- * method instead. Note: this will never return the empty (default) prefix;
- * to check for a default prefix, use the {@link #getURI getURI}
- * method with an argument of "". This method returns prefixes mapped to a specific Namespace
- * URI. The xml: prefix will be included. If you want only one
- * prefix that's mapped to the Namespace URI, and you don't care
- * which one you get, use the {@link #getPrefix getPrefix}
- * method instead. Note: the empty (default) prefix is never included
- * in this enumeration; to check for the presence of a default
- * Namespace, use the {@link #getURI getURI} method with an
- * argument of "". The empty (default) prefix will be included in this
- * enumeration; note that this behaviour differs from that of
- * {@link #getPrefix} and {@link #getPrefixes}. This module caches and reuses Namespace contexts,
- * so the number allocated
- * will be equal to the element depth of the document, not to the total
- * number of elements (i.e. 5-10 rather than tens of thousands).
- * Also, data structures used to represent contexts are shared when
- * possible (child contexts without declarations) to further reduce
- * the amount of memory that's consumed.
- * Since many prefixes may be mapped to the same URI,
- * the return value may be unreliable. The default prefix, if in force, is not
- * returned, and will have to be checked for separately. This class is optimized for the normal case where most
- * elements do not contain Namespace declarations. This class contains a static method for creating an instance of a
- * class from an explicit class name. It tries to use the thread's context
- * ClassLoader if possible and falls back to using
- * Class.forName(String). This code is designed to compile and run on JDK version 1.1 and later
- * including versions of Java 2. This class wraps a SAX1 {@link org.xml.sax.Parser Parser}
- * and makes it act as a SAX2 {@link org.xml.sax.XMLReader XMLReader},
- * with feature, property, and Namespace support. Note
- * that it is not possible to report {@link org.xml.sax.ContentHandler#skippedEntity
- * skippedEntity} events, since SAX1 does not make that information available. This adapter does not test for duplicate Namespace-qualified
- * attribute names. Use the "org.xml.sax.parser" property to locate the
- * embedded SAX1 driver. Note that the embedded parser cannot be changed once the
- * adapter is created; to embed a different parser, allocate
- * a new ParserAdapter. The only features recognized are namespaces and
- * namespace-prefixes. The only features recognized are namespaces and
- * namespace-prefixes. No properties are currently recognized. No properties are currently recognized. If necessary, perform Namespace processing. If the name has an undeclared prefix, use only the qname
- * and make an ErrorHandler.error callback in case the app is
- * interested. Use this method to detect illegal feature or
- * property changes. This class is in the Public Domain, and comes with NO
- * WARRANTY of any kind. This wrapper class is used only when Namespace support
- * is disabled -- it provides pretty much a direct mapping
- * from SAX1 to SAX2, except that names and types are
- * interned whenever requested. This method must be invoked before any of the others
- * can be used. Note: This class is designed to work with the now-deprecated
- * SAX1 {@link org.xml.sax.Parser Parser} class. SAX2 applications should use
- * {@link org.xml.sax.helpers.XMLReaderFactory XMLReaderFactory} instead. ParserFactory is not part of the platform-independent definition
- * of SAX; it is an additional convenience class designed
- * specifically for Java XML application writers. SAX applications
- * can use the static methods in this class to allocate a SAX parser
- * dynamically at run-time based either on the value of the
- * `org.xml.sax.parser' system property or on a string containing the class
- * name. Note that the application still requires an XML parser that
- * implements SAX1. The named class must exist and must implement the
- * {@link org.xml.sax.Parser Parser} interface. The named class must exist and must implement the
- * {@link org.xml.sax.Parser Parser} interface. This class is designed to sit between an {@link org.xml.sax.XMLReader
- * XMLReader} and the client application's event handlers. By default, it
- * does nothing but pass requests up to the reader and events
- * on to the handlers unmodified, but subclasses can override
- * specific methods to modify the event stream or the configuration
- * requests as they pass through. This filter will have no parent: you must assign a parent
- * before you start a parse or do any configuration with
- * setFeature or setProperty, unless you use this as a pure event
- * consumer rather than as an {@link XMLReader}. This is the {@link org.xml.sax.XMLReader XMLReader} from which
- * this filter will obtain its events and to which it will pass its
- * configuration requests. The parent may itself be another filter. If there is no parent reader set, any attempt to parse
- * or to set or get a feature or property will fail. This will always fail if the parent is null. This will always fail if the parent is null. This will always fail if the parent is null. Before every parse, check whether the parent is
- * non-null, and re-register the filter for all of the
- * events. This class wraps a SAX2 {@link org.xml.sax.XMLReader XMLReader}
- * and makes it act as a SAX1 {@link org.xml.sax.Parser Parser}. The XMLReader
- * must support a true value for the
- * http://xml.org/sax/features/namespace-prefixes property or parsing will fail
- * with a {@link org.xml.sax.SAXException SAXException}; if the XMLReader
- * supports a false value for the http://xml.org/sax/features/namespaces
- * property, that will also be used to improve efficiency. Use the "org.xml.sax.driver" property to locate the SAX2
- * driver to embed. Create a new adapter, wrapped around a SAX2 XMLReader.
- * The adapter will make the XMLReader act like a SAX1
- * Parser. This is not supported in SAX2, and will always throw
- * an exception. Note that the SAX1 document handler has no Namespace
- * support. This method will throw an exception if the embedded
- * XMLReader does not support the
- * http://xml.org/sax/features/namespace-prefixes property. This method will throw an exception if the embedded
- * XMLReader does not support the
- * http://xml.org/sax/features/namespace-prefixes property. This class contains static methods for creating an XML reader
- * from an explicit class name, or based on runtime defaults: Note to Distributions bundled with parsers:
- * You should modify the implementation of the no-arguments
- * createXMLReader to handle cases where the external
- * configuration mechanisms aren't set up. That method should do its
- * best to return a parser when one is in the class path, even when
- * nothing bound its class name to This constructor prevents the class from being instantiated.Attr
interface represents an attribute in an
- * Element
object. Typically the allowable values for the
- * attribute are defined in a document type definition.
- * Attr
objects inherit the Node
interface, but
- * since they are not actually child nodes of the element they describe, the
- * DOM does not consider them part of the document tree. Thus, the
- * Node
attributes parentNode
,
- * previousSibling
, and nextSibling
have a
- * null
value for Attr
objects. The DOM takes the
- * view that attributes are properties of elements rather than having a
- * separate identity from the elements they are associated with; this should
- * make it more efficient to implement such features as default attributes
- * associated with all elements of a given type. Furthermore,
- * Attr
nodes may not be immediate children of a
- * DocumentFragment
. However, they can be associated with
- * Element
nodes contained within a
- * DocumentFragment
. In short, users and implementors of the
- * DOM need to be aware that Attr
nodes have some things in
- * common with other objects inheriting the Node
interface, but
- * they also are quite distinct.
- * nodeValue
attribute
- * on the Attr
instance can also be used to retrieve the string
- * version of the attribute's value(s).
- * Attr
node may be either
- * Text
or EntityReference
nodes (when these are
- * in use; see the description of EntityReference
for
- * discussion). Because the DOM Core is not aware of attribute types, it
- * treats all attribute values as simple strings, even if the DTD or schema
- * declares them as having tokenized types.
- * true
; otherwise, it is
- * false
. Note that the implementation is in charge of this
- * attribute, not the user. If the user changes the value of the
- * attribute (even if it ends up having the same value as the default
- * value) then the specified
flag is automatically flipped
- * to true
. To re-specify the attribute as the default
- * value from the DTD, the user must delete the attribute. The
- * implementation will then make a new attribute available with
- * specified
set to false
and the default
- * value (if one exists).
- *
In summary: If the attribute has an assigned value in the document
- * then specified
is true
, and the value is
- * the assigned value. If the attribute has no assigned value in the
- * document and has a default value in the DTD, then
- * specified
is false
, and the value is the
- * default value in the DTD. If the attribute has no assigned value in
- * the document and has a value of #IMPLIED in the DTD, then the
- * attribute does not appear in the structure model of the document. If
- * the ownerElement
attribute is null
(i.e.
- * because it was just created or was set to null
by the
- * various removal and cloning operations) specified
is
- * true
.
- */
- public boolean getSpecified();
-
- /**
- * On retrieval, the value of the attribute is returned as a string.
- * Character and general entity references are replaced with their
- * values. See also the method getAttribute
on the
- * Element
interface.
- *
On setting, this creates a Text
node with the unparsed
- * contents of the string. I.e. any characters that an XML processor
- * would recognize as markup are instead treated as literal text. See
- * also the method setAttribute
on the Element
- * interface.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
- */
- public String getValue();
- public void setValue(String value)
- throws DOMException;
-
- /**
- * The Element
node this attribute is attached to or
- * null
if this attribute is not in use.
- * @since DOM Level 2
- */
- public Element getOwnerElement();
-
-}
diff --git a/libjava/org/w3c/dom/CDATASection.java b/libjava/org/w3c/dom/CDATASection.java
deleted file mode 100644
index d9972ef..0000000
--- a/libjava/org/w3c/dom/CDATASection.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * CDATA sections are used to escape blocks of text containing characters that
- * would otherwise be regarded as markup. The only delimiter that is
- * recognized in a CDATA section is the "]]>" string that ends the CDATA
- * section. CDATA sections cannot be nested. Their primary purpose is for
- * including material such as XML fragments, without needing to escape all
- * the delimiters.
- * DOMString
attribute of the Text
node holds
- * the text that is contained by the CDATA section. Note that this may
- * contain characters that need to be escaped outside of CDATA sections and
- * that, depending on the character encoding ("charset") chosen for
- * serialization, it may be impossible to write out some characters as part
- * of a CDATA section.
- * CDATASection
interface inherits from the
- * CharacterData
interface through the Text
- * interface. Adjacent CDATASection
nodes are not merged by use
- * of the normalize
method of the Node
interface.
- * Because no markup is recognized within a CDATASection
,
- * character numeric references cannot be used as an escape mechanism when
- * serializing. Therefore, action needs to be taken when serializing a
- * CDATASection
with a character encoding where some of the
- * contained characters cannot be represented. Failure to do so would not
- * produce well-formed XML.One potential solution in the serialization
- * process is to end the CDATA section before the character, output the
- * character using a character reference or entity reference, and open a new
- * CDATA section for any further characters in the text node. Note, however,
- * that some code conversion libraries at the time of writing do not return
- * an error or exception when a character is missing from the encoding,
- * making the task of ensuring that data is not corrupted on serialization
- * more difficult.
- * CharacterData
interface extends Node with a set of
- * attributes and methods for accessing character data in the DOM. For
- * clarity this set is defined here rather than on each object that uses
- * these attributes and methods. No DOM objects correspond directly to
- * CharacterData
, though Text
and others do
- * inherit the interface from it. All offsets
in this interface
- * start from 0
.
- * DOMString
interface, text strings in
- * the DOM are represented in UTF-16, i.e. as a sequence of 16-bit units. In
- * the following, the term 16-bit units is used whenever necessary to
- * indicate that indexing on CharacterData is done in 16-bit units.
- * CharacterData
node. However,
- * implementation limits may mean that the entirety of a node's data may
- * not fit into a single DOMString
. In such cases, the user
- * may call substringData
to retrieve the data in
- * appropriately sized pieces.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
- * @exception DOMException
- * DOMSTRING_SIZE_ERR: Raised when it would return more characters than
- * fit in a DOMString
variable on the implementation
- * platform.
- */
- public String getData()
- throws DOMException;
- public void setData(String data)
- throws DOMException;
-
- /**
- * The number of 16-bit units that are available through data
- * and the substringData
method below. This may have the
- * value zero, i.e., CharacterData
nodes may be empty.
- */
- public int getLength();
-
- /**
- * Extracts a range of data from the node.
- * @param offsetStart offset of substring to extract.
- * @param countThe number of 16-bit units to extract.
- * @return The specified substring. If the sum of offset
and
- * count
exceeds the length
, then all 16-bit
- * units to the end of the data are returned.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if the specified offset
is
- * negative or greater than the number of 16-bit units in
- * data
, or if the specified count
is
- * negative.
- *
DOMSTRING_SIZE_ERR: Raised if the specified range of text does
- * not fit into a DOMString
.
- */
- public String substringData(int offset,
- int count)
- throws DOMException;
-
- /**
- * Append the string to the end of the character data of the node. Upon
- * success, data
provides access to the concatenation of
- * data
and the DOMString
specified.
- * @param argThe DOMString
to append.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public void appendData(String arg)
- throws DOMException;
-
- /**
- * Insert a string at the specified 16-bit unit offset.
- * @param offsetThe character offset at which to insert.
- * @param argThe DOMString
to insert.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if the specified offset
is
- * negative or greater than the number of 16-bit units in
- * data
.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public void insertData(int offset,
- String arg)
- throws DOMException;
-
- /**
- * Remove a range of 16-bit units from the node. Upon success,
- * data
and length
reflect the change.
- * @param offsetThe offset from which to start removing.
- * @param countThe number of 16-bit units to delete. If the sum of
- * offset
and count
exceeds
- * length
then all 16-bit units from offset
- * to the end of the data are deleted.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if the specified offset
is
- * negative or greater than the number of 16-bit units in
- * data
, or if the specified count
is
- * negative.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public void deleteData(int offset,
- int count)
- throws DOMException;
-
- /**
- * Replace the characters starting at the specified 16-bit unit offset
- * with the specified string.
- * @param offsetThe offset from which to start replacing.
- * @param countThe number of 16-bit units to replace. If the sum of
- * offset
and count
exceeds
- * length
, then all 16-bit units to the end of the data
- * are replaced; (i.e., the effect is the same as a remove
- * method call with the same range, followed by an append
- * method invocation).
- * @param argThe DOMString
with which the range must be
- * replaced.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if the specified offset
is
- * negative or greater than the number of 16-bit units in
- * data
, or if the specified count
is
- * negative.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public void replaceData(int offset,
- int count,
- String arg)
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/Comment.java b/libjava/org/w3c/dom/Comment.java
deleted file mode 100644
index 7c37d96..0000000
--- a/libjava/org/w3c/dom/Comment.java
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * This interface inherits from CharacterData
and represents the
- * content of a comment, i.e., all the characters between the starting '
- * <!--
' and ending '-->
'. Note that this is
- * the definition of a comment in XML, and, in practice, HTML, although some
- * HTML tools may implement the full SGML comment structure.
- * NodeList
.
- * null
argument is passed.
- * DOMImplementation
interface provides a number of methods
- * for performing operations that are independent of any particular instance
- * of the document object model.
- * true
.
- * @return true
if the feature is implemented in the
- * specified version, false
otherwise.
- */
- public boolean hasFeature(String feature,
- String version);
-
- /**
- * Creates an empty DocumentType
node. Entity declarations
- * and notations are not made available. Entity reference expansions and
- * default attribute additions do not occur. It is expected that a
- * future version of the DOM will provide a way for populating a
- * DocumentType
.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param qualifiedNameThe qualified name of the document type to be
- * created.
- * @param publicIdThe external subset public identifier.
- * @param systemIdThe external subset system identifier.
- * @return A new DocumentType
node with
- * Node.ownerDocument
set to null
.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified qualified name
- * contains an illegal character.
- *
NAMESPACE_ERR: Raised if the qualifiedName
is
- * malformed.
- * @since DOM Level 2
- */
- public DocumentType createDocumentType(String qualifiedName,
- String publicId,
- String systemId)
- throws DOMException;
-
- /**
- * Creates an XML Document
object of the specified type with
- * its document element. HTML-only DOM implementations do not need to
- * implement this method.
- * @param namespaceURIThe namespace URI of the document element to create.
- * @param qualifiedNameThe qualified name of the document element to be
- * created.
- * @param doctypeThe type of document to be created or null
.
- * When doctype
is not null
, its
- * Node.ownerDocument
attribute is set to the document
- * being created.
- * @return A new Document
object.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified qualified name
- * contains an illegal character.
- *
NAMESPACE_ERR: Raised if the qualifiedName
is
- * malformed, if the qualifiedName
has a prefix and the
- * namespaceURI
is null
, or if the
- * qualifiedName
has a prefix that is "xml" and the
- * namespaceURI
is different from "
- * http://www.w3.org/XML/1998/namespace" .
- *
WRONG_DOCUMENT_ERR: Raised if doctype
has already
- * been used with a different document or was created from a different
- * implementation.
- * @since DOM Level 2
- */
- public Document createDocument(String namespaceURI,
- String qualifiedName,
- DocumentType doctype)
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/Document.java b/libjava/org/w3c/dom/Document.java
deleted file mode 100644
index 2db27c9..0000000
--- a/libjava/org/w3c/dom/Document.java
+++ /dev/null
@@ -1,365 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The Document
interface represents the entire HTML or XML
- * document. Conceptually, it is the root of the document tree, and provides
- * the primary access to the document's data.
- * Document
, the
- * Document
interface also contains the factory methods needed
- * to create these objects. The Node
objects created have a
- * ownerDocument
attribute which associates them with the
- * Document
within whose context they were created.
- * DocumentType
)
- * associated with this document. For HTML documents as well as XML
- * documents without a document type declaration this returns
- * null
. The DOM Level 2 does not support editing the
- * Document Type Declaration. docType
cannot be altered in
- * any way, including through the use of methods inherited from the
- * Node
interface, such as insertNode
or
- * removeNode
.
- */
- public DocumentType getDoctype();
-
- /**
- * The DOMImplementation
object that handles this document. A
- * DOM application may use objects from multiple implementations.
- */
- public DOMImplementation getImplementation();
-
- /**
- * This is a convenience attribute that allows direct access to the child
- * node that is the root element of the document. For HTML documents,
- * this is the element with the tagName "HTML".
- */
- public Element getDocumentElement();
-
- /**
- * Creates an element of the type specified. Note that the instance
- * returned implements the Element
interface, so attributes
- * can be specified directly on the returned object.
- *
In addition, if there are known attributes with default values,
- * Attr
nodes representing them are automatically created
- * and attached to the element.
- *
To create an element with a qualified name and namespace URI, use
- * the createElementNS
method.
- * @param tagNameThe name of the element type to instantiate. For XML,
- * this is case-sensitive. For HTML, the tagName
- * parameter may be provided in any case, but it must be mapped to the
- * canonical uppercase form by the DOM implementation.
- * @return A new Element
object with the
- * nodeName
attribute set to tagName
, and
- * localName
, prefix
, and
- * namespaceURI
set to null
.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified name contains an
- * illegal character.
- */
- public Element createElement(String tagName)
- throws DOMException;
-
- /**
- * Creates an empty DocumentFragment
object.
- * @return A new DocumentFragment
.
- */
- public DocumentFragment createDocumentFragment();
-
- /**
- * Creates a Text
node given the specified string.
- * @param dataThe data for the node.
- * @return The new Text
object.
- */
- public Text createTextNode(String data);
-
- /**
- * Creates a Comment
node given the specified string.
- * @param dataThe data for the node.
- * @return The new Comment
object.
- */
- public Comment createComment(String data);
-
- /**
- * Creates a CDATASection
node whose value is the specified
- * string.
- * @param dataThe data for the CDATASection
contents.
- * @return The new CDATASection
object.
- * @exception DOMException
- * NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
- */
- public CDATASection createCDATASection(String data)
- throws DOMException;
-
- /**
- * Creates a ProcessingInstruction
node given the specified
- * name and data strings.
- * @param targetThe target part of the processing instruction.
- * @param dataThe data for the node.
- * @return The new ProcessingInstruction
object.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified target contains an
- * illegal character.
- *
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
- */
- public ProcessingInstruction createProcessingInstruction(String target,
- String data)
- throws DOMException;
-
- /**
- * Creates an Attr
of the given name. Note that the
- * Attr
instance can then be set on an Element
- * using the setAttributeNode
method.
- *
To create an attribute with a qualified name and namespace URI, use
- * the createAttributeNS
method.
- * @param nameThe name of the attribute.
- * @return A new Attr
object with the nodeName
- * attribute set to name
, and localName
,
- * prefix
, and namespaceURI
set to
- * null
. The value of the attribute is the empty string.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified name contains an
- * illegal character.
- */
- public Attr createAttribute(String name)
- throws DOMException;
-
- /**
- * Creates an EntityReference
object. In addition, if the
- * referenced entity is known, the child list of the
- * EntityReference
node is made the same as that of the
- * corresponding Entity
node.If any descendant of the
- * Entity
node has an unbound namespace prefix, the
- * corresponding descendant of the created EntityReference
- * node is also unbound; (its namespaceURI
is
- * null
). The DOM Level 2 does not support any mechanism to
- * resolve namespace prefixes.
- * @param nameThe name of the entity to reference.
- * @return The new EntityReference
object.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified name contains an
- * illegal character.
- *
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
- */
- public EntityReference createEntityReference(String name)
- throws DOMException;
-
- /**
- * Returns a NodeList
of all the Elements
with a
- * given tag name in the order in which they are encountered in a
- * preorder traversal of the Document
tree.
- * @param tagnameThe name of the tag to match on. The special value "*"
- * matches all tags.
- * @return A new NodeList
object containing all the matched
- * Elements
.
- */
- public NodeList getElementsByTagName(String tagname);
-
- /**
- * Imports a node from another document to this document. The returned
- * node has no parent; (parentNode
is null
).
- * The source node is not altered or removed from the original document;
- * this method creates a new copy of the source node.
- *
For all nodes, importing a node creates a node object owned by the
- * importing document, with attribute values identical to the source
- * node's nodeName
and nodeType
, plus the
- * attributes related to namespaces (prefix
,
- * localName
, and namespaceURI
). As in the
- * cloneNode
operation on a Node
, the source
- * node is not altered.
- *
Additional information is copied as appropriate to the
- * nodeType
, attempting to mirror the behavior expected if
- * a fragment of XML or HTML source was copied from one document to
- * another, recognizing that the two documents may have different DTDs
- * in the XML case. The following list describes the specifics for each
- * type of node.
- *
- *
ownerElement
attribute
- * is set to null
and the specified
flag is
- * set to true
on the generated Attr
. The
- * descendants of the source Attr
are recursively imported
- * and the resulting nodes reassembled to form the corresponding subtree.
- * Note that the deep
parameter has no effect on
- * Attr
nodes; they always carry their children with them
- * when imported.deep
option
- * was set to true
, the descendants of the source element
- * are recursively imported and the resulting nodes reassembled to form
- * the corresponding subtree. Otherwise, this simply generates an empty
- * DocumentFragment
.Document
- * nodes cannot be imported.DocumentType
- * nodes cannot be imported.Attr
- * nodes are attached to the generated Element
. Default
- * attributes are not copied, though if the document being imported into
- * defines default attributes for this element name, those are assigned.
- * If the importNode
deep
parameter was set to
- * true
, the descendants of the source element are
- * recursively imported and the resulting nodes reassembled to form the
- * corresponding subtree.Entity
nodes can be
- * imported, however in the current release of the DOM the
- * DocumentType
is readonly. Ability to add these imported
- * nodes to a DocumentType
will be considered for addition
- * to a future release of the DOM.On import, the publicId
,
- * systemId
, and notationName
attributes are
- * copied. If a deep
import is requested, the descendants
- * of the the source Entity
are recursively imported and
- * the resulting nodes reassembled to form the corresponding subtree.EntityReference
itself is
- * copied, even if a deep
import is requested, since the
- * source and destination documents might have defined the entity
- * differently. If the document being imported into provides a
- * definition for this entity name, its value is assigned.Notation
nodes can be imported, however in the current
- * release of the DOM the DocumentType
is readonly. Ability
- * to add these imported nodes to a DocumentType
will be
- * considered for addition to a future release of the DOM.On import, the
- * publicId
and systemId
attributes are copied.
- * Note that the deep
parameter has no effect on
- * Notation
nodes since they never have any children.target
and data
values from those of the
- * source node.CharacterData
copy their
- * data
and length
attributes from those of
- * the source node.true
, recursively import the subtree under
- * the specified node; if false
, import only the node
- * itself, as explained above. This has no effect on Attr
- * , EntityReference
, and Notation
nodes.
- * @return The imported node that belongs to this Document
.
- * @exception DOMException
- * NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
- * supported.
- * @since DOM Level 2
- */
- public Node importNode(Node importedNode,
- boolean deep)
- throws DOMException;
-
- /**
- * Creates an element of the given qualified name and namespace URI.
- * HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the element to create.
- * @param qualifiedNameThe qualified name of the element type to
- * instantiate.
- * @return A new Element
object with the following
- * attributes:AttributeValueNode.nodeName
- * qualifiedName
Node.namespaceURI
- * namespaceURI
Node.prefix
prefix, extracted
- * from qualifiedName
, or null
if there is
- * no prefixNode.localName
local name, extracted from
- * qualifiedName
Element.tagName
- * qualifiedName
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified qualified name
- * contains an illegal character.
- *
NAMESPACE_ERR: Raised if the qualifiedName
is
- * malformed, if the qualifiedName
has a prefix and the
- * namespaceURI
is null
, or if the
- * qualifiedName
has a prefix that is "xml" and the
- * namespaceURI
is different from "
- * http://www.w3.org/XML/1998/namespace" .
- * @since DOM Level 2
- */
- public Element createElementNS(String namespaceURI,
- String qualifiedName)
- throws DOMException;
-
- /**
- * Creates an attribute of the given qualified name and namespace URI.
- * HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the attribute to create.
- * @param qualifiedNameThe qualified name of the attribute to instantiate.
- * @return A new Attr
object with the following attributes:
- * AttributeValueNode.nodeName
qualifiedName
- * Node.namespaceURI
namespaceURI
- * Node.prefix
prefix, extracted from
- * qualifiedName
, or null
if there is no
- * prefixNode.localName
local name, extracted from
- * qualifiedName
Attr.name
- * qualifiedName
Node.nodeValue
the empty
- * string
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified qualified name
- * contains an illegal character.
- *
NAMESPACE_ERR: Raised if the qualifiedName
is
- * malformed, if the qualifiedName
has a prefix and the
- * namespaceURI
is null
, if the
- * qualifiedName
has a prefix that is "xml" and the
- * namespaceURI
is different from "
- * http://www.w3.org/XML/1998/namespace", or if the
- * qualifiedName
is "xmlns" and the
- * namespaceURI
is different from "
- * http://www.w3.org/2000/xmlns/".
- * @since DOM Level 2
- */
- public Attr createAttributeNS(String namespaceURI,
- String qualifiedName)
- throws DOMException;
-
- /**
- * Returns a NodeList
of all the Elements
with a
- * given local name and namespace URI in the order in which they are
- * encountered in a preorder traversal of the Document
tree.
- * @param namespaceURIThe namespace URI of the elements to match on. The
- * special value "*" matches all namespaces.
- * @param localNameThe local name of the elements to match on. The
- * special value "*" matches all local names.
- * @return A new NodeList
object containing all the matched
- * Elements
.
- * @since DOM Level 2
- */
- public NodeList getElementsByTagNameNS(String namespaceURI,
- String localName);
-
- /**
- * Returns the Element
whose ID
is given by
- * elementId
. If no such element exists, returns
- * null
. Behavior is not defined if more than one element
- * has this ID
. The DOM implementation must have
- * information that says which attributes are of type ID. Attributes
- * with the name "ID" are not of type ID unless so defined.
- * Implementations that do not know whether attributes are of type ID or
- * not are expected to return null
.
- * @param elementIdThe unique id
value for an element.
- * @return The matching element.
- * @since DOM Level 2
- */
- public Element getElementById(String elementId);
-
-}
diff --git a/libjava/org/w3c/dom/DocumentFragment.java b/libjava/org/w3c/dom/DocumentFragment.java
deleted file mode 100644
index 9579eb7..0000000
--- a/libjava/org/w3c/dom/DocumentFragment.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * DocumentFragment
is a "lightweight" or "minimal"
- * Document
object. It is very common to want to be able to
- * extract a portion of a document's tree or to create a new fragment of a
- * document. Imagine implementing a user command like cut or rearranging a
- * document by moving fragments around. It is desirable to have an object
- * which can hold such fragments and it is quite natural to use a Node for
- * this purpose. While it is true that a Document
object could
- * fulfill this role, a Document
object can potentially be a
- * heavyweight object, depending on the underlying implementation. What is
- * really needed for this is a very lightweight object.
- * DocumentFragment
is such an object.
- * Node
-- may take DocumentFragment
- * objects as arguments; this results in all the child nodes of the
- * DocumentFragment
being moved to the child list of this node.
- * DocumentFragment
node are zero or more
- * nodes representing the tops of any sub-trees defining the structure of
- * the document. DocumentFragment
nodes do not need to be
- * well-formed XML documents (although they do need to follow the rules
- * imposed upon well-formed XML parsed entities, which can have multiple top
- * nodes). For example, a DocumentFragment
might have only one
- * child and that child node could be a Text
node. Such a
- * structure model represents neither an HTML document nor a well-formed XML
- * document.
- * DocumentFragment
is inserted into a
- * Document
(or indeed any other Node
that may
- * take children) the children of the DocumentFragment
and not
- * the DocumentFragment
itself are inserted into the
- * Node
. This makes the DocumentFragment
very
- * useful when the user wishes to create nodes that are siblings; the
- * DocumentFragment
acts as the parent of these nodes so that
- * the user can use the standard methods from the Node
- * interface, such as insertBefore
and appendChild
.
- * Document
has a doctype
attribute whose value
- * is either null
or a DocumentType
object. The
- * DocumentType
interface in the DOM Core provides an interface
- * to the list of entities that are defined for the document, and little
- * else because the effect of namespaces and the various XML schema efforts
- * on DTD representation are not clearly understood as of this writing.
- * DocumentType
nodes.
- * DOCTYPE
keyword.
- */
- public String getName();
-
- /**
- * A NamedNodeMap
containing the general entities, both
- * external and internal, declared in the DTD. Parameter entities are
- * not contained. Duplicates are discarded. For example in:
- * <!DOCTYPE
- * ex SYSTEM "ex.dtd" [ <!ENTITY foo "foo"> <!ENTITY bar
- * "bar"> <!ENTITY bar "bar2"> <!ENTITY % baz "baz">
- * ]> <ex/>
- * the interface provides access to foo
- * and the first declaration of bar
but not the second
- * declaration of bar
or baz
. Every node in
- * this map also implements the Entity
interface.
- *
The DOM Level 2 does not support editing entities, therefore
- * entities
cannot be altered in any way.
- */
- public NamedNodeMap getEntities();
-
- /**
- * A NamedNodeMap
containing the notations declared in the
- * DTD. Duplicates are discarded. Every node in this map also implements
- * the Notation
interface.
- *
The DOM Level 2 does not support editing notations, therefore
- * notations
cannot be altered in any way.
- */
- public NamedNodeMap getNotations();
-
- /**
- * The public identifier of the external subset.
- * @since DOM Level 2
- */
- public String getPublicId();
-
- /**
- * The system identifier of the external subset.
- * @since DOM Level 2
- */
- public String getSystemId();
-
- /**
- * The internal subset as a string.The actual content returned depends on
- * how much information is available to the implementation. This may
- * vary depending on various parameters, including the XML processor
- * used to build the document.
- * @since DOM Level 2
- */
- public String getInternalSubset();
-
-}
diff --git a/libjava/org/w3c/dom/Element.java b/libjava/org/w3c/dom/Element.java
deleted file mode 100644
index 85277fa..0000000
--- a/libjava/org/w3c/dom/Element.java
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The Element
interface represents an element in an HTML or XML
- * document. Elements may have attributes associated with them; since the
- * Element
interface inherits from Node
, the
- * generic Node
interface attribute attributes
may
- * be used to retrieve the set of all attributes for an element. There are
- * methods on the Element
interface to retrieve either an
- * Attr
object by name or an attribute value by name. In XML,
- * where an attribute value may contain entity references, an
- * Attr
object should be retrieved to examine the possibly
- * fairly complex sub-tree representing the attribute value. On the other
- * hand, in HTML, where all attributes have simple string values, methods to
- * directly access an attribute value can safely be used as a convenience.In
- * DOM Level 2, the method normalize
is inherited from the
- * Node
interface where it was moved.
- * <elementExample
- * id="demo"> ... </elementExample> ,
- * tagName
has
- * the value "elementExample"
. Note that this is
- * case-preserving in XML, as are all of the operations of the DOM. The
- * HTML DOM returns the tagName
of an HTML element in the
- * canonical uppercase form, regardless of the case in the source HTML
- * document.
- */
- public String getTagName();
-
- /**
- * Retrieves an attribute value by name.
- * @param nameThe name of the attribute to retrieve.
- * @return The Attr
value as a string, or the empty string
- * if that attribute does not have a specified or default value.
- */
- public String getAttribute(String name);
-
- /**
- * Adds a new attribute. If an attribute with that name is already present
- * in the element, its value is changed to be that of the value
- * parameter. This value is a simple string; it is not parsed as it is
- * being set. So any markup (such as syntax to be recognized as an
- * entity reference) is treated as literal text, and needs to be
- * appropriately escaped by the implementation when it is written out.
- * In order to assign an attribute value that contains entity
- * references, the user must create an Attr
node plus any
- * Text
and EntityReference
nodes, build the
- * appropriate subtree, and use setAttributeNode
to assign
- * it as the value of an attribute.
- *
To set an attribute with a qualified name and namespace URI, use
- * the setAttributeNS
method.
- * @param nameThe name of the attribute to create or alter.
- * @param valueValue to set in string form.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified name contains an
- * illegal character.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public void setAttribute(String name,
- String value)
- throws DOMException;
-
- /**
- * Removes an attribute by name. If the removed attribute is known to have
- * a default value, an attribute immediately appears containing the
- * default value as well as the corresponding namespace URI, local name,
- * and prefix when applicable.
- *
To remove an attribute by local name and namespace URI, use the
- * removeAttributeNS
method.
- * @param nameThe name of the attribute to remove.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public void removeAttribute(String name)
- throws DOMException;
-
- /**
- * Retrieves an attribute node by name.
- *
To retrieve an attribute node by qualified name and namespace URI,
- * use the getAttributeNodeNS
method.
- * @param nameThe name (nodeName
) of the attribute to
- * retrieve.
- * @return The Attr
node with the specified name (
- * nodeName
) or null
if there is no such
- * attribute.
- */
- public Attr getAttributeNode(String name);
-
- /**
- * Adds a new attribute node. If an attribute with that name (
- * nodeName
) is already present in the element, it is
- * replaced by the new one.
- *
To add a new attribute node with a qualified name and namespace
- * URI, use the setAttributeNodeNS
method.
- * @param newAttrThe Attr
node to add to the attribute list.
- * @return If the newAttr
attribute replaces an existing
- * attribute, the replaced Attr
node is returned,
- * otherwise null
is returned.
- * @exception DOMException
- * WRONG_DOCUMENT_ERR: Raised if newAttr
was created from a
- * different document than the one that created the element.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- *
INUSE_ATTRIBUTE_ERR: Raised if newAttr
is already an
- * attribute of another Element
object. The DOM user must
- * explicitly clone Attr
nodes to re-use them in other
- * elements.
- */
- public Attr setAttributeNode(Attr newAttr)
- throws DOMException;
-
- /**
- * Removes the specified attribute node. If the removed Attr
- * has a default value it is immediately replaced. The replacing
- * attribute has the same namespace URI and local name, as well as the
- * original prefix, when applicable.
- * @param oldAttrThe Attr
node to remove from the attribute
- * list.
- * @return The Attr
node that was removed.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- *
NOT_FOUND_ERR: Raised if oldAttr
is not an attribute
- * of the element.
- */
- public Attr removeAttributeNode(Attr oldAttr)
- throws DOMException;
-
- /**
- * Returns a NodeList
of all descendant Elements
- * with a given tag name, in the order in which they are encountered in
- * a preorder traversal of this Element
tree.
- * @param nameThe name of the tag to match on. The special value "*"
- * matches all tags.
- * @return A list of matching Element
nodes.
- */
- public NodeList getElementsByTagName(String name);
-
- /**
- * Retrieves an attribute value by local name and namespace URI. HTML-only
- * DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the attribute to retrieve.
- * @param localNameThe local name of the attribute to retrieve.
- * @return The Attr
value as a string, or the empty string
- * if that attribute does not have a specified or default value.
- * @since DOM Level 2
- */
- public String getAttributeNS(String namespaceURI,
- String localName);
-
- /**
- * Adds a new attribute. If an attribute with the same local name and
- * namespace URI is already present on the element, its prefix is
- * changed to be the prefix part of the qualifiedName
, and
- * its value is changed to be the value
parameter. This
- * value is a simple string; it is not parsed as it is being set. So any
- * markup (such as syntax to be recognized as an entity reference) is
- * treated as literal text, and needs to be appropriately escaped by the
- * implementation when it is written out. In order to assign an
- * attribute value that contains entity references, the user must create
- * an Attr
node plus any Text
and
- * EntityReference
nodes, build the appropriate subtree,
- * and use setAttributeNodeNS
or
- * setAttributeNode
to assign it as the value of an
- * attribute.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the attribute to create or
- * alter.
- * @param qualifiedNameThe qualified name of the attribute to create or
- * alter.
- * @param valueThe value to set in string form.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified qualified name
- * contains an illegal character.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- *
NAMESPACE_ERR: Raised if the qualifiedName
is
- * malformed, if the qualifiedName
has a prefix and the
- * namespaceURI
is null
, if the
- * qualifiedName
has a prefix that is "xml" and the
- * namespaceURI
is different from "
- * http://www.w3.org/XML/1998/namespace", or if the
- * qualifiedName
is "xmlns" and the
- * namespaceURI
is different from "
- * http://www.w3.org/2000/xmlns/".
- * @since DOM Level 2
- */
- public void setAttributeNS(String namespaceURI,
- String qualifiedName,
- String value)
- throws DOMException;
-
- /**
- * Removes an attribute by local name and namespace URI. If the removed
- * attribute has a default value it is immediately replaced. The
- * replacing attribute has the same namespace URI and local name, as
- * well as the original prefix.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the attribute to remove.
- * @param localNameThe local name of the attribute to remove.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- * @since DOM Level 2
- */
- public void removeAttributeNS(String namespaceURI,
- String localName)
- throws DOMException;
-
- /**
- * Retrieves an Attr
node by local name and namespace URI.
- * HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the attribute to retrieve.
- * @param localNameThe local name of the attribute to retrieve.
- * @return The Attr
node with the specified attribute local
- * name and namespace URI or null
if there is no such
- * attribute.
- * @since DOM Level 2
- */
- public Attr getAttributeNodeNS(String namespaceURI,
- String localName);
-
- /**
- * Adds a new attribute. If an attribute with that local name and that
- * namespace URI is already present in the element, it is replaced by
- * the new one.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param newAttrThe Attr
node to add to the attribute list.
- * @return If the newAttr
attribute replaces an existing
- * attribute with the same local name and namespace URI, the replaced
- * Attr
node is returned, otherwise null
is
- * returned.
- * @exception DOMException
- * WRONG_DOCUMENT_ERR: Raised if newAttr
was created from a
- * different document than the one that created the element.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- *
INUSE_ATTRIBUTE_ERR: Raised if newAttr
is already an
- * attribute of another Element
object. The DOM user must
- * explicitly clone Attr
nodes to re-use them in other
- * elements.
- * @since DOM Level 2
- */
- public Attr setAttributeNodeNS(Attr newAttr)
- throws DOMException;
-
- /**
- * Returns a NodeList
of all the descendant
- * Elements
with a given local name and namespace URI in
- * the order in which they are encountered in a preorder traversal of
- * this Element
tree.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the elements to match on. The
- * special value "*" matches all namespaces.
- * @param localNameThe local name of the elements to match on. The
- * special value "*" matches all local names.
- * @return A new NodeList
object containing all the matched
- * Elements
.
- * @since DOM Level 2
- */
- public NodeList getElementsByTagNameNS(String namespaceURI,
- String localName);
-
- /**
- * Returns true
when an attribute with a given name is
- * specified on this element or has a default value, false
- * otherwise.
- * @param nameThe name of the attribute to look for.
- * @return true
if an attribute with the given name is
- * specified on this element or has a default value, false
- * otherwise.
- * @since DOM Level 2
- */
- public boolean hasAttribute(String name);
-
- /**
- * Returns true
when an attribute with a given local name and
- * namespace URI is specified on this element or has a default value,
- * false
otherwise. HTML-only DOM implementations do not
- * need to implement this method.
- * @param namespaceURIThe namespace URI of the attribute to look for.
- * @param localNameThe local name of the attribute to look for.
- * @return true
if an attribute with the given local name
- * and namespace URI is specified or has a default value on this
- * element, false
otherwise.
- * @since DOM Level 2
- */
- public boolean hasAttributeNS(String namespaceURI,
- String localName);
-
-}
diff --git a/libjava/org/w3c/dom/Entity.java b/libjava/org/w3c/dom/Entity.java
deleted file mode 100644
index 51a69cb..0000000
--- a/libjava/org/w3c/dom/Entity.java
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * This interface represents an entity, either parsed or unparsed, in an XML
- * document. Note that this models the entity itself not the entity
- * declaration. Entity
declaration modeling has been left for a
- * later Level of the DOM specification.
- * nodeName
attribute that is inherited from
- * Node
contains the name of the entity.
- * EntityReference
nodes in the document tree.
- * Entity
- * node's child list represents the structure of that replacement text.
- * Otherwise, the child list is empty.
- * Entity
nodes; if a
- * user wants to make changes to the contents of an Entity
,
- * every related EntityReference
node has to be replaced in the
- * structure model by a clone of the Entity
's contents, and
- * then the desired changes must be made to each of those clones instead.
- * Entity
nodes and all their descendants are readonly.
- * Entity
node does not have any parent.If the entity
- * contains an unbound namespace prefix, the namespaceURI
of
- * the corresponding node in the Entity
node subtree is
- * null
. The same is true for EntityReference
- * nodes that refer to this entity, when they are created using the
- * createEntityReference
method of the Document
- * interface. The DOM Level 2 does not support any mechanism to resolve
- * namespace prefixes.
- * null
.
- */
- public String getPublicId();
-
- /**
- * The system identifier associated with the entity, if specified. If the
- * system identifier was not specified, this is null
.
- */
- public String getSystemId();
-
- /**
- * For unparsed entities, the name of the notation for the entity. For
- * parsed entities, this is null
.
- */
- public String getNotationName();
-
-}
diff --git a/libjava/org/w3c/dom/EntityReference.java b/libjava/org/w3c/dom/EntityReference.java
deleted file mode 100644
index 31c854d..0000000
--- a/libjava/org/w3c/dom/EntityReference.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * EntityReference
objects may be inserted into the structure
- * model when an entity reference is in the source document, or when the
- * user wishes to insert an entity reference. Note that character references
- * and references to predefined entities are considered to be expanded by
- * the HTML or XML processor so that characters are represented by their
- * Unicode equivalent rather than by an entity reference. Moreover, the XML
- * processor may completely expand references to entities while building the
- * structure model, instead of providing EntityReference
- * objects. If it does provide such objects, then for a given
- * EntityReference
node, it may be that there is no
- * Entity
node representing the referenced entity. If such an
- * Entity
exists, then the subtree of the
- * EntityReference
node is in general a copy of the
- * Entity
node subtree. However, this may not be true when an
- * entity contains an unbound namespace prefix. In such a case, because the
- * namespace prefix resolution depends on where the entity reference is, the
- * descendants of the EntityReference
node may be bound to
- * different namespace URIs.
- * Entity
nodes, EntityReference
nodes and
- * all their descendants are readonly.
- * NamedNodeMap
interface are used to
- * represent collections of nodes that can be accessed by name. Note that
- * NamedNodeMap
does not inherit from NodeList
;
- * NamedNodeMaps
are not maintained in any particular order.
- * Objects contained in an object implementing NamedNodeMap
may
- * also be accessed by an ordinal index, but this is simply to allow
- * convenient enumeration of the contents of a NamedNodeMap
,
- * and does not imply that the DOM specifies an order to these Nodes.
- * NamedNodeMap
objects in the DOM are live.
- * nodeName
of a node to retrieve.
- * @return A Node
(of any type) with the specified
- * nodeName
, or null
if it does not identify
- * any node in this map.
- */
- public Node getNamedItem(String name);
-
- /**
- * Adds a node using its nodeName
attribute. If a node with
- * that name is already present in this map, it is replaced by the new
- * one.
- *
As the nodeName
attribute is used to derive the name
- * which the node must be stored under, multiple nodes of certain types
- * (those that have a "special" string value) cannot be stored as the
- * names would clash. This is seen as preferable to allowing nodes to be
- * aliased.
- * @param argA node to store in this map. The node will later be
- * accessible using the value of its nodeName
attribute.
- * @return If the new Node
replaces an existing node the
- * replaced Node
is returned, otherwise null
- * is returned.
- * @exception DOMException
- * WRONG_DOCUMENT_ERR: Raised if arg
was created from a
- * different document than the one that created this map.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.
- *
INUSE_ATTRIBUTE_ERR: Raised if arg
is an
- * Attr
that is already an attribute of another
- * Element
object. The DOM user must explicitly clone
- * Attr
nodes to re-use them in other elements.
- */
- public Node setNamedItem(Node arg)
- throws DOMException;
-
- /**
- * Removes a node specified by name. When this map contains the attributes
- * attached to an element, if the removed attribute is known to have a
- * default value, an attribute immediately appears containing the
- * default value as well as the corresponding namespace URI, local name,
- * and prefix when applicable.
- * @param nameThe nodeName
of the node to remove.
- * @return The node removed from this map if a node with such a name
- * exists.
- * @exception DOMException
- * NOT_FOUND_ERR: Raised if there is no node named name
in
- * this map.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.
- */
- public Node removeNamedItem(String name)
- throws DOMException;
-
- /**
- * Returns the index
th item in the map. If index
- * is greater than or equal to the number of nodes in this map, this
- * returns null
.
- * @param indexIndex into this map.
- * @return The node at the index
th position in the map, or
- * null
if that is not a valid index.
- */
- public Node item(int index);
-
- /**
- * The number of nodes in this map. The range of valid child node indices
- * is 0
to length-1
inclusive.
- */
- public int getLength();
-
- /**
- * Retrieves a node specified by local name and namespace URI. HTML-only
- * DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the node to retrieve.
- * @param localNameThe local name of the node to retrieve.
- * @return A Node
(of any type) with the specified local
- * name and namespace URI, or null
if they do not
- * identify any node in this map.
- * @since DOM Level 2
- */
- public Node getNamedItemNS(String namespaceURI,
- String localName);
-
- /**
- * Adds a node using its namespaceURI
and
- * localName
. If a node with that namespace URI and that
- * local name is already present in this map, it is replaced by the new
- * one.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param argA node to store in this map. The node will later be
- * accessible using the value of its namespaceURI
and
- * localName
attributes.
- * @return If the new Node
replaces an existing node the
- * replaced Node
is returned, otherwise null
- * is returned.
- * @exception DOMException
- * WRONG_DOCUMENT_ERR: Raised if arg
was created from a
- * different document than the one that created this map.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.
- *
INUSE_ATTRIBUTE_ERR: Raised if arg
is an
- * Attr
that is already an attribute of another
- * Element
object. The DOM user must explicitly clone
- * Attr
nodes to re-use them in other elements.
- * @since DOM Level 2
- */
- public Node setNamedItemNS(Node arg)
- throws DOMException;
-
- /**
- * Removes a node specified by local name and namespace URI. A removed
- * attribute may be known to have a default value when this map contains
- * the attributes attached to an element, as returned by the attributes
- * attribute of the Node
interface. If so, an attribute
- * immediately appears containing the default value as well as the
- * corresponding namespace URI, local name, and prefix when applicable.
- *
HTML-only DOM implementations do not need to implement this method.
- * @param namespaceURIThe namespace URI of the node to remove.
- * @param localNameThe local name of the node to remove.
- * @return The node removed from this map if a node with such a local
- * name and namespace URI exists.
- * @exception DOMException
- * NOT_FOUND_ERR: Raised if there is no node with the specified
- * namespaceURI
and localName
in this map.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.
- * @since DOM Level 2
- */
- public Node removeNamedItemNS(String namespaceURI,
- String localName)
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/Node.java b/libjava/org/w3c/dom/Node.java
deleted file mode 100644
index ef650a2..0000000
--- a/libjava/org/w3c/dom/Node.java
+++ /dev/null
@@ -1,390 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The Node
interface is the primary datatype for the entire
- * Document Object Model. It represents a single node in the document tree.
- * While all objects implementing the Node
interface expose
- * methods for dealing with children, not all objects implementing the
- * Node
interface may have children. For example,
- * Text
nodes may not have children, and adding children to
- * such nodes results in a DOMException
being raised.
- * nodeName
, nodeValue
and
- * attributes
are included as a mechanism to get at node
- * information without casting down to the specific derived interface. In
- * cases where there is no obvious mapping of these attributes for a
- * specific nodeType
(e.g., nodeValue
for an
- * Element
or attributes
for a Comment
- * ), this returns null
. Note that the specialized interfaces
- * may contain additional and more convenient mechanisms to get and set the
- * relevant information.
- * Element
.
- */
- public static final short ELEMENT_NODE = 1;
- /**
- * The node is an Attr
.
- */
- public static final short ATTRIBUTE_NODE = 2;
- /**
- * The node is a Text
node.
- */
- public static final short TEXT_NODE = 3;
- /**
- * The node is a CDATASection
.
- */
- public static final short CDATA_SECTION_NODE = 4;
- /**
- * The node is an EntityReference
.
- */
- public static final short ENTITY_REFERENCE_NODE = 5;
- /**
- * The node is an Entity
.
- */
- public static final short ENTITY_NODE = 6;
- /**
- * The node is a ProcessingInstruction
.
- */
- public static final short PROCESSING_INSTRUCTION_NODE = 7;
- /**
- * The node is a Comment
.
- */
- public static final short COMMENT_NODE = 8;
- /**
- * The node is a Document
.
- */
- public static final short DOCUMENT_NODE = 9;
- /**
- * The node is a DocumentType
.
- */
- public static final short DOCUMENT_TYPE_NODE = 10;
- /**
- * The node is a DocumentFragment
.
- */
- public static final short DOCUMENT_FRAGMENT_NODE = 11;
- /**
- * The node is a Notation
.
- */
- public static final short NOTATION_NODE = 12;
-
- /**
- * The name of this node, depending on its type; see the table above.
- */
- public String getNodeName();
-
- /**
- * The value of this node, depending on its type; see the table above.
- * When it is defined to be null
, setting it has no effect.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
- * @exception DOMException
- * DOMSTRING_SIZE_ERR: Raised when it would return more characters than
- * fit in a DOMString
variable on the implementation
- * platform.
- */
- public String getNodeValue()
- throws DOMException;
- public void setNodeValue(String nodeValue)
- throws DOMException;
-
- /**
- * A code representing the type of the underlying object, as defined above.
- */
- public short getNodeType();
-
- /**
- * The parent of this node. All nodes, except Attr
,
- * Document
, DocumentFragment
,
- * Entity
, and Notation
may have a parent.
- * However, if a node has just been created and not yet added to the
- * tree, or if it has been removed from the tree, this is
- * null
.
- */
- public Node getParentNode();
-
- /**
- * A NodeList
that contains all children of this node. If
- * there are no children, this is a NodeList
containing no
- * nodes.
- */
- public NodeList getChildNodes();
-
- /**
- * The first child of this node. If there is no such node, this returns
- * null
.
- */
- public Node getFirstChild();
-
- /**
- * The last child of this node. If there is no such node, this returns
- * null
.
- */
- public Node getLastChild();
-
- /**
- * The node immediately preceding this node. If there is no such node,
- * this returns null
.
- */
- public Node getPreviousSibling();
-
- /**
- * The node immediately following this node. If there is no such node,
- * this returns null
.
- */
- public Node getNextSibling();
-
- /**
- * A NamedNodeMap
containing the attributes of this node (if
- * it is an Element
) or null
otherwise.
- */
- public NamedNodeMap getAttributes();
-
- /**
- * The Document
object associated with this node. This is
- * also the Document
object used to create new nodes. When
- * this node is a Document
or a DocumentType
- * which is not used with any Document
yet, this is
- * null
.
- * @version DOM Level 2
- */
- public Document getOwnerDocument();
-
- /**
- * Inserts the node newChild
before the existing child node
- * refChild
. If refChild
is null
,
- * insert newChild
at the end of the list of children.
- *
If newChild
is a DocumentFragment
object,
- * all of its children are inserted, in the same order, before
- * refChild
. If the newChild
is already in the
- * tree, it is first removed.
- * @param newChildThe node to insert.
- * @param refChildThe reference node, i.e., the node before which the new
- * node must be inserted.
- * @return The node being inserted.
- * @exception DOMException
- * HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
- * allow children of the type of the newChild
node, or if
- * the node to insert is one of this node's ancestors.
- *
WRONG_DOCUMENT_ERR: Raised if newChild
was created
- * from a different document than the one that created this node.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or
- * if the parent of the node being inserted is readonly.
- *
NOT_FOUND_ERR: Raised if refChild
is not a child of
- * this node.
- */
- public Node insertBefore(Node newChild,
- Node refChild)
- throws DOMException;
-
- /**
- * Replaces the child node oldChild
with newChild
- * in the list of children, and returns the oldChild
node.
- *
If newChild
is a DocumentFragment
object,
- * oldChild
is replaced by all of the
- * DocumentFragment
children, which are inserted in the
- * same order. If the newChild
is already in the tree, it
- * is first removed.
- * @param newChildThe new node to put in the child list.
- * @param oldChildThe node being replaced in the list.
- * @return The node replaced.
- * @exception DOMException
- * HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
- * allow children of the type of the newChild
node, or if
- * the node to put in is one of this node's ancestors.
- *
WRONG_DOCUMENT_ERR: Raised if newChild
was created
- * from a different document than the one that created this node.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of
- * the new node is readonly.
- *
NOT_FOUND_ERR: Raised if oldChild
is not a child of
- * this node.
- */
- public Node replaceChild(Node newChild,
- Node oldChild)
- throws DOMException;
-
- /**
- * Removes the child node indicated by oldChild
from the list
- * of children, and returns it.
- * @param oldChildThe node being removed.
- * @return The node removed.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- *
NOT_FOUND_ERR: Raised if oldChild
is not a child of
- * this node.
- */
- public Node removeChild(Node oldChild)
- throws DOMException;
-
- /**
- * Adds the node newChild
to the end of the list of children
- * of this node. If the newChild
is already in the tree, it
- * is first removed.
- * @param newChildThe node to add.If it is a DocumentFragment
- * object, the entire contents of the document fragment are moved
- * into the child list of this node
- * @return The node added.
- * @exception DOMException
- * HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not
- * allow children of the type of the newChild
node, or if
- * the node to append is one of this node's ancestors.
- *
WRONG_DOCUMENT_ERR: Raised if newChild
was created
- * from a different document than the one that created this node.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public Node appendChild(Node newChild)
- throws DOMException;
-
- /**
- * Returns whether this node has any children.
- * @return true
if this node has any children,
- * false
otherwise.
- */
- public boolean hasChildNodes();
-
- /**
- * Returns a duplicate of this node, i.e., serves as a generic copy
- * constructor for nodes. The duplicate node has no parent; (
- * parentNode
is null
.).
- *
Cloning an Element
copies all attributes and their
- * values, including those generated by the XML processor to represent
- * defaulted attributes, but this method does not copy any text it
- * contains unless it is a deep clone, since the text is contained in a
- * child Text
node. Cloning an Attribute
- * directly, as opposed to be cloned as part of an Element
- * cloning operation, returns a specified attribute (
- * specified
is true
). Cloning any other type
- * of node simply returns a copy of this node.
- *
Note that cloning an immutable subtree results in a mutable copy,
- * but the children of an EntityReference
clone are readonly
- * . In addition, clones of unspecified Attr
nodes are
- * specified. And, cloning Document
,
- * DocumentType
, Entity
, and
- * Notation
nodes is implementation dependent.
- * @param deepIf true
, recursively clone the subtree under
- * the specified node; if false
, clone only the node
- * itself (and its attributes, if it is an Element
).
- * @return The duplicate node.
- */
- public Node cloneNode(boolean deep);
-
- /**
- * Puts all Text
nodes in the full depth of the sub-tree
- * underneath this Node
, including attribute nodes, into a
- * "normal" form where only structure (e.g., elements, comments,
- * processing instructions, CDATA sections, and entity references)
- * separates Text
nodes, i.e., there are neither adjacent
- * Text
nodes nor empty Text
nodes. This can
- * be used to ensure that the DOM view of a document is the same as if
- * it were saved and re-loaded, and is useful when operations (such as
- * XPointer lookups) that depend on a particular document tree
- * structure are to be used.In cases where the document contains
- * CDATASections
, the normalize operation alone may not be
- * sufficient, since XPointers do not differentiate between
- * Text
nodes and CDATASection
nodes.
- * @version DOM Level 2
- */
- public void normalize();
-
- /**
- * Tests whether the DOM implementation implements a specific feature and
- * that feature is supported by this node.
- * @param featureThe name of the feature to test. This is the same name
- * which can be passed to the method hasFeature
on
- * DOMImplementation
.
- * @param versionThis is the version number of the feature to test. In
- * Level 2, version 1, this is the string "2.0". If the version is not
- * specified, supporting any version of the feature will cause the
- * method to return true
.
- * @return Returns true
if the specified feature is
- * supported on this node, false
otherwise.
- * @since DOM Level 2
- */
- public boolean isSupported(String feature,
- String version);
-
- /**
- * The namespace URI of this node, or null
if it is
- * unspecified.
- *
This is not a computed value that is the result of a namespace
- * lookup based on an examination of the namespace declarations in
- * scope. It is merely the namespace URI given at creation time.
- *
For nodes of any type other than ELEMENT_NODE
and
- * ATTRIBUTE_NODE
and nodes created with a DOM Level 1
- * method, such as createElement
from the
- * Document
interface, this is always null
.Per
- * the Namespaces in XML Specification an attribute does not inherit
- * its namespace from the element it is attached to. If an attribute is
- * not explicitly given a namespace, it simply has no namespace.
- * @since DOM Level 2
- */
- public String getNamespaceURI();
-
- /**
- * The namespace prefix of this node, or null
if it is
- * unspecified.
- *
Note that setting this attribute, when permitted, changes the
- * nodeName
attribute, which holds the qualified name, as
- * well as the tagName
and name
attributes of
- * the Element
and Attr
interfaces, when
- * applicable.
- *
Note also that changing the prefix of an attribute that is known to
- * have a default value, does not make a new attribute with the default
- * value and the original prefix appear, since the
- * namespaceURI
and localName
do not change.
- *
For nodes of any type other than ELEMENT_NODE
and
- * ATTRIBUTE_NODE
and nodes created with a DOM Level 1
- * method, such as createElement
from the
- * Document
interface, this is always null
.
- * @exception DOMException
- * INVALID_CHARACTER_ERR: Raised if the specified prefix contains an
- * illegal character.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- *
NAMESPACE_ERR: Raised if the specified prefix
is
- * malformed, if the namespaceURI
of this node is
- * null
, if the specified prefix is "xml" and the
- * namespaceURI
of this node is different from "
- * http://www.w3.org/XML/1998/namespace", if this node is an attribute
- * and the specified prefix is "xmlns" and the
- * namespaceURI
of this node is different from "
- * http://www.w3.org/2000/xmlns/", or if this node is an attribute and
- * the qualifiedName
of this node is "xmlns" .
- * @since DOM Level 2
- */
- public String getPrefix();
- public void setPrefix(String prefix)
- throws DOMException;
-
- /**
- * Returns the local part of the qualified name of this node.
- *
For nodes of any type other than ELEMENT_NODE
and
- * ATTRIBUTE_NODE
and nodes created with a DOM Level 1
- * method, such as createElement
from the
- * Document
interface, this is always null
.
- * @since DOM Level 2
- */
- public String getLocalName();
-
- /**
- * Returns whether this node (if it is an element) has any attributes.
- * @return true
if this node has any attributes,
- * false
otherwise.
- * @since DOM Level 2
- */
- public boolean hasAttributes();
-
-}
diff --git a/libjava/org/w3c/dom/NodeList.java b/libjava/org/w3c/dom/NodeList.java
deleted file mode 100644
index f4033f3..0000000
--- a/libjava/org/w3c/dom/NodeList.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The NodeList
interface provides the abstraction of an ordered
- * collection of nodes, without defining or constraining how this collection
- * is implemented. NodeList
objects in the DOM are live.
- * NodeList
are accessible via an integral
- * index, starting from 0.
- * index
th item in the collection. If
- * index
is greater than or equal to the number of nodes in
- * the list, this returns null
.
- * @param indexIndex into the collection.
- * @return The node at the index
th position in the
- * NodeList
, or null
if that is not a valid
- * index.
- */
- public Node item(int index);
-
- /**
- * The number of nodes in the list. The range of valid child node indices
- * is 0 to length-1
inclusive.
- */
- public int getLength();
-
-}
diff --git a/libjava/org/w3c/dom/Notation.java b/libjava/org/w3c/dom/Notation.java
deleted file mode 100644
index 284e015..0000000
--- a/libjava/org/w3c/dom/Notation.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * This interface represents a notation declared in the DTD. A notation either
- * declares, by name, the format of an unparsed entity (see section 4.7 of
- * the XML 1.0 specification ), or is used for formal declaration of
- * processing instruction targets (see section 2.6 of the XML 1.0
- * specification ). The nodeName
attribute inherited from
- * Node
is set to the declared name of the notation.
- * Notation
nodes;
- * they are therefore readonly.
- * Notation
node does not have any parent.
- * null
.
- */
- public String getPublicId();
-
- /**
- * The system identifier of this notation. If the system identifier was
- * not specified, this is null
.
- */
- public String getSystemId();
-
-}
diff --git a/libjava/org/w3c/dom/ProcessingInstruction.java b/libjava/org/w3c/dom/ProcessingInstruction.java
deleted file mode 100644
index e3cfd1b..0000000
--- a/libjava/org/w3c/dom/ProcessingInstruction.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The ProcessingInstruction
interface represents a "processing
- * instruction", used in XML as a way to keep processor-specific information
- * in the text of the document.
- * ?>
.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
- */
- public String getData();
- public void setData(String data)
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/Text.java b/libjava/org/w3c/dom/Text.java
deleted file mode 100644
index c7c9971..0000000
--- a/libjava/org/w3c/dom/Text.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom;
-
-/**
- * The Text
interface inherits from CharacterData
- * and represents the textual content (termed character data in XML) of an
- * Element
or Attr
. If there is no markup inside
- * an element's content, the text is contained in a single object
- * implementing the Text
interface that is the only child of
- * the element. If there is markup, it is parsed into the information items
- * (elements, comments, etc.) and Text
nodes that form the list
- * of children of the element.
- * Text
node for each block of text. Users may create adjacent
- * Text
nodes that represent the contents of a given element
- * without any intervening markup, but should be aware that there is no way
- * to represent the separations between these nodes in XML or HTML, so they
- * will not (in general) persist between DOM editing sessions. The
- * normalize()
method on Node
merges any such
- * adjacent Text
objects into a single node for each block of
- * text.
- * offset
,
- * keeping both in the tree as siblings. After being split, this node
- * will contain all the content up to the offset
point. A
- * new node of the same type, which contains all the content at and
- * after the offset
point, is returned. If the original
- * node had a parent node, the new node is inserted as the next sibling
- * of the original node. When the offset
is equal to the
- * length of this node, the new node has no data.
- * @param offsetThe 16-bit unit offset at which to split, starting from
- * 0
.
- * @return The new node, of the same type as this node.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if the specified offset is negative or greater
- * than the number of 16-bit units in data
.
- *
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
- */
- public Text splitText(int offset)
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/ranges/DocumentRange.java b/libjava/org/w3c/dom/ranges/DocumentRange.java
deleted file mode 100644
index f9b764f..0000000
--- a/libjava/org/w3c/dom/ranges/DocumentRange.java
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.ranges;
-
-/**
- * Document
interface using binding-specific casting
- * methods.
- * @return The initial state of the Range returned from this method is
- * such that both of its boundary-points are positioned at the
- * beginning of the corresponding Document, before any content. The
- * Range returned can only be used to select content associated with
- * this Document, or with DocumentFragments and Attrs for which this
- * Document is the ownerDocument
.
- */
- public Range createRange();
-
-}
diff --git a/libjava/org/w3c/dom/ranges/Range.java b/libjava/org/w3c/dom/ranges/Range.java
deleted file mode 100644
index f4c3608..0000000
--- a/libjava/org/w3c/dom/ranges/Range.java
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.ranges;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.DocumentFragment;
-import org.w3c.dom.DOMException;
-
-/**
- * detach()
has already been
- * invoked on this object.
- */
- public Node getStartContainer()
- throws DOMException;
-
- /**
- * Offset within the starting node of the Range.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public int getStartOffset()
- throws DOMException;
-
- /**
- * Node within which the Range ends
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public Node getEndContainer()
- throws DOMException;
-
- /**
- * Offset within the ending node of the Range.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public int getEndOffset()
- throws DOMException;
-
- /**
- * TRUE if the Range is collapsed
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public boolean getCollapsed()
- throws DOMException;
-
- /**
- * The deepest common ancestor container of the Range's two
- * boundary-points.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public Node getCommonAncestorContainer()
- throws DOMException;
-
- /**
- * Sets the attributes describing the start of the Range.
- * @param refNodeThe refNode
value. This parameter must be
- * different from null
.
- * @param offsetThe startOffset
value.
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if refNode
or an ancestor
- * of refNode
is an Entity, Notation, or DocumentType
- * node.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if offset
is negative or greater
- * than the number of child units in refNode
. Child units
- * are 16-bit units if refNode
is a type of CharacterData
- * node (e.g., a Text or Comment node) or a ProcessingInstruction
- * node. Child units are Nodes in all other cases.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- */
- public void setStart(Node refNode,
- int offset)
- throws RangeException, DOMException;
-
- /**
- * Sets the attributes describing the end of a Range.
- * @param refNodeThe refNode
value. This parameter must be
- * different from null
.
- * @param offsetThe endOffset
value.
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if refNode
or an ancestor
- * of refNode
is an Entity, Notation, or DocumentType
- * node.
- * @exception DOMException
- * INDEX_SIZE_ERR: Raised if offset
is negative or greater
- * than the number of child units in refNode
. Child units
- * are 16-bit units if refNode
is a type of CharacterData
- * node (e.g., a Text or Comment node) or a ProcessingInstruction
- * node. Child units are Nodes in all other cases.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- */
- public void setEnd(Node refNode,
- int offset)
- throws RangeException, DOMException;
-
- /**
- * Sets the start position to be before a node
- * @param refNodeRange starts before refNode
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if the root container of
- * refNode
is not an Attr, Document, or DocumentFragment
- * node or if refNode
is a Document, DocumentFragment,
- * Attr, Entity, or Notation node.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void setStartBefore(Node refNode)
- throws RangeException, DOMException;
-
- /**
- * Sets the start position to be after a node
- * @param refNodeRange starts after refNode
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if the root container of
- * refNode
is not an Attr, Document, or DocumentFragment
- * node or if refNode
is a Document, DocumentFragment,
- * Attr, Entity, or Notation node.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void setStartAfter(Node refNode)
- throws RangeException, DOMException;
-
- /**
- * Sets the end position to be before a node.
- * @param refNodeRange ends before refNode
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if the root container of
- * refNode
is not an Attr, Document, or DocumentFragment
- * node or if refNode
is a Document, DocumentFragment,
- * Attr, Entity, or Notation node.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void setEndBefore(Node refNode)
- throws RangeException, DOMException;
-
- /**
- * Sets the end of a Range to be after a node
- * @param refNodeRange ends after refNode
.
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if the root container of
- * refNode
is not an Attr, Document or DocumentFragment
- * node or if refNode
is a Document, DocumentFragment,
- * Attr, Entity, or Notation node.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void setEndAfter(Node refNode)
- throws RangeException, DOMException;
-
- /**
- * Collapse a Range onto one of its boundary-points
- * @param toStartIf TRUE, collapses the Range onto its start; if FALSE,
- * collapses it onto its end.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void collapse(boolean toStart)
- throws DOMException;
-
- /**
- * Select a node and its contents
- * @param refNodeThe node to select.
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if an ancestor of refNode
- * is an Entity, Notation or DocumentType node or if
- * refNode
is a Document, DocumentFragment, Attr, Entity,
- * or Notation node.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void selectNode(Node refNode)
- throws RangeException, DOMException;
-
- /**
- * Select the contents within a node
- * @param refNodeNode to select from
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if refNode
or an ancestor
- * of refNode
is an Entity, Notation or DocumentType node.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void selectNodeContents(Node refNode)
- throws RangeException, DOMException;
-
- // CompareHow
- /**
- * Compare start boundary-point of sourceRange
to start
- * boundary-point of Range on which compareBoundaryPoints
- * is invoked.
- */
- public static final short START_TO_START = 0;
- /**
- * Compare start boundary-point of sourceRange
to end
- * boundary-point of Range on which compareBoundaryPoints
- * is invoked.
- */
- public static final short START_TO_END = 1;
- /**
- * Compare end boundary-point of sourceRange
to end
- * boundary-point of Range on which compareBoundaryPoints
- * is invoked.
- */
- public static final short END_TO_END = 2;
- /**
- * Compare end boundary-point of sourceRange
to start
- * boundary-point of Range on which compareBoundaryPoints
- * is invoked.
- */
- public static final short END_TO_START = 3;
-
- /**
- * Compare the boundary-points of two Ranges in a document.
- * @param howA code representing the type of comparison, as defined above.
- * @param sourceRangeThe Range
on which this current
- * Range
is compared to.
- * @return -1, 0 or 1 depending on whether the corresponding
- * boundary-point of the Range is respectively before, equal to, or
- * after the corresponding boundary-point of sourceRange
.
- * @exception DOMException
- * WRONG_DOCUMENT_ERR: Raised if the two Ranges are not in the same
- * Document or DocumentFragment.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- */
- public short compareBoundaryPoints(short how,
- Range sourceRange)
- throws DOMException;
-
- /**
- * Removes the contents of a Range from the containing document or
- * document fragment without returning a reference to the removed
- * content.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if any portion of the content of
- * the Range is read-only or any of the nodes that contain any of the
- * content of the Range are read-only.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- */
- public void deleteContents()
- throws DOMException;
-
- /**
- * Moves the contents of a Range from the containing document or document
- * fragment to a new DocumentFragment.
- * @return A DocumentFragment containing the extracted contents.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if any portion of the content of
- * the Range is read-only or any of the nodes which contain any of the
- * content of the Range are read-only.
- *
HIERARCHY_REQUEST_ERR: Raised if a DocumentType node would be
- * extracted into the new DocumentFragment.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- */
- public DocumentFragment extractContents()
- throws DOMException;
-
- /**
- * Duplicates the contents of a Range
- * @return A DocumentFragment that contains content equivalent to this
- * Range.
- * @exception DOMException
- * HIERARCHY_REQUEST_ERR: Raised if a DocumentType node would be
- * extracted into the new DocumentFragment.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- */
- public DocumentFragment cloneContents()
- throws DOMException;
-
- /**
- * Inserts a node into the Document or DocumentFragment at the start of
- * the Range. If the container is a Text node, this will be split at the
- * start of the Range (as if the Text node's splitText method was
- * performed at the insertion point) and the insertion will occur
- * between the two resulting Text nodes. Adjacent Text nodes will not be
- * automatically merged. If the node to be inserted is a
- * DocumentFragment node, the children will be inserted rather than the
- * DocumentFragment node itself.
- * @param newNodeThe node to insert at the start of the Range
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if an ancestor container of the
- * start of the Range is read-only.
- *
WRONG_DOCUMENT_ERR: Raised if newNode
and the
- * container of the start of the Range were not created from the same
- * document.
- *
HIERARCHY_REQUEST_ERR: Raised if the container of the start of
- * the Range is of a type that does not allow children of the type of
- * newNode
or if newNode
is an ancestor of
- * the container.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- * @exception RangeException
- * INVALID_NODE_TYPE_ERR: Raised if newNode
is an Attr,
- * Entity, Notation, or Document node.
- */
- public void insertNode(Node newNode)
- throws DOMException, RangeException;
-
- /**
- * Reparents the contents of the Range to the given node and inserts the
- * node at the position of the start of the Range.
- * @param newParentThe node to surround the contents with.
- * @exception DOMException
- * NO_MODIFICATION_ALLOWED_ERR: Raised if an ancestor container of
- * either boundary-point of the Range is read-only.
- *
WRONG_DOCUMENT_ERR: Raised if newParent
and the
- * container of the start of the Range were not created from the same
- * document.
- *
HIERARCHY_REQUEST_ERR: Raised if the container of the start of
- * the Range is of a type that does not allow children of the type of
- * newParent
or if newParent
is an ancestor
- * of the container or if node
would end up with a child
- * node of a type not allowed by the type of node
.
- *
INVALID_STATE_ERR: Raised if detach()
has already
- * been invoked on this object.
- * @exception RangeException
- * BAD_BOUNDARYPOINTS_ERR: Raised if the Range partially selects a
- * non-text node.
- *
INVALID_NODE_TYPE_ERR: Raised if node
is an Attr,
- * Entity, DocumentType, Notation, Document, or DocumentFragment node.
- */
- public void surroundContents(Node newParent)
- throws DOMException, RangeException;
-
- /**
- * Produces a new Range whose boundary-points are equal to the
- * boundary-points of the Range.
- * @return The duplicated Range.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public Range cloneRange()
- throws DOMException;
-
- /**
- * Returns the contents of a Range as a string. This string contains only
- * the data characters, not any markup.
- * @return The contents of the Range.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public String toString()
- throws DOMException;
-
- /**
- * Called to indicate that the Range is no longer in use and that the
- * implementation may relinquish any resources associated with this
- * Range. Subsequent calls to any methods or attribute getters on this
- * Range will result in a DOMException
being thrown with an
- * error code of INVALID_STATE_ERR
.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if detach()
has already been
- * invoked on this object.
- */
- public void detach()
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/ranges/RangeException.java b/libjava/org/w3c/dom/ranges/RangeException.java
deleted file mode 100644
index abf9a9f..0000000
--- a/libjava/org/w3c/dom/ranges/RangeException.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.ranges;
-
-/**
- * Range operations may throw a RangeException
as specified in
- * their method descriptions.
- * DocumentTraversal
contains methods that create iterators and
- * tree-walkers to traverse a node and its children in document order (depth
- * first, pre-order traversal, which is equivalent to the order in which the
- * start tags occur in the text representation of the document). In DOMs
- * which support the Traversal feature, DocumentTraversal
will
- * be implemented by the same objects that implement the Document interface.
- * NodeIterator
over the subtree rooted at the
- * specified node.
- * @param rootThe node which will be iterated together with its children.
- * The iterator is initially positioned just before this node. The
- * whatToShow
flags and the filter, if any, are not
- * considered when setting this position. The root must not be
- * null
.
- * @param whatToShowThis flag specifies which node types may appear in
- * the logical view of the tree presented by the iterator. See the
- * description of NodeFilter
for the set of possible
- * SHOW_
values.These flags can be combined using
- * OR
.
- * @param filterThe NodeFilter
to be used with this
- * TreeWalker
, or null
to indicate no filter.
- * @param entityReferenceExpansionThe value of this flag determines
- * whether entity reference nodes are expanded.
- * @return The newly created NodeIterator
.
- * @exception DOMException
- * NOT_SUPPORTED_ERR: Raised if the specified root
is
- * null
.
- */
- public NodeIterator createNodeIterator(Node root,
- int whatToShow,
- NodeFilter filter,
- boolean entityReferenceExpansion)
- throws DOMException;
-
- /**
- * Create a new TreeWalker
over the subtree rooted at the
- * specified node.
- * @param rootThe node which will serve as the root
for the
- * TreeWalker
. The whatToShow
flags and the
- * NodeFilter
are not considered when setting this value;
- * any node type will be accepted as the root
. The
- * currentNode
of the TreeWalker
is
- * initialized to this node, whether or not it is visible. The
- * root
functions as a stopping point for traversal
- * methods that look upward in the document structure, such as
- * parentNode
and nextNode. The root
must
- * not be null
.
- * @param whatToShowThis flag specifies which node types may appear in
- * the logical view of the tree presented by the tree-walker. See the
- * description of NodeFilter
for the set of possible
- * SHOW_ values.These flags can be combined using OR
.
- * @param filterThe NodeFilter
to be used with this
- * TreeWalker
, or null
to indicate no filter.
- * @param entityReferenceExpansionIf this flag is false, the contents of
- * EntityReference
nodes are not presented in the logical
- * view.
- * @return The newly created TreeWalker
.
- * @exception DOMException
- * NOT_SUPPORTED_ERR: Raised if the specified root
is
- * null
.
- */
- public TreeWalker createTreeWalker(Node root,
- int whatToShow,
- NodeFilter filter,
- boolean entityReferenceExpansion)
- throws DOMException;
-
-}
diff --git a/libjava/org/w3c/dom/traversal/NodeFilter.java b/libjava/org/w3c/dom/traversal/NodeFilter.java
deleted file mode 100644
index 8901059..0000000
--- a/libjava/org/w3c/dom/traversal/NodeFilter.java
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.traversal;
-
-import org.w3c.dom.Node;
-
-/**
- * Filters are objects that know how to "filter out" nodes. If a
- * NodeIterator
or TreeWalker
is given a
- * NodeFilter
, it applies the filter before it returns the next
- * node. If the filter says to accept the node, the traversal logic returns
- * it; otherwise, traversal looks for the next node and pretends that the
- * node that was rejected was not there.
- * NodeFilter
is just an
- * interface that users can implement to provide their own filters.
- * NodeFilters
do not need to know how to traverse from node
- * to node, nor do they need to know anything about the data structure that
- * is being traversed. This makes it very easy to write filters, since the
- * only thing they have to know how to do is evaluate a single node. One
- * filter may be used with a number of different kinds of traversals,
- * encouraging code reuse.
- * NodeIterator
or TreeWalker
will return this
- * node.
- */
- public static final short FILTER_ACCEPT = 1;
- /**
- * Reject the node. Navigation methods defined for
- * NodeIterator
or TreeWalker
will not return
- * this node. For TreeWalker
, the children of this node
- * will also be rejected. NodeIterators
treat this as a
- * synonym for FILTER_SKIP
.
- */
- public static final short FILTER_REJECT = 2;
- /**
- * Skip this single node. Navigation methods defined for
- * NodeIterator
or TreeWalker
will not return
- * this node. For both NodeIterator
and
- * TreeWalker
, the children of this node will still be
- * considered.
- */
- public static final short FILTER_SKIP = 3;
-
- // Constants for whatToShow
- /**
- * Show all Nodes
.
- */
- public static final int SHOW_ALL = 0xFFFFFFFF;
- /**
- * Show Element
nodes.
- */
- public static final int SHOW_ELEMENT = 0x00000001;
- /**
- * Show Attr
nodes. This is meaningful only when creating an
- * iterator or tree-walker with an attribute node as its
- * root
; in this case, it means that the attribute node
- * will appear in the first position of the iteration or traversal.
- * Since attributes are never children of other nodes, they do not
- * appear when traversing over the document tree.
- */
- public static final int SHOW_ATTRIBUTE = 0x00000002;
- /**
- * Show Text
nodes.
- */
- public static final int SHOW_TEXT = 0x00000004;
- /**
- * Show CDATASection
nodes.
- */
- public static final int SHOW_CDATA_SECTION = 0x00000008;
- /**
- * Show EntityReference
nodes.
- */
- public static final int SHOW_ENTITY_REFERENCE = 0x00000010;
- /**
- * Show Entity
nodes. This is meaningful only when creating
- * an iterator or tree-walker with an Entity
node as its
- * root
; in this case, it means that the Entity
- * node will appear in the first position of the traversal. Since
- * entities are not part of the document tree, they do not appear when
- * traversing over the document tree.
- */
- public static final int SHOW_ENTITY = 0x00000020;
- /**
- * Show ProcessingInstruction
nodes.
- */
- public static final int SHOW_PROCESSING_INSTRUCTION = 0x00000040;
- /**
- * Show Comment
nodes.
- */
- public static final int SHOW_COMMENT = 0x00000080;
- /**
- * Show Document
nodes.
- */
- public static final int SHOW_DOCUMENT = 0x00000100;
- /**
- * Show DocumentType
nodes.
- */
- public static final int SHOW_DOCUMENT_TYPE = 0x00000200;
- /**
- * Show DocumentFragment
nodes.
- */
- public static final int SHOW_DOCUMENT_FRAGMENT = 0x00000400;
- /**
- * Show Notation
nodes. This is meaningful only when creating
- * an iterator or tree-walker with a Notation
node as its
- * root
; in this case, it means that the
- * Notation
node will appear in the first position of the
- * traversal. Since notations are not part of the document tree, they do
- * not appear when traversing over the document tree.
- */
- public static final int SHOW_NOTATION = 0x00000800;
-
- /**
- * Test whether a specified node is visible in the logical view of a
- * TreeWalker
or NodeIterator
. This function
- * will be called by the implementation of TreeWalker
and
- * NodeIterator
; it is not normally called directly from
- * user code. (Though you could do so if you wanted to use the same
- * filter to guide your own application logic.)
- * @param nThe node to check to see if it passes the filter or not.
- * @return a constant to determine whether the node is accepted,
- * rejected, or skipped, as defined above.
- */
- public short acceptNode(Node n);
-
-}
diff --git a/libjava/org/w3c/dom/traversal/NodeIterator.java b/libjava/org/w3c/dom/traversal/NodeIterator.java
deleted file mode 100644
index 3563e80..0000000
--- a/libjava/org/w3c/dom/traversal/NodeIterator.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.traversal;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.DOMException;
-
-/**
- * Iterators
are used to step through a set of nodes, e.g. the
- * set of nodes in a NodeList
, the document subtree governed by
- * a particular Node
, the results of a query, or any other set
- * of nodes. The set of nodes to be iterated is determined by the
- * implementation of the NodeIterator
. DOM Level 2 specifies a
- * single NodeIterator
implementation for document-order
- * traversal of a document subtree. Instances of these iterators are created
- * by calling DocumentTraversal
- * .createNodeIterator()
.
- * NodeIterator
, as specified when it
- * was created.
- */
- public Node getRoot();
-
- /**
- * This attribute determines which node types are presented via the
- * iterator. The available set of constants is defined in the
- * NodeFilter
interface. Nodes not accepted by
- * whatToShow
will be skipped, but their children may still
- * be considered. Note that this skip takes precedence over the filter,
- * if any.
- */
- public int getWhatToShow();
-
- /**
- * The NodeFilter
used to screen nodes.
- */
- public NodeFilter getFilter();
-
- /**
- * The value of this flag determines whether the children of entity
- * reference nodes are visible to the iterator. If false, they and
- * their descendants will be rejected. Note that this rejection takes
- * precedence over whatToShow
and the filter. Also note
- * that this is currently the only situation where
- * NodeIterators
may reject a complete subtree rather than
- * skipping individual nodes.
- *
- *
To produce a view of the document that has entity references
- * expanded and does not expose the entity reference node itself, use
- * the whatToShow
flags to hide the entity reference node
- * and set expandEntityReferences
to true when creating the
- * iterator. To produce a view of the document that has entity reference
- * nodes but no entity expansion, use the whatToShow
flags
- * to show the entity reference node and set
- * expandEntityReferences
to false.
- */
- public boolean getExpandEntityReferences();
-
- /**
- * Returns the next node in the set and advances the position of the
- * iterator in the set. After a NodeIterator
is created,
- * the first call to nextNode()
returns the first node in
- * the set.
- * @return The next Node
in the set being iterated over, or
- * null
if there are no more members in that set.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if this method is called after the
- * detach
method was invoked.
- */
- public Node nextNode()
- throws DOMException;
-
- /**
- * Returns the previous node in the set and moves the position of the
- * NodeIterator
backwards in the set.
- * @return The previous Node
in the set being iterated over,
- * or null
if there are no more members in that set.
- * @exception DOMException
- * INVALID_STATE_ERR: Raised if this method is called after the
- * detach
method was invoked.
- */
- public Node previousNode()
- throws DOMException;
-
- /**
- * Detaches the NodeIterator
from the set which it iterated
- * over, releasing any computational resources and placing the iterator
- * in the INVALID state. After detach
has been invoked,
- * calls to nextNode
or previousNode
will
- * raise the exception INVALID_STATE_ERR.
- */
- public void detach();
-
-}
diff --git a/libjava/org/w3c/dom/traversal/TreeWalker.java b/libjava/org/w3c/dom/traversal/TreeWalker.java
deleted file mode 100644
index ed02929..0000000
--- a/libjava/org/w3c/dom/traversal/TreeWalker.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright (c) 2000 World Wide Web Consortium,
- * (Massachusetts Institute of Technology, Institut National de
- * Recherche en Informatique et en Automatique, Keio University). All
- * Rights Reserved. This program is distributed under the W3C's Software
- * Intellectual Property License. This program is distributed in the
- * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- * PURPOSE.
- * See W3C License http://www.w3.org/Consortium/Legal/ for more details.
- */
-
-package org.w3c.dom.traversal;
-
-import org.w3c.dom.Node;
-import org.w3c.dom.DOMException;
-
-/**
- * TreeWalker
objects are used to navigate a document tree or
- * subtree using the view of the document defined by their
- * whatToShow
flags and filter (if any). Any function which
- * performs navigation using a TreeWalker
will automatically
- * support any view defined by a TreeWalker
.
- * TreeWalker
view may be children of different, widely
- * separated nodes in the original view. For instance, consider a
- * NodeFilter
that skips all nodes except for Text nodes and
- * the root node of a document. In the logical view that results, all text
- * nodes will be siblings and appear as direct children of the root node, no
- * matter how deeply nested the structure of the original document.
- * root
node of the TreeWalker
, as specified
- * when it was created.
- */
- public Node getRoot();
-
- /**
- * This attribute determines which node types are presented via the
- * TreeWalker
. The available set of constants is defined in
- * the NodeFilter
interface. Nodes not accepted by
- * whatToShow
will be skipped, but their children may still
- * be considered. Note that this skip takes precedence over the filter,
- * if any.
- */
- public int getWhatToShow();
-
- /**
- * The filter used to screen nodes.
- */
- public NodeFilter getFilter();
-
- /**
- * The value of this flag determines whether the children of entity
- * reference nodes are visible to the TreeWalker
. If false,
- * they and their descendants will be rejected. Note that this
- * rejection takes precedence over whatToShow
and the
- * filter, if any.
- *
To produce a view of the document that has entity references
- * expanded and does not expose the entity reference node itself, use
- * the whatToShow
flags to hide the entity reference node
- * and set expandEntityReferences
to true when creating the
- * TreeWalker
. To produce a view of the document that has
- * entity reference nodes but no entity expansion, use the
- * whatToShow
flags to show the entity reference node and
- * set expandEntityReferences
to false.
- */
- public boolean getExpandEntityReferences();
-
- /**
- * The node at which the TreeWalker
is currently positioned.
- *
Alterations to the DOM tree may cause the current node to no longer
- * be accepted by the TreeWalker
's associated filter.
- * currentNode
may also be explicitly set to any node,
- * whether or not it is within the subtree specified by the
- * root
node or would be accepted by the filter and
- * whatToShow
flags. Further traversal occurs relative to
- * currentNode
even if it is not part of the current view,
- * by applying the filters in the requested direction; if no traversal
- * is possible, currentNode
is not changed.
- * @exception DOMException
- * NOT_SUPPORTED_ERR: Raised if an attempt is made to set
- * currentNode
to null
.
- */
- public Node getCurrentNode();
- public void setCurrentNode(Node currentNode)
- throws DOMException;
-
- /**
- * Moves to and returns the closest visible ancestor node of the current
- * node. If the search for parentNode
attempts to step
- * upward from the TreeWalker
's root
node, or
- * if it fails to find a visible ancestor node, this method retains the
- * current position and returns null
.
- * @return The new parent node, or null
if the current node
- * has no parent in the TreeWalker
's logical view.
- */
- public Node parentNode();
-
- /**
- * Moves the TreeWalker
to the first visible child of the
- * current node, and returns the new node. If the current node has no
- * visible children, returns null
, and retains the current
- * node.
- * @return The new node, or null
if the current node has no
- * visible children in the TreeWalker
's logical view.
- */
- public Node firstChild();
-
- /**
- * Moves the TreeWalker
to the last visible child of the
- * current node, and returns the new node. If the current node has no
- * visible children, returns null
, and retains the current
- * node.
- * @return The new node, or null
if the current node has no
- * children in the TreeWalker
's logical view.
- */
- public Node lastChild();
-
- /**
- * Moves the TreeWalker
to the previous sibling of the
- * current node, and returns the new node. If the current node has no
- * visible previous sibling, returns null
, and retains the
- * current node.
- * @return The new node, or null
if the current node has no
- * previous sibling. in the TreeWalker
's logical view.
- */
- public Node previousSibling();
-
- /**
- * Moves the TreeWalker
to the next sibling of the current
- * node, and returns the new node. If the current node has no visible
- * next sibling, returns null
, and retains the current node.
- * @return The new node, or null
if the current node has no
- * next sibling. in the TreeWalker
's logical view.
- */
- public Node nextSibling();
-
- /**
- * Moves the TreeWalker
to the previous visible node in
- * document order relative to the current node, and returns the new
- * node. If the current node has no previous node, or if the search for
- * previousNode
attempts to step upward from the
- * TreeWalker
's root
node, returns
- * null
, and retains the current node.
- * @return The new node, or null
if the current node has no
- * previous node in the TreeWalker
's logical view.
- */
- public Node previousNode();
-
- /**
- * Moves the TreeWalker
to the next visible node in document
- * order relative to the current node, and returns the new node. If the
- * current node has no next node, or if the search for nextNode attempts
- * to step upward from the TreeWalker
's root
- * node, returns null
, and retains the current node.
- * @return The new node, or null
if the current node has no
- * next node in the TreeWalker
's logical view.
- */
- public Node nextNode();
-
-}
diff --git a/libjava/org/xml/sax/AttributeList.java b/libjava/org/xml/sax/AttributeList.java
deleted file mode 100644
index b1a647a..0000000
--- a/libjava/org/xml/sax/AttributeList.java
+++ /dev/null
@@ -1,193 +0,0 @@
-// SAX Attribute List Interface.
-// http://www.saxproject.org
-// No warranty; no copyright -- use this as you will.
-// $Id: AttributeList.java,v 1.3.2.3 2002/01/29 21:34:14 dbrownell Exp $
-
-package org.xml.sax;
-
-/**
- * Interface for an element's attribute specifications.
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * public void startElement (String name, AttributeList atts) {
- * for (int i = 0; i < atts.getLength(); i++) {
- * String name = atts.getName(i);
- * String type = atts.getType(i);
- * String value = atts.getValue(i);
- * [...]
- * }
- * }
- *
- *
- *
- * public void startElement (String name, AttributeList atts) {
- * String identifier = atts.getValue("id");
- * String label = atts.getValue("label");
- * [...]
- * }
- *
- *
- * @deprecated This interface has been replaced by the SAX2
- * {@link org.xml.sax.Attributes Attributes}
- * interface, which includes Namespace support.
- * @since SAX 1.0
- * @author David Megginson
- * @version 2.0.1 (sax2r2)
- * @see org.xml.sax.DocumentHandler#startElement startElement
- * @see org.xml.sax.helpers.AttributeListImpl AttributeListImpl
- */
-public interface AttributeList {
-
-
- ////////////////////////////////////////////////////////////////////
- // Iteration methods.
- ////////////////////////////////////////////////////////////////////
-
-
- /**
- * Return the number of attributes in this list.
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- *
- *
- * http://xml.org/sax/features/namespace-prefixes
- * feature is set to true (it is false by
- * default).
- * Because SAX2 conforms to the "Namespaces in XML" specification,
- * it does not give namespace declaration attributes a namespace URI.
- * Some other W3C specifications are in conflict with that, expecting
- * these declarations to be in a namespace.
- * Handler code may need to resolve that conflict.
- * http://xml.org/sax/features/namespaces
- * feature is false, access by Namespace-qualified names
- * may not be available.
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * import java.net.*;
- * import org.xml.sax.*;
- *
- *
- * http://xml.org/sax/features/namespaces
- * feature is true (the default).
- *
- *
- *
- *
- *
- * http://xml.org/sax/features/namespace-prefixes
- * property is true (it is false by default, and support for a
- * true value is optional).char
value. char
value. There are two important cases where this
- * happens, because characters can't be represented in just sixteen bits.
- * In one case, characters are represented in a Surrogate Pair,
- * using two special Unicode values. Such characters are in the so-called
- * "Astral Planes", with a code point above U+FFFF. A second case involves
- * composite characters, such as a base character combining with one or
- * more accent characters. char
-at-a-time idioms will be working in character
- * units; in some cases they will split characters. This is relevant
- * wherever XML permits arbitrary characters, such as attribute values,
- * processing instruction data, and comments as well as in data reported
- * from this method. It's also generally relevant whenever Java code
- * manipulates internationalized text; the issue isn't unique to XML.char
- * value. http://xml.org/sax/features/external-general-entities
- * and the
- * http://xml.org/sax/features/external-parameter-entities
- * properties.
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * import org.xml.sax.EntityResolver;
- * import org.xml.sax.InputSource;
- *
- * public class MyResolver implements EntityResolver {
- * public InputSource resolveEntity (String publicId, String systemId)
- * {
- * if (systemId.equals("http://www.myhost.com/today")) {
- * // return a special input source
- * MyReader reader = new MyReader();
- * return new InputSource(reader);
- * } else {
- * // use the default behaviour
- * return null;
- * }
- * }
- * }
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- * char
values since
- * the last line end.
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * parse(new InputSource(systemId));
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- *
- *
- *
- * XMLReader r = new MySAXDriver();
- *
- * // try to activate validation
- * try {
- * r.setFeature("http://xml.org/sax/features/validation", true);
- * } catch (SAXException e) {
- * System.err.println("Cannot activate validation.");
- * }
- *
- * // register event handlers
- * r.setContentHandler(new MyContentHandler());
- * r.setErrorHandler(new MyErrorHandler());
- *
- * // parse the first document
- * try {
- * r.parse("http://www.foo.com/mydoc.xml");
- * } catch (IOException e) {
- * System.err.println("I/O exception reading XML document");
- * } catch (SAXException e) {
- * System.err.println("XML exception reading document.");
- * }
- *
- *
- *
- * parse(new InputSource(systemId));
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- * http://xml.org/sax/properties/declaration-handler
- * and an object implementing this interface (or null) as the value.
- * If the reader does not report declaration events, it will throw a
- * {@link org.xml.sax.SAXNotRecognizedException SAXNotRecognizedException}
- * when you attempt to register the handler.
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- * http://xml.org/sax/properties/lexical-handler
- * and an object implementing this interface (or null) as the value.
- * If the reader does not report lexical events, it will throw a
- * {@link org.xml.sax.SAXNotRecognizedException SAXNotRecognizedException}
- * when you attempt to register the handler.http://xml.org/sax/features/lexical-handler/parameter-entities
- * feature to query or control the reporting of parameter entities.
- *
- *
- *
-
-
-
-org.xml.sax.helpers.DefaultHandler
or
-org.xml.sax.helpers.XMLFilterImpl
classes.
-You can subclass these if you need such behaviour.
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * private AttributeList myatts;
- *
- * public void startElement (String name, AttributeList atts)
- * {
- * // create a persistent copy of the attribute list
- * // for use outside this method
- * myatts = new AttributeListImpl(atts);
- * [...]
- * }
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * Locator locator;
- * Locator startloc;
- *
- * public void setLocator (Locator locator)
- * {
- * // note the locator
- * this.locator = locator;
- * }
- *
- * public void startDocument ()
- * {
- * // save the location of the start of the document
- * // for future use.
- * Locator startloc = new LocatorImpl(locator);
- * }
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * String parts[] = new String[3];
- * NamespaceSupport support = new NamespaceSupport();
- *
- * support.pushContext();
- * support.declarePrefix("", "http://www.w3.org/1999/xhtml");
- * support.declarePrefix("dc", "http://www.purl.org/dc#");
- *
- * parts = support.processName("p", parts, false);
- * System.out.println("Namespace URI: " + parts[0]);
- * System.out.println("Local name: " + parts[1]);
- * System.out.println("Raw name: " + parts[2]);
- *
- * parts = support.processName("dc:title", parts, false);
- * System.out.println("Namespace URI: " + parts[0]);
- * System.out.println("Local name: " + parts[1]);
- * System.out.println("Raw name: " + parts[2]);
- *
- * support.popContext();
- *
- *
- * http://www.w3.org/XML/1998/namespace
- * as defined in the XML Namespaces specification.
- *
- *
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * This module, both source code and documentation, is in the
- * Public Domain, and comes with NO WARRANTY.
- * See http://www.saxproject.org
- * for further information.
- *
- *
- *
- * try {
- * XMLReader myReader = XMLReaderFactory.createXMLReader();
- * } catch (SAXException e) {
- * System.err.println(e.getMessage());
- * }
- *
- *
- * org.xml.sax.driver
so
- * those configuration mechanisms would see it.
org.xml.sax.driver
- * has a value, that is used as an XMLReader class name. org.xml.sax.parser
system
- * property will often be usable.) In environments such as small embedded systems, which can not - * support that flexibility, other mechanisms to determine the default - * may be used.
- * - *Note that many Java environments allow system properties to be - * initialized on a command line. This means that in most cases - * setting a good value for that property ensures that calls to this - * method will succeed, except when security policies intervene. - * This will also maximize application portability to older SAX - * environments, with less robust implementations of this method. - *
- * - * @return A new XMLReader. - * @exception org.xml.sax.SAXException If no default XMLReader class - * can be identified and instantiated. - * @see #createXMLReader(java.lang.String) - */ - public static XMLReader createXMLReader () - throws SAXException - { - String className = null; - ClassLoader loader = NewInstance.getClassLoader (); - - // 1. try the JVM-instance-wide system property - try { className = System.getProperty (property); } - catch (Exception e) { /* normally fails for applets */ } - - // 2. if that fails, try META-INF/services/ - if (className == null) { - try { - String service = "META-INF/services/" + property; - InputStream in; - BufferedReader reader; - - if (loader == null) - in = ClassLoader.getSystemResourceAsStream (service); - else - in = loader.getResourceAsStream (service); - - if (in != null) { - reader = new BufferedReader ( - new InputStreamReader (in, "UTF8")); - className = reader.readLine (); - in.close (); - } - } catch (Exception e) { - } - } - - // 3. Distro-specific fallback - if (className == null) { -// BEGIN DISTRIBUTION-SPECIFIC - - // EXAMPLE: - // className = "com.example.sax.XmlReader"; - // or a $JAVA_HOME/jre/lib/*properties setting... - -// END DISTRIBUTION-SPECIFIC - } - - // do we know the XMLReader implementation class yet? - if (className != null) - return loadClass (loader, className); - - // 4. panic -- adapt any SAX1 parser - try { - return new ParserAdapter (ParserFactory.makeParser ()); - } catch (Exception e) { - throw new SAXException ("Can't create default XMLReader; " - + "is system property org.xml.sax.driver set?"); - } - } - - - /** - * Attempt to create an XML reader from a class name. - * - *Given a class name, this method attempts to load - * and instantiate the class as an XML reader.
- * - *Note that this method will not be usable in environments where - * the caller (perhaps an applet) is not permitted to load classes - * dynamically.
- * - * @return A new XML reader. - * @exception org.xml.sax.SAXException If the class cannot be - * loaded, instantiated, and cast to XMLReader. - * @see #createXMLReader() - */ - public static XMLReader createXMLReader (String className) - throws SAXException - { - return loadClass (NewInstance.getClassLoader (), className); - } - - private static XMLReader loadClass (ClassLoader loader, String className) - throws SAXException - { - try { - return (XMLReader) NewInstance.newInstance (loader, className); - } catch (ClassNotFoundException e1) { - throw new SAXException("SAX2 driver class " + className + - " not found", e1); - } catch (IllegalAccessException e2) { - throw new SAXException("SAX2 driver class " + className + - " found but cannot be loaded", e2); - } catch (InstantiationException e3) { - throw new SAXException("SAX2 driver class " + className + - " loaded but cannot be instantiated (no empty public constructor?)", - e3); - } catch (ClassCastException e4) { - throw new SAXException("SAX2 driver class " + className + - " does not implement XMLReader", e4); - } - } -} diff --git a/libjava/org/xml/sax/helpers/package.html b/libjava/org/xml/sax/helpers/package.html deleted file mode 100644 index 458d122..0000000 --- a/libjava/org/xml/sax/helpers/package.html +++ /dev/null @@ -1,13 +0,0 @@ - - - - - - -This package contains "helper" classes, including -support for bootstrapping SAX-based applications. - -
See http://www.saxproject.org -for more information about SAX.
- - diff --git a/libjava/org/xml/sax/package.html b/libjava/org/xml/sax/package.html deleted file mode 100644 index 25f4b86..0000000 --- a/libjava/org/xml/sax/package.html +++ /dev/null @@ -1,164 +0,0 @@ - - - - - - -This package provides the core SAX APIs. -Some SAX1 APIs are deprecated to encourage integration of -namespace-awareness into designs of new applications -and into maintainance of existing infrastructure.
- -See http://www.saxproject.org -for more information about SAX.
- - - One of the essential characteristics of SAX2 is that it added
-feature flags which can be used to examine and perhaps modify
-parser modes, in particular modes such as validation.
-Since features are identified by (absolute) URIs, anyone
-can define such features.
-Currently defined standard feature URIs have the prefix
-http://xml.org/sax/features/
before an identifier such as
-validation
. Turn features on or off using
-setFeature. Those standard identifiers are:
Feature ID | -Default | -Description | -
---|---|---|
external-general-entities | -unspecified | -Reports whether this parser processes external - general entities; always true if validating | -
external-parameter-entities | -unspecified | -Reports whether this parser processes external - parameter entities; always true if validating | -
lexical-handler/parameter-entities | -unspecified | -true indicates that the LexicalHandler will report the - beginning and end of parameter entities - | -
namespaces | -true | -true indicates namespace URIs and unprefixed local names - for element and attribute names will be available | -
namespace-prefixes | -false | -true indicates XML 1.0 names (with prefixes) and attributes - (including xmlns* attributes) will be available | -
string-interning | -unspecified | -true if all XML names (for elements, prefixes, attributes, - entities, notations, and local names), - as well as Namespace URIs, will have been interned - using java.lang.String.intern. This supports fast - testing of equality/inequality against string constants. | -
validation | -unspecified | -controls whether the parser is reporting all validity - errors; if true, all external entities will be read. | -
Support for the default values of the -namespaces and namespace-prefixes -properties is required. -
- -For default values not specified by SAX2, -each XMLReader implementation specifies its default, -or may choose not to expose the feature flag. -Unless otherwise specified here, -implementations may support changing current values -of these standard feature flags, but not while parsing. -
- - For parser interface characteristics that are described
-as objects, a separate namespace is defined. The
-objects in this namespace are again identified by URI, and
-the standard property URIs have the prefix
-http://xml.org/sax/properties/
before an identifier such as
-lexical-handler
or
-dom-node
. Manage those properties using
-setProperty(). Those identifiers are:
Property ID | -Description | -
---|---|
declaration-handler | -Used to see most DTD declarations except those treated - as lexical ("document element name is ...") or which are - mandatory for all SAX parsers (DTDHandler). - The Object must implement org.xml.sax.ext.DeclHandler. - | -
dom-node | -For "DOM Walker" style parsers, which ignore their - parser.parse() parameters, this is used to - specify the DOM (sub)tree being walked by the parser. - The Object must implement the - org.w3c.dom.Node interface. - | -
lexical-handler | -Used to see some syntax events that are essential in some - applications: comments, CDATA delimeters, selected general - entity inclusions, and the start and end of the DTD - (and declaration of document element name). - The Object must implement org.xml.sax.ext.LexicalHandler. - | -
xml-string | -Readable only during a parser callback, this exposes a TBS - chunk of characters responsible for the current event. | -
All of these standard properties are optional; -XMLReader implementations need not support them. -
- - -- cgit v1.1