org.enhydra.xml.lazydom.LazyElementNoNS Maven / Gradle / Ivy
The newest version!
/*
* Enhydra Java Application Server Project
*
* The contents of this file are subject to the Enhydra Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License on
* the Enhydra web site ( http://www.enhydra.org/ ).
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific terms governing rights and limitations
* under the License.
*
* The Initial Developer of the Enhydra Application Server is Lutris
* Technologies, Inc. The Enhydra Application Server and portions created
* by Lutris Technologies, Inc. are Copyright Lutris Technologies, Inc.
* All Rights Reserved.
*
* Contributor(s):
*
* $Id: LazyElementNoNS.java,v 1.4 2005/01/26 08:29:24 jkjome Exp $
*/
package org.enhydra.xml.lazydom;
import org.enhydra.apache.xerces.dom.ElementImpl;
import org.enhydra.apache.xerces.dom.NodeImpl;
import org.enhydra.xml.io.PreFormattedText;
import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
/**
* Implementation of the DOM Element without namespaces that supports lazy
* instantiation of a template DOM. It is used by HTML, where non-standard
* element names containing `:' are occasionally invented. If this was
* derived from ElementNSImpl, it would do validation on the name and generate
* an error.
*/
public class LazyElementNoNS extends ElementImpl implements LazyElement {
/**
* Constructor.
* @param ownerDoc The document that owns this node.
* @param template If not-null, get the parameters from this template.
* @param qualifiedName The tag name for the node.
* Will be ignored if template is not-null.
*/
protected LazyElementNoNS(LazyDocument ownerDoc,
LazyElement template,
String qualifiedName) {
super(ownerDoc,
(template != null) ? template.getNodeName() : qualifiedName);
if (template != null) {
fTemplateNode = template;
fNodeId = template.getNodeId();
} else {
// Not created from a template, mark all as expanded.
fParentExpanded = true;
fChildrenExpanded = true;
fAttributesExpanded = true;
}
}
//-------------------------------------------------------------------------
// LazyElementNoNS specific
//-------------------------------------------------------------------------
/**
* Template for this element.
*/
private LazyElement fTemplateNode = null;
/**
* Mark the node as a template node and associated preformatted text.
* @see LazyNode#makeTemplateNode
* @see PreFormattedText#setPreFormattedText
*/
public void makeTemplateNode(int nodeId,
String text) {
fNodeId = nodeId;
fIsTemplateNode = true;
fPreFormattedText = text;
}
/**
* Get the template for this node.
* @see LazyNode#getTemplateNode
*/
public LazyElement getTemplateElement() {
return fTemplateNode;
}
/**
* @see Node#cloneNode
*/
public Node cloneNode(boolean deep) {
// If children are copied, we must expand now.
if (deep && !fChildrenExpanded) {
expandChildren();
}
// Attributes are always copied
if (!fAttributesExpanded) {
expandAttributes();
}
// This does a clone(), must clean up all fields.
LazyElementNoNS newElement = (LazyElementNoNS)super.cloneNode(deep);
newElement.fNodeId = NULL_NODE_ID;
newElement.fParentExpanded = true;
newElement.fChildrenExpanded = true;
newElement.fAttributesExpanded = true;
return newElement;
}
//-------------------------------------------------------------------------
// LazyNode support
//-------------------------------------------------------------------------
/*
* Node id for this element.
*/
private int fNodeId = NULL_NODE_ID;
/**
* Is this a template node?
*/
private boolean fIsTemplateNode;
/*
* @see LazyNode#makeTemplateNode
*/
public void makeTemplateNode(int nodeId) {
fNodeId = nodeId;
fIsTemplateNode = true;
}
/**
* @see LazyNode#getNodeId
*/
public int getNodeId() {
return fNodeId;
}
/**
* @see LazyNode#isTemplateNode
*/
public boolean isTemplateNode() {
return fIsTemplateNode;
}
/**
* @see LazyNode#getTemplateNode
*/
public LazyNode getTemplateNode() {
return fTemplateNode;
}
/**
* @see LazyNode#templateClone
*/
public LazyNode templateClone(Document ownerDocument) {
return new LazyElementNoNS((LazyDocument)ownerDocument, this, null);
}
/**
* Set the node value, invalidating the id. All node data is modified
* by this routine.
* @see org.w3c.dom.Node#setNodeValue
*/
public void setNodeValue(String value) {
fNodeId = NULL_NODE_ID;
super.setNodeValue(value);
}
//-------------------------------------------------------------------------
// LazyParent support
//-------------------------------------------------------------------------
/**
* Parent and children expanded flags.
*/
private boolean fParentExpanded = false;
private boolean fChildrenExpanded = false;
/**
* @see LazyParent#isParentExpanded()
*/
public boolean isParentExpanded() {
return fParentExpanded;
}
/**
* @see LazyParent#setParentExpanded
*/
public void setParentExpanded() {
fParentExpanded = true;
}
/**
* @see LazyParent#setParentWhileExpanding
*/
public void setParentWhileExpanding(Node parent) {
ownerNode = (NodeImpl)parent;
flags |= OWNED;
fParentExpanded = true;
}
/**
* @see LazyParent#areChildrenExpanded()
*/
public boolean areChildrenExpanded() {
return fChildrenExpanded;
}
/**
* @see LazyParent#setChildrenExpanded
*/
public void setChildrenExpanded() {
fChildrenExpanded = true;
}
/**
* @see LazyParent#appendChildWhileExpanding
*/
public void appendChildWhileExpanding(Node child) {
super.insertBefore(child, null);
}
/**
* Expand the parent of this element, if it is not already expanded.
*/
private void expandParent() {
((LazyDocument)getOwnerDocument()).doExpandParent(this);
}
/**
* Expand the children of this element, if they are not already expanded.
*/
protected void expandChildren() {
((LazyDocument)getOwnerDocument()).doExpandChildren(this);
}
/**
* @see org.w3c.dom.Node#getParentNode
*/
public Node getParentNode() {
if (!fParentExpanded) {
expandParent();
}
return super.getParentNode();
}
/**
* @see org.w3c.dom.Node#getChildNodes
*/
public NodeList getChildNodes() {
if (!fChildrenExpanded) {
expandChildren();
}
return super.getChildNodes();
}
/**
* @see org.w3c.dom.Node#getFirstChild
*/
public Node getFirstChild() {
if (!fChildrenExpanded) {
expandChildren();
}
return super.getFirstChild();
}
/**
* @see org.w3c.dom.Node#getLastChild
*/
public Node getLastChild() {
if (!fChildrenExpanded) {
expandChildren();
}
return super.getLastChild();
}
/**
* @see org.w3c.dom.Node#getPreviousSibling
*/
public Node getPreviousSibling() {
if (!fParentExpanded) {
expandParent();
}
return super.getPreviousSibling();
}
/**
* @see org.w3c.dom.Node#getNextSibling
*/
public Node getNextSibling() {
if (!fParentExpanded) {
expandParent();
}
return super.getNextSibling();
}
/**
* @see org.w3c.dom.Node#insertBefore
*/
public Node insertBefore(Node newChild,
Node refChild)
throws DOMException {
if (!fChildrenExpanded) {
expandChildren();
}
return super.insertBefore(newChild, refChild);
}
/**
* @see org.w3c.dom.Node#replaceChild
*/
public Node replaceChild(Node newChild,
Node oldChild)
throws DOMException {
if (!fChildrenExpanded) {
expandChildren();
}
return super.replaceChild(newChild, oldChild);
}
/**
* @see org.w3c.dom.Node#removeChild
*/
public Node removeChild(Node oldChild)
throws DOMException {
if (!fChildrenExpanded) {
expandChildren();
}
return super.removeChild(oldChild);
}
/**
* @see org.w3c.dom.Node#appendChild
*/
public Node appendChild(Node newChild)
throws DOMException {
if (!fChildrenExpanded) {
expandChildren();
}
return super.appendChild(newChild);
}
/**
* @see org.w3c.dom.Node#hasChildNodes
*/
public boolean hasChildNodes() {
if (!fChildrenExpanded) {
return fTemplateNode.hasChildNodes();
} else {
return super.hasChildNodes();
}
}
/**
* @see org.w3c.dom.Node#normalize
*/
public void normalize() {
if (!fChildrenExpanded) {
expandChildren();
}
super.normalize();
}
//-------------------------------------------------------------------------
// Attribute support
//-------------------------------------------------------------------------
/**
* Attributes expanded flag.
*/
private boolean fAttributesExpanded = false;
/**
* Are the attributes of this node expanded?
*/
public boolean areAttributesExpanded() {
return fAttributesExpanded;
}
/**
* Do work of expanding attributes. Must be called while
* synchronized on the owner document.
*/
private void doExpandAttributes(LazyDocument doc) {
doc.enterExpansion();
try {
NamedNodeMap templateAttrs = fTemplateNode.getAttributes();
if (templateAttrs != null) {
int len = templateAttrs.getLength();
for (int idx = 0; idx < len; idx++) {
Attr attr = (Attr)doc.getNodeFromTemplate((LazyNode)templateAttrs.item(idx));
super.setAttributeNode(attr);
}
}
fAttributesExpanded = true;
} finally {
doc.leaveExpansion();
}
}
/**
* Expand the attributes of this element, if they are not already
* expanded.
*/
private void expandAttributes() {
LazyDocument doc = (LazyDocument)getOwnerDocument();
synchronized (doc) {
if (!fAttributesExpanded) {
doExpandAttributes(doc);
}
}
}
/**
* @see org.w3c.dom.Node#getAttributes
*/
public NamedNodeMap getAttributes() {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.getAttributes();
}
/**
* @see org.w3c.dom.Element#getAttribute
*/
public String getAttribute(String name) {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.getAttribute(name);
}
/**
* @see org.w3c.dom.Element#setAttribute
*/
public void setAttribute(String name,
String value) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
super.setAttribute(name, value);
}
/**
* @see org.w3c.dom.Element#removeAttribute
*/
public void removeAttribute(String name) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
super.removeAttribute(name);
}
/**
* @see org.w3c.dom.Element#getAttributeNode
*/
public Attr getAttributeNode(String name) {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.getAttributeNode(name);
}
/**
* @see org.w3c.dom.Element#setAttributeNode
*/
public Attr setAttributeNode(Attr newAttr) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.setAttributeNode(newAttr);
}
/**
* @see org.w3c.dom.Element#removeAttributeNode
*/
public Attr removeAttributeNode(Attr oldAttr) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.removeAttributeNode(oldAttr);
}
/**
* @see org.w3c.dom.Element#getAttributeNS
*/
public String getAttributeNS(String namespaceURI,
String localName) {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.getAttributeNS(namespaceURI, localName);
}
/**
* @see org.w3c.dom.Element#setAttributeNS
*/
public void setAttributeNS(String namespaceURI,
String qualifiedName,
String value) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
super.setAttributeNS(namespaceURI, qualifiedName, value);
}
/**
* @see org.w3c.dom.Element#removeAttributeNS
*/
public void removeAttributeNS(String namespaceURI,
String localName) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
super.removeAttributeNS(namespaceURI, localName);
}
/**
* @see org.w3c.dom.Element#getAttributeNodeNS
*/
public Attr getAttributeNodeNS(String namespaceURI,
String localName) {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.getAttributeNodeNS(namespaceURI, localName);
}
/**
* @see org.w3c.dom.Element#setAttributeNodeNS
*/
public Attr setAttributeNodeNS(Attr newAttr) throws DOMException {
if (!fAttributesExpanded) {
expandAttributes();
}
return super.setAttributeNodeNS(newAttr);
}
//-------------------------------------------------------------------------
// PreFormattedText specific
//-------------------------------------------------------------------------
/**
* Pre-formatted text associated with the node.
*/
private String fPreFormattedText;
/**
* @see PreFormattedText#getPreFormattedText
*/
public String getPreFormattedText() {
return fPreFormattedText;
}
/**
* @see PreFormattedText#setPreFormattedText
*/
public void setPreFormattedText(String text) {
fPreFormattedText = text;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy