Java Node.PROCESSING_INSTRUCTION_NODE属性代码示例

void checkIndex(Node refNode, int offset) throws DOMException
{
    if (offset < 0) {
        throw new DOMException(
            DOMException.INDEX_SIZE_ERR, 
            DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "INDEX_SIZE_ERR", null));
	}

    int type = refNode.getNodeType();
    
    // If the node contains text, ensure that the
    // offset of the range is <= to the length of the text
    if (type == Node.TEXT_NODE
        || type == Node.CDATA_SECTION_NODE
        || type == Node.COMMENT_NODE
        || type == Node.PROCESSING_INSTRUCTION_NODE) {
        if (offset > refNode.getNodeValue().length()) {
            throw new DOMException(DOMException.INDEX_SIZE_ERR, 
            DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "INDEX_SIZE_ERR", null));
        }
    }
    else {
        // Since the node is not text, ensure that the offset
        // is valid with respect to the number of child nodes
        if (offset > refNode.getChildNodes().getLength()) {
		throw new DOMException(DOMException.INDEX_SIZE_ERR, 
            DOMMessageFormatter.formatMessage(DOMMessageFormatter.DOM_DOMAIN, "INDEX_SIZE_ERR", null));
        }
    }
}
 

/**
 * Record baseURI information for the Element (by adding xml:base attribute)
 * or for the ProcessingInstruction (by setting a baseURI field)
 * Non deferred DOM.
 *
 * @param node
 */
protected final void handleBaseURI (Node node){
    if (fDocumentImpl != null) {
        // REVISIT: remove dependency on our implementation when
        //          DOM L3 becomes REC

        String baseURI = null;
        short nodeType = node.getNodeType ();

        if (nodeType == Node.ELEMENT_NODE) {
            // if an element already has xml:base attribute
            // do nothing
            if (fNamespaceAware) {
                if (((Element)node).getAttributeNodeNS ("http://www.w3.org/XML/1998/namespace","base")!=null) {
                    return;
                }
            } else if (((Element)node).getAttributeNode ("xml:base") != null) {
                return;
            }
            // retrive the baseURI from the entity reference
            baseURI = ((EntityReferenceImpl)fCurrentNode).getBaseURI ();
            if (baseURI !=null && !baseURI.equals (fDocumentImpl.getDocumentURI ())) {
                if (fNamespaceAware) {
                    ((Element)node).setAttributeNS ("http://www.w3.org/XML/1998/namespace", "xml:base", baseURI);
                } else {
                    ((Element)node).setAttribute ("xml:base", baseURI);
                }
            }
        }
        else if (nodeType == Node.PROCESSING_INSTRUCTION_NODE) {

            baseURI = ((EntityReferenceImpl)fCurrentNode).getBaseURI ();
            if (baseURI !=null && fErrorHandler != null) {
                DOMErrorImpl error = new DOMErrorImpl ();
                error.fType = "pi-base-uri-not-preserved";
                error.fRelatedData = baseURI;
                error.fSeverity = DOMError.SEVERITY_WARNING;
                fErrorHandler.getErrorHandler ().handleError (error);
            }
        }
    }
}
 

final boolean hasTextContent(Node child) {
    return child.getNodeType() != Node.COMMENT_NODE &&
        child.getNodeType() != Node.PROCESSING_INSTRUCTION_NODE &&
        (child.getNodeType() != Node.TEXT_NODE ||
         ((TextImpl) child).isIgnorableWhitespace() == false);
}
 

/** Do processing for the start of a node. */
private void beginNode(Node node) {
    switch (node.getNodeType()) {
        case Node.ELEMENT_NODE:
            fCurrentElement = node;
            // push namespace context
            fNamespaceContext.pushContext();
            // start element
            fillQName(fElementQName, node);
            processAttributes(node.getAttributes());
            fSchemaValidator.startElement(fElementQName, fAttributes, null);
            break;
        case Node.TEXT_NODE:
            if (fDOMValidatorHandler != null) {
                fDOMValidatorHandler.setIgnoringCharacters(true);
                sendCharactersToValidator(node.getNodeValue());
                fDOMValidatorHandler.setIgnoringCharacters(false);
                fDOMValidatorHandler.characters((Text) node);
            }
            else {
                sendCharactersToValidator(node.getNodeValue());
            }
            break;
        case Node.CDATA_SECTION_NODE:
            if (fDOMValidatorHandler != null) {
                fDOMValidatorHandler.setIgnoringCharacters(true);
                fSchemaValidator.startCDATA(null);
                sendCharactersToValidator(node.getNodeValue());
                fSchemaValidator.endCDATA(null);
                fDOMValidatorHandler.setIgnoringCharacters(false);
                fDOMValidatorHandler.cdata((CDATASection) node);
            }
            else {
                fSchemaValidator.startCDATA(null);
                sendCharactersToValidator(node.getNodeValue());
                fSchemaValidator.endCDATA(null); 
            }
            break;
        case Node.PROCESSING_INSTRUCTION_NODE:
            /** 
             * The validator does nothing with processing instructions so bypass it.
             * Send the ProcessingInstruction node directly to the result builder.
             */
            if (fDOMValidatorHandler != null) {
                fDOMValidatorHandler.processingInstruction((ProcessingInstruction) node);
            }
            break;
        case Node.COMMENT_NODE:
            /** 
             * The validator does nothing with comments so bypass it.
             * Send the Comment node directly to the result builder.
             */
            if (fDOMValidatorHandler != null) {
                fDOMValidatorHandler.comment((Comment) node);
            }
            break;
        case Node.DOCUMENT_TYPE_NODE:
            /** 
             * Send the DocumentType node directly to the result builder.
             */
            if (fDOMValidatorHandler != null) {
                fDOMValidatorHandler.doctypeDecl((DocumentType) node);
            }
            break;
        default: // Ignore other node types.
            break;
    }
}
 

/**
 * Utility method for traversing a single node.
 * Does not properly handle a text node containing both the
 * start and end offsets.  Such nodes should
 * have been previously detected and been routed to traverseCharacterDataNode.
 * 
 * @param n      The node to be traversed.
 * 
 * @param isFullySelected
 *               Set to true if the node is fully selected.  Should be 
 *               false otherwise.
 *               Note that although the DOM 2 specification says that a 
 *               text node that is boththe start and end container is not
 *               selected, we treat it here as if it were partially 
 *               selected.
 * 
 * @param isLeft Is true if we are traversing the node as part of navigating
 *               the "left boundary" of the range.  If this value is false,
 *               it implies we are navigating the "right boundary" of the
 *               range.
 * 
 * @param how    Specifies what type of traversal is being
 *               requested (extract, clone, or delete).
 *               Legal values for this argument are:
 *               
 *               <ol>
 *               <li><code>EXTRACT_CONTENTS</code> - will simply
 *               return the original node.
 *               
 *               <li><code>CLONE_CONTENTS</code> - will leave the
 *               context tree of the range undisturbed, but will
 *               return a cloned node.
 *               
 *               <li><code>DELETE_CONTENTS</code> - will delete the
 *               node from it's parent, but will return null.
 *               </ol>
 * 
 * @return Returns a node that is the result of visiting the node.
 *         If the traversal operation is
 *         <code>DELETE_CONTENTS</code> the return value is null.
 */
private Node traverseNode( Node n, boolean isFullySelected, boolean isLeft, int how )
{
    if ( isFullySelected ) {
        return traverseFullySelected( n, how );
    }
    final short nodeType = n.getNodeType();
    if (nodeType == Node.TEXT_NODE ||
        nodeType == Node.CDATA_SECTION_NODE ||
        nodeType == Node.COMMENT_NODE ||
        nodeType == Node.PROCESSING_INSTRUCTION_NODE) {
        return traverseCharacterDataNode( n, isLeft, how );
    }
    return traversePartiallySelected( n, how );
}
 

/**
 * A short integer indicating what type of node this is. The named
 * constants for this value are defined in the org.w3c.dom.Node interface.
 */
public short getNodeType() {
    return Node.PROCESSING_INSTRUCTION_NODE;
}