| Methods Summary |
|---|
| void | appendAttribute(int namespaceIndex, int localNameIndex, int prefixIndex, boolean isID, int m_char_current_start, int contentLength)Append an Attribute child at the current insertion
point. Assumes that the symbols (namespace URI, local name, and
prefix) have already been added to the pools, and that the content has
already been appended to m_char. Note that the attribute's content has
been flattened into a single string; DTM does _NOT_ attempt to model
the details of entity references within attribute values.
// %TBD% isID is not currently honored.
// W0 High: Namespace Low: Node Type
int w0 = ATTRIBUTE_NODE | namespaceIndex<<16;
// W1: Parent
int w1 = currentParent;
// W2: Next (not yet resolved)
int w2 = 0;
// W3: Tagname high: prefix Low: local name
int w3 = localNameIndex | prefixIndex<<16;
/**/System.out.println("set w3="+w3+" "+(w3>>16)+"/"+(w3&0xffff));
// Add node
int ourslot = appendNode(w0, w1, w2, w3);
previousSibling = ourslot; // Should attributes be previous siblings
// Attribute's content is currently appended as a Text Node
// W0: Node Type
w0 = TEXT_NODE;
// W1: Parent
w1 = ourslot;
// W2: Start Position within buffer
w2 = m_char_current_start;
// W3: Length
w3 = contentLength;
appendNode(w0, w1, w2, w3);
// Attrs are Parents
previousSiblingWasParent = true;
return ;//(m_docHandle | ourslot);
|
| public void | appendChild(int newChild, boolean clone, boolean cloneDepth)Append a child to the end of the child list of the current node. Please note that the node
is always cloned if it is owned by another document.
%REVIEW% "End of the document" needs to be defined more clearly.
Does it become the last child of the Document? Of the root element?
boolean sameDoc = ((newChild & DOCHANDLE_MASK) == m_docHandle);
if (clone || !sameDoc) {
} else {
}
|
| void | appendComment(int m_char_current_start, int contentLength)Append a comment child at the current insertion point. Assumes that the
actual content of the comment has previously been appended to the m_char
buffer (shared with the builder).
// create a Comment Node
// %TBD% may be possible to combine with appendNode()to replace the next chunk of code
int w0 = COMMENT_NODE;
// W1: Parent
int w1 = currentParent;
// W2: Start position within m_char
int w2 = m_char_current_start;
// W3: Length of the full string
int w3 = contentLength;
int ourslot = appendNode(w0, w1, w2, w3);
previousSibling = ourslot;
|
| void | appendEndDocument()All appends to this document have finished; do whatever final
cleanup is needed.
done = true;
// %TBD% may need to notice the last slot number and slot count to avoid
// residual data from provious use of this DTM
|
| void | appendEndElement()Terminate the element currently acting as an insertion point. Subsequent
insertions will occur as the last child of this element's parent.
// pop up the stacks
if (previousSiblingWasParent)
nodes.writeEntry(previousSibling, 2, NULL);
// Pop parentage
previousSibling = currentParent;
nodes.readSlot(currentParent, gotslot);
currentParent = gotslot[1] & 0xFFFF;
// The element just being finished will be
// the previous sibling for the next operation
previousSiblingWasParent = true;
// Pop a level of namespace table
// namespaceTable.removeLastElem();
|
| void | appendNSDeclaration(int prefixIndex, int namespaceIndex, boolean isID)Append a Namespace Declaration child at the current insertion point.
Assumes that the symbols (namespace URI and prefix) have already been
added to the pools
// %REVIEW% I'm assigning this node the "namespace for namespaces"
// which the DOM defined. It is expected that the Namespace spec will
// adopt this as official. It isn't strictly needed since it's implied
// by the nodetype, but for now...
// %REVIEW% Prefix need not be recorded; it's implied too. But
// recording it might simplify the design.
// %TBD% isID is not currently honored.
final int namespaceForNamespaces=m_nsNames.stringToIndex("http://www.w3.org/2000/xmlns/");
// W0 High: Namespace Low: Node Type
int w0 = NAMESPACE_NODE | (m_nsNames.stringToIndex("http://www.w3.org/2000/xmlns/")<<16);
// W1: Parent
int w1 = currentParent;
// W2: CURRENTLY UNUSED -- It's next-sib in attrs, but we have no kids.
int w2 = 0;
// W3: namespace name
int w3 = namespaceIndex;
// Add node
int ourslot = appendNode(w0, w1, w2, w3);
previousSibling = ourslot; // Should attributes be previous siblings
previousSiblingWasParent = false;
return ;//(m_docHandle | ourslot);
|
| private final int | appendNode(int w0, int w1, int w2, int w3)Wrapper for ChunkedIntArray.append, to automatically update the
previous sibling's "next" reference (if necessary) and periodically
wake a reader who may have encountered incomplete data and entered
a wait state.
// A decent compiler may inline this.
int slotnumber = nodes.appendSlot(w0, w1, w2, w3);
if (DEBUG) System.out.println(slotnumber+": "+w0+" "+w1+" "+w2+" "+w3);
if (previousSiblingWasParent)
nodes.writeEntry(previousSibling,2,slotnumber);
previousSiblingWasParent = false; // Set the default; endElement overrides
return slotnumber;
|
| void | appendStartDocument()Starting a new document. Perform any resets/initialization
not already handled.
// %TBD% reset slot 0 to indicate ChunkedIntArray reuse or wait for
// the next initDocument().
m_docElement = NULL; // reset nodeHandle to the root of the actual dtm doc content
initDocument(0);
|
| void | appendStartElement(int namespaceIndex, int localNameIndex, int prefixIndex)Append an Element child at the current insertion point. This
Element then _becomes_ the insertion point; subsequent appends
become its lastChild until an appendEndElement() call is made.
Assumes that the symbols (local name, namespace URI and prefix)
have already been added to the pools
Note that this _only_ handles the Element node itself. Attrs and
namespace nodes are unbundled in the ContentHandler layer
and appended separately.
// do document root node creation here on the first element, create nodes for
// this element and its attributes, store the element, namespace, and attritute
// name indexes to the nodes array, keep track of the current node and parent
// element used
// W0 High: Namespace Low: Node Type
int w0 = (namespaceIndex << 16) | ELEMENT_NODE;
// W1: Parent
int w1 = currentParent;
// W2: Next (initialized as 0)
int w2 = 0;
// W3: Tagname high: prefix Low: local name
int w3 = localNameIndex | prefixIndex<<16;
/**/System.out.println("set w3="+w3+" "+(w3>>16)+"/"+(w3&0xffff));
//int ourslot = nodes.appendSlot(w0, w1, w2, w3);
int ourslot = appendNode(w0, w1, w2, w3);
currentParent = ourslot;
previousSibling = 0;
// set the root element pointer when creating the first element node
if (m_docElement == NULL)
m_docElement = ourslot;
|
| public void | appendTextChild(java.lang.String str)Append a text node child that will be constructed from a string,
to the end of the document.
%REVIEW% "End of the document" needs to be defined more clearly.
Does it become the last child of the Document? Of the root element?
// ###shs Think more about how this differs from createTextNode
//%TBD%
|
| void | appendTextChild(int m_char_current_start, int contentLength)Append a text child at the current insertion point. Assumes that the
actual content of the text has previously been appended to the m_char
buffer (shared with the builder).
// create a Text Node
// %TBD% may be possible to combine with appendNode()to replace the next chunk of code
int w0 = TEXT_NODE;
// W1: Parent
int w1 = currentParent;
// W2: Start position within m_char
int w2 = m_char_current_start;
// W3: Length of the full string
int w3 = contentLength;
int ourslot = appendNode(w0, w1, w2, w3);
previousSibling = ourslot;
|
| public void | characters(char[] ch, int start, int length)
// Actually creating the text node is handled by
// processAccumulatedText(); here we just accumulate the
// characters into the buffer.
m_char.append(ch,start,length);
|
| public void | comment(char[] ch, int start, int length)
processAccumulatedText();
m_char.append(ch,start,length); // Single-string value
appendComment(m_char_current_start,length);
m_char_current_start+=length;
|
| public void | dispatchCharactersEvents(int nodeHandle, org.xml.sax.ContentHandler ch, boolean normalize)Directly call the
characters method on the passed ContentHandler for the
string-value of the given node (see http://www.w3.org/TR/xpath#data-model
for the definition of a node's string-value). Multiple calls to the
ContentHandler's characters methods may well occur for a single call to
this method.
|
| public void | dispatchToEvents(int nodeHandle, org.xml.sax.ContentHandler ch)Directly create SAX parser events from a subtree.
|
| public void | documentRegistration()A dummy routine to satisify the abstract interface. If the DTM
implememtation that extends the default base requires notification
of registration, they can override this method.
|
| public void | documentRelease()A dummy routine to satisify the abstract interface. If the DTM
implememtation that extends the default base requires notification
when the document is being released, they can override this method
|
| public void | endCDATA()
// No-op in DTM
|
| public void | endDTD()
// No-op in DTM
|
| public void | endDocument()
// May need to tell the low-level builder code to pop up a level.
// There _should't_ be any significant pending text at this point.
appendEndDocument();
|
| public void | endElement(java.lang.String namespaceURI, java.lang.String localName, java.lang.String qName)
processAccumulatedText();
// No args but we do need to tell the low-level builder code to
// pop up a level.
appendEndElement();
|
| public void | endEntity(java.lang.String name)
// No-op in DTM
|
| public void | endPrefixMapping(java.lang.String prefix)
// No-op
|
| public int | getAttributeNode(int nodeHandle, java.lang.String namespaceURI, java.lang.String name)Retrieves an attribute node by by qualified name and namespace URI.
int nsIndex = m_nsNames.stringToIndex(namespaceURI),
nameIndex = m_localNames.stringToIndex(name);
nodeHandle &= NODEHANDLE_MASK;
nodes.readSlot(nodeHandle, gotslot);
short type = (short) (gotslot[0] & 0xFFFF);
// If nodeHandle points to element next slot would be first attribute
if (type == ELEMENT_NODE)
nodeHandle++;
// Iterate through Attribute Nodes
while (type == ATTRIBUTE_NODE) {
if ((nsIndex == (gotslot[0] << 16)) && (gotslot[3] == nameIndex))
return nodeHandle | m_docHandle;
// Goto next sibling
nodeHandle = gotslot[2];
nodes.readSlot(nodeHandle, gotslot);
}
return NULL;
|
| public com.sun.org.apache.xml.internal.dtm.DTMAxisIterator | getAxisIterator(int axis)This is a shortcut to the iterators that implement the
supported XPath axes (only namespace::) is not supported.
Returns a bare-bones iterator that must be initialized
with a start node (using iterator.setStartNode()).
// %TBD%
return null;
|
| public com.sun.org.apache.xml.internal.dtm.DTMAxisTraverser | getAxisTraverser(int axis)This returns a stateless "traverser", that can navigate over an
XPath axis, though not in document order.
return null;
|
| com.sun.org.apache.xml.internal.utils.FastStringBuffer | getContentBuffer()Get a reference pointer to the content-text repository
return m_char;
|
| public org.xml.sax.ContentHandler | getContentHandler()getContentHandler returns "our SAX builder" -- the thing that
someone else should send SAX events to in order to extend this
DTM model.
if (m_incrSAXSource instanceof IncrementalSAXSource_Filter)
return (ContentHandler) m_incrSAXSource;
else
return this;
|
| public org.xml.sax.DTDHandler | getDTDHandler()Return this DTM's DTDHandler.
return null;
|
| public org.xml.sax.ext.DeclHandler | getDeclHandler()Return this DTM's DeclHandler.
return null;
|
| public int | getDocument()Given a node handle, find the owning document node.
return m_docHandle;
|
| public boolean | getDocumentAllDeclarationsProcessed()Return an indication of
whether the processor has read the complete DTD. Its value is a
boolean. If it is false, then certain properties (indicated in their
descriptions below) may be unknown. If it is true, those properties
are never unknown.return false;
|
| public java.lang.String | getDocumentBaseURI()Return the base URI of the document entity. If it is not known
(because the document was parsed from a socket connection or from
standard input, for example), the value of this property is unknown.
return m_documentBaseURI;
|
| public java.lang.String | getDocumentEncoding(int nodeHandle)Return the name of the character encoding scheme
in which the document entity is expressed.return null;
|
| public int | getDocumentRoot()Returns the root element of the document.
return (m_docHandle | m_docElement);
|
| public int | getDocumentRoot(int nodeHandle)Given a node handle, find the owning document node. This has the DTM
semantics; a Document node is its own owner.
%REVIEW% Since this is DOM-specific, it may belong at the DOM
binding layer. Included here as a convenience function and to
aid porting of DOM code to DTM.
// Assumption that Document Node is always in 0 slot
if ((nodeHandle & NODEHANDLE_MASK) == 0)
return NULL;
return (nodeHandle & DOCHANDLE_MASK);
|
| public java.lang.String | getDocumentStandalone(int nodeHandle)Return an indication of the standalone status of the document,
either "yes" or "no". This property is derived from the optional
standalone document declaration in the XML declaration at the
beginning of the document entity, and has no value if there is no
standalone document declaration.return null;
|
| public java.lang.String | getDocumentSystemIdentifier(int nodeHandle)Return the system identifier of the document entity. If
it is not known, the value of this property is unknown.return null;
|
| public java.lang.String | getDocumentTypeDeclarationPublicIdentifier()Return the public identifier of the external subset,
normalized as described in 4.2.2 External Entities [XML]. If there is
no external subset or if it has no public identifier, this property
has no value.return null;
|
| public java.lang.String | getDocumentTypeDeclarationSystemIdentifier()A document type declaration information item has the following properties:
1. [system identifier] The system identifier of the external subset, if
it exists. Otherwise this property has no value.return null;
|
| public java.lang.String | getDocumentVersion(int documentHandle)Return a string representing the XML version of the document. This
property is derived from the XML declaration optionally present at the
beginning of the document entity, and has no value if there is no XML
declaration.return null;
|
| public int | getElementById(java.lang.String elementId)Returns the Element whose ID is given by
elementId. If no such element exists, returns
DTM.NULL. Behavior is not defined if more than one element
has this ID. Attributes (including those
with the name "ID") are not of type ID unless so defined by DTD/Schema
information available to the DTM implementation.
Implementations that do not know whether attributes are of type ID or
not are expected to return DTM.NULL.
%REVIEW% Presumably IDs are still scoped to a single document,
and this operation searches only within a single document, right?
Wouldn't want collisions between DTMs in the same process. return 0;
|
| public org.xml.sax.EntityResolver | getEntityResolver()Return this DTM's EntityResolver.
return null;
|
| public org.xml.sax.ErrorHandler | getErrorHandler()Return this DTM's ErrorHandler.
return null;
|
| public int | getExpandedTypeID(int nodeHandle)Given a node handle, return an ID that represents the node's expanded name.
nodes.readSlot(nodeHandle, gotslot);
String qName = m_localNames.indexToString(gotslot[3]);
// Remove prefix from qName
// %TBD% jjk This is assuming the elementName is the qName.
int colonpos = qName.indexOf(":");
String localName = qName.substring(colonpos+1);
// Get NS
String namespace = m_nsNames.indexToString(gotslot[0] << 16);
// Create expanded name
String expandedName = namespace + ":" + localName;
int expandedNameID = m_nsNames.stringToIndex(expandedName);
return expandedNameID;
|
| public int | getExpandedTypeID(java.lang.String namespace, java.lang.String localName, int type)Given an expanded name, return an ID. If the expanded-name does not
exist in the internal tables, the entry will be created, and the ID will
be returned. Any additional nodes that are created that have this
expanded name will use this ID.
// Create expanded name
// %TBD% jjk Expanded name is bitfield-encoded as
// typeID[6]nsuriID[10]localID[16]. Switch to that form, and to
// accessing the ns/local via their tables rather than confusing
// nsnames and expandednames.
String expandedName = namespace + ":" + localName;
int expandedNameID = m_nsNames.stringToIndex(expandedName);
return expandedNameID;
|
| public int | getFirstAttribute(int nodeHandle)Given a node handle, get the index of the node's first attribute.
nodeHandle &= NODEHANDLE_MASK;
// %REVIEW% jjk: Just a quick observation: If you're going to
// call readEntry repeatedly on the same node, it may be
// more efficiently to do a readSlot to get the data locally,
// reducing the addressing and call-and-return overhead.
// Should we check if handle is element (do we want sanity checks?)
if (ELEMENT_NODE != (nodes.readEntry(nodeHandle, 0) & 0xFFFF))
return NULL;
// First Attribute (if any) should be at next position in table
nodeHandle++;
return(ATTRIBUTE_NODE == (nodes.readEntry(nodeHandle, 0) & 0xFFFF)) ?
nodeHandle | m_docHandle : NULL;
|
| public int | getFirstChild(int nodeHandle)Given a node handle, get the handle of the node's first child.
If not yet resolved, waits for more nodes to be added to the document and
tries again.
// ###shs worry about tracing/debug later
nodeHandle &= NODEHANDLE_MASK;
// Read node into variable
nodes.readSlot(nodeHandle, gotslot);
// type is the last half of first slot
short type = (short) (gotslot[0] & 0xFFFF);
// Check to see if Element or Document node
if ((type == ELEMENT_NODE) || (type == DOCUMENT_NODE) ||
(type == ENTITY_REFERENCE_NODE)) {
// In case when Document root is given
// if (nodeHandle == 0) nodeHandle = 1;
// %TBD% Probably was a mistake.
// If someone explicitly asks for first child
// of Document, I would expect them to want
// that and only that.
int kid = nodeHandle + 1;
nodes.readSlot(kid, gotslot);
while (ATTRIBUTE_NODE == (gotslot[0] & 0xFFFF)) {
// points to next sibling
kid = gotslot[2];
// Return NULL if node has only attributes
if (kid == NULL) return NULL;
nodes.readSlot(kid, gotslot);
}
// If parent slot matches given parent, return kid
if (gotslot[1] == nodeHandle)
{
int firstChild = kid | m_docHandle;
return firstChild;
}
}
// No child found
return NULL;
|
| public int | getFirstNamespaceNode(int nodeHandle, boolean inScope)Given a node handle, get the index of the node's first child.
If not yet resolved, waits for more nodes to be added to the document and
tries again
return NULL;
|
| public int | getLastChild(int nodeHandle)Given a node handle, advance to its last child.
If not yet resolved, waits for more nodes to be added to the document and
tries again.
// ###shs put trace/debug later
nodeHandle &= NODEHANDLE_MASK;
// do not need to test node type since getFirstChild does that
int lastChild = NULL;
for (int nextkid = getFirstChild(nodeHandle); nextkid != NULL;
nextkid = getNextSibling(nextkid)) {
lastChild = nextkid;
}
return lastChild | m_docHandle;
|
| public short | getLevel(int nodeHandle)Get the depth level of this node in the tree (equals 1 for
a parentless node).
short count = 0;
while (nodeHandle != 0) {
count++;
nodeHandle = nodes.readEntry(nodeHandle, 1);
}
return count;
|
| public org.xml.sax.ext.LexicalHandler | getLexicalHandler()Return this DTM's lexical handler.
%REVIEW% Should this return null if constrution already done/begun?
if (m_incrSAXSource instanceof IncrementalSAXSource_Filter)
return (LexicalHandler) m_incrSAXSource;
else
return this;
|
| public java.lang.String | getLocalName(int nodeHandle)Given a node handle, return its DOM-style localname.
(As defined in Namespaces, this is the portion of the name after any
colon character)
%REVIEW% What's the local name of something other than Element/Attr?
Should this be DOM-style (undefined unless namespaced), or other?
nodes.readSlot(nodeHandle, gotslot);
short type = (short) (gotslot[0] & 0xFFFF);
String name = "";
if ((type==ELEMENT_NODE) || (type==ATTRIBUTE_NODE)) {
int i=gotslot[3];
name=m_localNames.indexToString(i & 0xFFFF);
if(name==null) name="";
}
return name;
|
| public java.lang.String | getLocalNameFromExpandedNameID(int ExpandedNameID)Given an expanded-name ID, return the local name part.
// Get expanded name
String expandedName = m_localNames.indexToString(ExpandedNameID);
// Remove prefix from expanded name
int colonpos = expandedName.indexOf(":");
String localName = expandedName.substring(colonpos+1);
return localName;
|
| public com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool | getLocalNameTable()Get a reference pointer to the element name symbol table.
return m_localNames;
|
| public java.lang.String | getNamespaceFromExpandedNameID(int ExpandedNameID)Given an expanded-name ID, return the namespace URI part.
String expandedName = m_localNames.indexToString(ExpandedNameID);
// Remove local name from expanded name
int colonpos = expandedName.indexOf(":");
String nsName = expandedName.substring(0, colonpos);
return nsName;
|
| public java.lang.String | getNamespaceURI(int nodeHandle)Given a node handle, return its DOM-style namespace URI
(As defined in Namespaces, this is the declared URI which this node's
prefix -- or default in lieu thereof -- was mapped to.)return null;
|
| public int | getNextAttribute(int nodeHandle)Given a node handle, advance to the next attribute. If an
element, we advance to its first attribute; if an attr, we advance to
the next attr on the same node.
nodeHandle &= NODEHANDLE_MASK;
nodes.readSlot(nodeHandle, gotslot);
//%REVIEW% Why are we using short here? There's no storage
//reduction for an automatic variable, especially one used
//so briefly, and it typically costs more cycles to process
//than an int would.
short type = (short) (gotslot[0] & 0xFFFF);
if (type == ELEMENT_NODE) {
return getFirstAttribute(nodeHandle);
} else if (type == ATTRIBUTE_NODE) {
if (gotslot[2] != NULL)
return (m_docHandle | gotslot[2]);
}
return NULL;
|
| public int | getNextDescendant(int subtreeRootHandle, int nodeHandle)Given a node handle, advance to its next descendant.
If not yet resolved, waits for more nodes to be added to the document and
tries again.
subtreeRootHandle &= NODEHANDLE_MASK;
nodeHandle &= NODEHANDLE_MASK;
// Document root [Document Node? -- jjk] - no next-sib
if (nodeHandle == 0)
return NULL;
while (!m_isError) {
// Document done and node out of bounds
if (done && (nodeHandle > nodes.slotsUsed()))
break;
if (nodeHandle > subtreeRootHandle) {
nodes.readSlot(nodeHandle+1, gotslot);
if (gotslot[2] != 0) {
short type = (short) (gotslot[0] & 0xFFFF);
if (type == ATTRIBUTE_NODE) {
nodeHandle +=2;
} else {
int nextParentPos = gotslot[1];
if (nextParentPos >= subtreeRootHandle)
return (m_docHandle | (nodeHandle+1));
else
break;
}
} else if (!done) {
// Add wait logic here
} else
break;
} else {
nodeHandle++;
}
}
// Probably should throw error here like original instead of returning
return NULL;
|
| public int | getNextFollowing(int axisContextHandle, int nodeHandle)Given a node handle, advance to the next node on the following axis.
//###shs still working on
return NULL;
|
| public int | getNextNamespaceNode(int baseHandle, int namespaceHandle, boolean inScope)Given a namespace handle, advance to the next namespace.
%TBD% THIS METHOD DOES NOT MATCH THE CURRENT SIGNATURE IN
THE DTM INTERFACE. FIX IT, OR JUSTIFY CHANGING THE DTM
API.
// ###shs need to work on namespace
return NULL;
|
| public int | getNextPreceding(int axisContextHandle, int nodeHandle)Given a node handle, advance to the next node on the preceding axis.
// ###shs copied from Xalan 1, what is this suppose to do?
nodeHandle &= NODEHANDLE_MASK;
while (nodeHandle > 1) {
nodeHandle--;
if (ATTRIBUTE_NODE == (nodes.readEntry(nodeHandle, 0) & 0xFFFF))
continue;
// if nodeHandle is _not_ an ancestor of
// axisContextHandle, specialFind will return it.
// If it _is_ an ancestor, specialFind will return -1
// %REVIEW% unconditional return defeats the
// purpose of the while loop -- does this
// logic make any sense?
return (m_docHandle | nodes.specialFind(axisContextHandle, nodeHandle));
}
return NULL;
|
| public int | getNextSibling(int nodeHandle)Given a node handle, advance to its next sibling.
%TBD% This currently uses the DTM-internal definition of
sibling; eg, the last attr's next sib is the first
child. In the old DTM, the DOM proxy layer provided the
additional logic for the public view. If we're rewriting
for XPath emulation, that test must be done here.
%TBD% CODE INTERACTION WITH INCREMENTAL PARSE - If not yet
resolved, should wait for more nodes to be added to the document
and tries again.
nodeHandle &= NODEHANDLE_MASK;
// Document root has no next sibling
if (nodeHandle == 0)
return NULL;
short type = (short) (nodes.readEntry(nodeHandle, 0) & 0xFFFF);
if ((type == ELEMENT_NODE) || (type == ATTRIBUTE_NODE) ||
(type == ENTITY_REFERENCE_NODE)) {
int nextSib = nodes.readEntry(nodeHandle, 2);
if (nextSib == NULL)
return NULL;
if (nextSib != 0)
return (m_docHandle | nextSib);
// ###shs should cycle/wait if nextSib is 0? Working on threading next
}
// Next Sibling is in the next position if it shares the same parent
int thisParent = nodes.readEntry(nodeHandle, 1);
if (nodes.readEntry(++nodeHandle, 1) == thisParent)
return (m_docHandle | nodeHandle);
return NULL;
|
| public org.w3c.dom.Node | getNode(int nodeHandle)Return an DOM node for the given node.
return null;
|
| public java.lang.String | getNodeName(int nodeHandle)Given a node handle, return its DOM-style node name. This will
include names such as #text or #document. // Notation
nodes.readSlot(nodeHandle, gotslot);
short type = (short) (gotslot[0] & 0xFFFF);
String name = fixednames[type];
if (null == name) {
int i=gotslot[3];
/**/System.out.println("got i="+i+" "+(i>>16)+"/"+(i&0xffff));
name=m_localNames.indexToString(i & 0xFFFF);
String prefix=m_prefixNames.indexToString(i >>16);
if(prefix!=null && prefix.length()>0)
name=prefix+":"+name;
}
return name;
|
| public java.lang.String | getNodeNameX(int nodeHandle)Given a node handle, return the XPath node name. This should be
the name as described by the XPath data model, NOT the DOM-style
name.return null;
|
| public short | getNodeType(int nodeHandle)Given a node handle, return its DOM-style node type.
%REVIEW% Generally, returning short is false economy. Return int?
return(short) (nodes.readEntry(nodeHandle, 0) & 0xFFFF);
|
| public java.lang.String | getNodeValue(int nodeHandle)Given a node handle, return its node value. This is mostly
as defined by the DOM, but may ignore some conveniences.
nodes.readSlot(nodeHandle, gotslot);
int nodetype=gotslot[0] & 0xFF; // ###zaj use mask to get node type
String value=null;
switch (nodetype) { // ###zaj todo - document nodetypes
case ATTRIBUTE_NODE:
nodes.readSlot(nodeHandle+1, gotslot);
case TEXT_NODE:
case COMMENT_NODE:
case CDATA_SECTION_NODE:
value=m_char.getString(gotslot[2], gotslot[3]); //###zaj
break;
case PROCESSING_INSTRUCTION_NODE:
case ELEMENT_NODE:
case ENTITY_REFERENCE_NODE:
default:
break;
}
return value;
|
| public com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool | getNsNameTable()Get a reference pointer to the namespace URI symbol table.
return m_nsNames;
|
| public int | getOwnerDocument(int nodeHandle)Given a node handle, find the owning document node. This has the exact
same semantics as the DOM Document method of the same name, in that if
the nodeHandle is a document node, it will return NULL.
%REVIEW% Since this is DOM-specific, it may belong at the DOM
binding layer. Included here as a convenience function and to
aid porting of DOM code to DTM.
// Assumption that Document Node is always in 0 slot
if ((nodeHandle & NODEHANDLE_MASK) == 0)
return NULL;
return (nodeHandle & DOCHANDLE_MASK);
|
| public int | getParent(int nodeHandle)Given a node handle, find its parent node.
// Should check to see within range?
// Document Root should not have to be handled differently
return (m_docHandle | nodes.readEntry(nodeHandle, 1));
|
| public java.lang.String | getPrefix(int nodeHandle)Given a namespace handle, return the prefix that the namespace decl is
mapping.
Given a node handle, return the prefix used to map to the namespace.
%REVIEW% Are you sure you want "" for no prefix?
%REVIEW% Should this be DOM-style (undefined unless namespaced),
or other?
nodes.readSlot(nodeHandle, gotslot);
short type = (short) (gotslot[0] & 0xFFFF);
String name = "";
if((type==ELEMENT_NODE) || (type==ATTRIBUTE_NODE)) {
int i=gotslot[3];
name=m_prefixNames.indexToString(i >>16);
if(name==null) name="";
}
return name;
|
| public com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool | getPrefixNameTable()Get a reference pointer to the prefix name symbol table.
return m_prefixNames;
|
| public int | getPreviousSibling(int nodeHandle)Given a node handle, find its preceeding sibling.
WARNING: DTM is asymmetric; this operation is resolved by search, and is
relatively expensive.
nodeHandle &= NODEHANDLE_MASK;
// Document root has no previous sibling
if (nodeHandle == 0)
return NULL;
int parent = nodes.readEntry(nodeHandle, 1);
int kid = NULL;
for (int nextkid = getFirstChild(parent); nextkid != nodeHandle;
nextkid = getNextSibling(nextkid)) {
kid = nextkid;
}
return kid | m_docHandle;
|
| public javax.xml.transform.SourceLocator | getSourceLocatorFor(int node)Source information is not handled yet, so return
null here.
return null;
|
| public com.sun.org.apache.xml.internal.utils.XMLString | getStringValue(int nodeHandle)Get the string-value of a node as a String object
(see http://www.w3.org/TR/xpath#data-model
for the definition of a node's string-value).
// ###zaj - researching
nodes.readSlot(nodeHandle, gotslot);
int nodetype=gotslot[0] & 0xFF;
String value=null;
switch (nodetype) {
case TEXT_NODE:
case COMMENT_NODE:
case CDATA_SECTION_NODE:
value= m_char.getString(gotslot[2], gotslot[3]);
break;
case PROCESSING_INSTRUCTION_NODE:
case ATTRIBUTE_NODE:
case ELEMENT_NODE:
case ENTITY_REFERENCE_NODE:
default:
break;
}
return m_xsf.newstr( value );
|
| public char[] | getStringValueChunk(int nodeHandle, int chunkIndex, int[] startAndLen)Get a character array chunk in the string-value of a node.
(see http://www.w3.org/TR/xpath#data-model
for the definition of a node's string-value).
Note that a single text node may have multiple text chunks.
EXPLANATION: This method is an artifact of the fact that
the underlying m_chars object may not store characters in a
single contiguous array -- for example,the current
FastStringBuffer may split a single node's text across
multiple allocation units. This call retrieves a single
contiguous portion of the text -- as much as m-chars was
able to store in a single allocation unit. PLEASE NOTE
that this may not be the same granularityas the SAX
characters() events that caused the text node to be built
in the first place, since m_chars buffering may be on
different boundaries than the parser's buffers.return new char[0];
|
| public int | getStringValueChunkCount(int nodeHandle)Get number of character array chunks in
the string-value of a node.
(see http://www.w3.org/TR/xpath#data-model
for the definition of a node's string-value).
Note that a single text node may have multiple text chunks.
EXPLANATION: This method is an artifact of the fact that the
underlying m_chars object may not store characters in a
single contiguous array -- for example,the current
FastStringBuffer may split a single node's text across
multiple allocation units. This call tells us how many
separate accesses will be required to retrieve the entire
content. PLEASE NOTE that this may not be the same as the
number of SAX characters() events that caused the text node
to be built in the first place, since m_chars buffering may
be on different boundaries than the parser's buffers.
//###zaj return value
return 0;
|
| public com.sun.org.apache.xml.internal.dtm.DTMAxisIterator | getTypedAxisIterator(int axis, int type)Get an iterator that can navigate over an XPath Axis, predicated by
the extended type ID.
// %TBD%
return null;
|
| public java.lang.String | getUnparsedEntityURI(java.lang.String name)The getUnparsedEntityURI function returns the URI of the unparsed
entity with the specified name in the same document as the context
node (see [3.3 Unparsed Entities]). It returns the empty string if
there is no such entity.
XML processors may choose to use the System Identifier (if one
is provided) to resolve the entity, rather than the URI in the
Public Identifier. The details are dependent on the processor, and
we would have to support some form of plug-in resolver to handle
this properly. Currently, we simply return the System Identifier if
present, and hope that it a usable URI or that our caller can
map it to one.
TODO: Resolve Public Identifiers... or consider changing function name.
If we find a relative URI
reference, XML expects it to be resolved in terms of the base URI
of the document. The DOM doesn't do that for us, and it isn't
entirely clear whether that should be done here; currently that's
pushed up to a higher level of our application. (Note that DOM Level
1 didn't store the document's base URI.)
TODO: Consider resolving Relative URIs.
(The DOM's statement that "An XML processor may choose to
completely expand entities before the structure model is passed
to the DOM" refers only to parsed entities, not unparsed, and hence
doesn't affect this function.) return null;
|
| public boolean | hasChildNodes(int nodeHandle)Given a node handle, test if it has child nodes.
%REVIEW% This is obviously useful at the DOM layer, where it
would permit testing this without having to create a proxy
node. It's less useful in the DTM API, where
(dtm.getFirstChild(nodeHandle)!=DTM.NULL) is just as fast and
almost as self-evident. But it's a convenience, and eases porting
of DOM code to DTM.
return(getFirstChild(nodeHandle) != NULL);
|
| public void | ignorableWhitespace(char[] ch, int start, int length)
// %TBD% I believe ignorable text isn't part of the DTM model...?
|
| final void | initDocument(int documentNumber)Reset a dtm document to its initial (empty) state.
The DTMManager will invoke this method when the dtm is created.
// save masked DTM document handle
m_docHandle = documentNumber<<DOCHANDLE_SHIFT;
// Initialize the doc -- no parent, no next-sib
nodes.writeSlot(0,DOCUMENT_NODE,-1,-1,0);
// wait for the first startElement to create the doc root node
done = false;
|
| public boolean | isAttributeSpecified(int attributeHandle)5. [specified] A flag indicating whether this attribute was actually
specified in the start-tag of its element, or was defaulted from the
DTD.return false;
|
| public boolean | isCharacterElementContentWhitespace(int nodeHandle)2. [element content whitespace] A boolean indicating whether the
character is white space appearing within element content (see [XML],
2.10 "White Space Handling"). Note that validating XML processors are
required by XML 1.0 to provide this information. If there is no
declaration for the containing element, this property has no value for
white space characters. If no declaration has been read, but the [all
declarations processed] property of the document information item is
false (so there may be an unread declaration), then the value of this
property is unknown for white space characters. It is always false for
characters that are not white space.return false;
|
| public boolean | isDocumentAllDeclarationsProcessed(int documentHandle)10. [all declarations processed] This property is not strictly speaking
part of the infoset of the document. Rather it is an indication of
whether the processor has read the complete DTD. Its value is a
boolean. If it is false, then certain properties (indicated in their
descriptions below) may be unknown. If it is true, those properties
are never unknown.return false;
|
| public boolean | isNodeAfter(int nodeHandle1, int nodeHandle2)Figure out whether nodeHandle2 should be considered as being later
in the document than nodeHandle1, in Document Order as defined
by the XPath model. This may not agree with the ordering defined
by other XML applications.
There are some cases where ordering isn't defined, and neither are
the results of this function -- though we'll generally return true.
TODO: Make sure this does the right thing with attribute nodes!!! return false;
|
| public boolean | isSupported(java.lang.String feature, java.lang.String version)Tests whether DTM DOM implementation implements a specific feature and
that feature is supported by this node.return false;
|
| public void | migrateTo(com.sun.org.apache.xml.internal.dtm.DTMManager manager)Migrate a DTM built with an old DTMManager to a new DTMManager.
After the migration, the new DTMManager will treat the DTM as
one that is built by itself.
This is used to support DTM sharing between multiple transformations.
|
| public boolean | needsTwoThreads()
return null!=m_incrSAXSource;
|
| private void | processAccumulatedText()
int len=m_char.length();
if(len!=m_char_current_start)
{
// The FastStringBuffer has been previously agreed upon
appendTextChild(m_char_current_start,len-m_char_current_start);
m_char_current_start=len;
}
|
| public void | processingInstruction(java.lang.String target, java.lang.String data)
processAccumulatedText();
// %TBD% Which pools do target and data go into?
|
| void | setContentBuffer(com.sun.org.apache.xml.internal.utils.FastStringBuffer buffer)Set a reference pointer to the content-text repository
m_char = buffer;
|
| public void | setDocumentBaseURI(java.lang.String baseURI)Set the base URI of the document entity.
m_documentBaseURI = baseURI;
|
| public void | setDocumentLocator(org.xml.sax.Locator locator)
// No-op for DTM
|
| public void | setFeature(java.lang.String featureId, boolean state)Set an implementation dependent feature.
%REVIEW% Do we really expect to set features on DTMs?
|
| public void | setIncrementalSAXSource(com.sun.org.apache.xml.internal.dtm.ref.IncrementalSAXSource source)Bind a IncrementalSAXSource to this DTM. If we discover we need nodes
that have not yet been built, we will ask this object to send us more
events, and it will manage interactions with its data sources.
Note that we do not actually build the IncrementalSAXSource, since we don't
know what source it's reading from, what thread that source will run in,
or when it will run.
m_incrSAXSource=source;
// Establish SAX-stream link so we can receive the requested data
source.setContentHandler(this);
source.setLexicalHandler(this);
// Are the following really needed? IncrementalSAXSource doesn't yet
// support them, and they're mostly no-ops here...
//source.setErrorHandler(this);
//source.setDTDHandler(this);
//source.setDeclHandler(this);
|
| public void | setLocalNameTable(com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool poolRef)Set a reference pointer to the element name symbol table.
%REVIEW% Should this really be Public? Changing it while
DTM is in use would be a disaster.
m_localNames = poolRef;
|
| public void | setNsNameTable(com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool poolRef)Set a reference pointer to the namespace URI symbol table.
%REVIEW% Should this really be Public? Changing it while
DTM is in use would be a disaster.
m_nsNames = poolRef;
|
| public void | setPrefixNameTable(com.sun.org.apache.xml.internal.dtm.ref.DTMStringPool poolRef)Set a reference pointer to the prefix name symbol table.
%REVIEW% Should this really be Public? Changing it while
DTM is in use would be a disaster.
m_prefixNames = poolRef;
|
| public void | setProperty(java.lang.String property, java.lang.Object value)For the moment all the run time properties are ignored by this
class.
|
| public void | skippedEntity(java.lang.String name)
processAccumulatedText();
//%TBD%
|
| public void | startCDATA()
// No-op in DTM
|
| public void | startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId)
// No-op in DTM
|
| public void | startDocument()
appendStartDocument();
|
| public void | startElement(java.lang.String namespaceURI, java.lang.String localName, java.lang.String qName, org.xml.sax.Attributes atts)
processAccumulatedText();
// %TBD% Split prefix off qname
String prefix=null;
int colon=qName.indexOf(':");
if(colon>0)
prefix=qName.substring(0,colon);
// %TBD% Where do we pool expandedName, or is it just the union, or...
/**/System.out.println("Prefix="+prefix+" index="+m_prefixNames.stringToIndex(prefix));
appendStartElement(m_nsNames.stringToIndex(namespaceURI),
m_localNames.stringToIndex(localName),
m_prefixNames.stringToIndex(prefix)); /////// %TBD%
// %TBD% I'm assuming that DTM will require resequencing of
// NS decls before other attrs, hence two passes are taken.
// %TBD% Is there an easier way to test for NSDecl?
int nAtts=(atts==null) ? 0 : atts.getLength();
// %TBD% Countdown is more efficient if nobody cares about sequence.
for(int i=nAtts-1;i>=0;--i)
{
qName=atts.getQName(i);
if(qName.startsWith("xmlns:") || "xmlns".equals(qName))
{
prefix=null;
colon=qName.indexOf(':");
if(colon>0)
{
prefix=qName.substring(0,colon);
}
else
{
// %REVEIW% Null or ""?
prefix=null; // Default prefix
}
appendNSDeclaration(
m_prefixNames.stringToIndex(prefix),
m_nsNames.stringToIndex(atts.getValue(i)),
atts.getType(i).equalsIgnoreCase("ID"));
}
}
for(int i=nAtts-1;i>=0;--i)
{
qName=atts.getQName(i);
if(!(qName.startsWith("xmlns:") || "xmlns".equals(qName)))
{
// %TBD% I hate having to extract the prefix into a new
// string when we may never use it. Consider pooling whole
// qNames, which are already strings?
prefix=null;
colon=qName.indexOf(':");
if(colon>0)
{
prefix=qName.substring(0,colon);
localName=qName.substring(colon+1);
}
else
{
prefix=""; // Default prefix
localName=qName;
}
m_char.append(atts.getValue(i)); // Single-string value
int contentEnd=m_char.length();
if(!("xmlns".equals(prefix) || "xmlns".equals(qName)))
appendAttribute(m_nsNames.stringToIndex(atts.getURI(i)),
m_localNames.stringToIndex(localName),
m_prefixNames.stringToIndex(prefix),
atts.getType(i).equalsIgnoreCase("ID"),
m_char_current_start, contentEnd-m_char_current_start);
m_char_current_start=contentEnd;
}
}
|
| public void | startEntity(java.lang.String name)
// No-op in DTM
|
| public void | startPrefixMapping(java.lang.String prefix, java.lang.String uri)
// No-op in DTM, handled during element/attr processing?
|
| public boolean | supportsPreStripping()Return true if the xsl:strip-space or xsl:preserve-space was processed
during construction of the DTM document.
%REVEIW% Presumes a 1:1 mapping from DTM to Document, since
we aren't saying which Document to query...? return false;
|
