You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commons-dev@ws.apache.org by ru...@apache.org on 2006/03/27 10:02:11 UTC
svn commit: r389047 [4/7] - in /webservices/commons/trunk/modules/axiom: ./
src/org/apache/axiom/om/impl/dom/ src/org/apache/axiom/om/impl/dom/factory/
src/org/apache/axiom/om/impl/dom/jaxp/
src/org/apache/axiom/om/impl/dom/msg/ src/org/apache/axiom/so...
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/ParentNode.java
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/ParentNode.java?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/ParentNode.java (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/ParentNode.java Mon Mar 27 00:02:06 2006
@@ -0,0 +1,460 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axiom.om.impl.dom;
+
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNode;
+import org.apache.axiom.om.impl.OMContainerEx;
+import org.apache.axiom.om.impl.OMNodeEx;
+import org.apache.axiom.om.impl.traverse.OMChildrenIterator;
+import org.apache.axiom.om.impl.traverse.OMChildrenQNameIterator;
+import org.w3c.dom.DOMException;
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+public abstract class ParentNode extends ChildNode implements OMContainerEx {
+
+ protected ChildNode firstChild;
+
+ protected ChildNode lastChild;
+
+ /**
+ * @param ownerDocument
+ */
+ protected ParentNode(DocumentImpl ownerDocument, OMFactory factory) {
+ super(ownerDocument, factory);
+ }
+
+ protected ParentNode(OMFactory factory) {
+ super(factory);
+ }
+
+ // /
+ // /OMContainer methods
+ // /
+
+ public void addChild(OMNode omNode) {
+ this.appendChild((Node) omNode);
+ }
+
+ public void buildNext() {
+ if (!this.done)
+ builder.next();
+ }
+
+ public Iterator getChildren() {
+ return new OMChildrenIterator(this.firstChild);
+ }
+
+ /**
+ * Returns an iterator of child nodes having a given qname.
+ *
+ * @see org.apache.axiom.om.OMContainer#getChildrenWithName
+ * (javax.xml.namespace.QName)
+ */
+ public Iterator getChildrenWithName(QName elementQName) throws OMException {
+ return new OMChildrenQNameIterator(getFirstOMChild(), elementQName);
+ }
+
+ /**
+ * Returns the first OMElement child node.
+ *
+ * @see org.apache.axiom.om.OMContainer#getFirstChildWithName
+ * (javax.xml.namespace.QName)
+ */
+ public OMElement getFirstChildWithName(QName elementQName)
+ throws OMException {
+ Iterator children = new OMChildrenQNameIterator(getFirstOMChild(),
+ elementQName);
+ while (children.hasNext()) {
+ OMNode node = (OMNode) children.next();
+
+ // Return the first OMElement node that is found
+ if (node instanceof OMElement) {
+ return (OMElement) node;
+ }
+ }
+ return null;
+ }
+
+ public OMNode getFirstOMChild() {
+ while ((firstChild == null) && !done) {
+ buildNext();
+ }
+ return firstChild;
+ }
+
+ public void setFirstChild(OMNode omNode) {
+ if (firstChild != null) {
+ ((OMNodeEx) omNode).setParent(this);
+ }
+ this.firstChild = (ChildNode) omNode;
+ }
+
+ // /
+ // /DOM Node methods
+ // /
+
+ public NodeList getChildNodes() {
+ if (!this.done) {
+ this.build();
+ }
+ return new NodeListImpl(this, null, null);
+ }
+
+ public Node getFirstChild() {
+ return (Node) this.getFirstOMChild();
+ }
+
+ public Node getLastChild() {
+ if (!this.done) {
+ this.build();
+ }
+ return this.lastChild;
+ }
+
+ public boolean hasChildNodes() {
+ while ((firstChild == null) && !done) {
+ buildNext();
+ }
+ return this.firstChild != null;
+ }
+
+ /**
+ * Inserts newChild before the refChild. If the refChild is null then the
+ * newChild is made the last child.
+ */
+ public Node insertBefore(Node newChild, Node refChild) throws DOMException {
+
+ ChildNode newDomChild = (ChildNode) newChild;
+ ChildNode refDomChild = (ChildNode) refChild;
+
+ if (this == newChild || !isAncestor(newChild)) {
+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "HIERARCHY_REQUEST_ERR", null));
+ }
+
+ if (!(this instanceof Document)
+ && !(this.ownerNode == newDomChild.getOwnerDocument())) {
+ throw new DOMException(DOMException.WRONG_DOCUMENT_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "WRONG_DOCUMENT_ERR", null));
+ }
+
+ if (this.isReadonly()) {
+ throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "NO_MODIFICATION_ALLOWED_ERR", null));
+ }
+
+ if (this instanceof Document) {
+ if (((DocumentImpl) this).documentElement != null
+ && !(newDomChild instanceof CommentImpl)) {
+ // Throw exception since there cannot be two document elements
+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "HIERARCHY_REQUEST_ERR", null));
+ } else if (newDomChild instanceof ElementImpl) {
+ if (newDomChild.parentNode == null) {
+ newDomChild.parentNode = this;
+ }
+ // set the document element
+ ((DocumentImpl) this).documentElement = (ElementImpl) newDomChild;
+ }
+ }
+
+ if (refChild == null) { // Append the child to the end of the list
+ // if there are no children
+ if (this.lastChild == null && firstChild == null) {
+ this.lastChild = newDomChild;
+ this.firstChild = newDomChild;
+ this.firstChild.isFirstChild(true);
+ newDomChild.setParent(this);
+ } else {
+ this.lastChild.nextSibling = newDomChild;
+ newDomChild.previousSibling = this.lastChild;
+
+ this.lastChild = newDomChild;
+ }
+ if (newDomChild.parentNode == null) {
+ newDomChild.parentNode = this;
+ }
+ return newChild;
+ } else {
+ Iterator children = this.getChildren();
+ boolean found = false;
+ while (children.hasNext()) {
+ ChildNode tempNode = (ChildNode) children.next();
+
+ if (tempNode.equals(refChild)) {
+ // RefChild found
+ if (this.firstChild == tempNode) { // If the refChild is the
+ // first child
+
+ if (newChild instanceof DocumentFragmentimpl) {
+ // The new child is a DocumentFragment
+ DocumentFragmentimpl docFrag =
+ (DocumentFragmentimpl) newChild;
+ this.firstChild = docFrag.firstChild;
+ docFrag.lastChild.nextSibling = refDomChild;
+ refDomChild.previousSibling =
+ docFrag.lastChild.nextSibling;
+
+ } else {
+
+ // Make the newNode the first Child
+ this.firstChild = newDomChild;
+
+ newDomChild.nextSibling = refDomChild;
+ refDomChild.previousSibling = newDomChild;
+
+ this.firstChild.isFirstChild(true);
+ refDomChild.isFirstChild(false);
+ newDomChild.previousSibling = null; // Just to be
+ // sure :-)
+
+ }
+ } else { // If the refChild is not the fist child
+ ChildNode previousNode = refDomChild.previousSibling;
+
+ if (newChild instanceof DocumentFragmentimpl) {
+ // the newChild is a document fragment
+ DocumentFragmentimpl docFrag =
+ (DocumentFragmentimpl) newChild;
+
+ previousNode.nextSibling = docFrag.firstChild;
+ docFrag.firstChild.previousSibling = previousNode;
+
+ docFrag.lastChild.nextSibling = refDomChild;
+ refDomChild.previousSibling = docFrag.lastChild;
+ } else {
+
+ previousNode.nextSibling = newDomChild;
+ newDomChild.previousSibling = previousNode;
+
+ newDomChild.nextSibling = refDomChild;
+ refDomChild.previousSibling = newDomChild;
+ }
+
+ }
+ found = true;
+ break;
+ }
+ }
+
+ if (!found) {
+ throw new DOMException(DOMException.NOT_FOUND_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "NOT_FOUND_ERR", null));
+ }
+
+ if (newDomChild.parentNode == null) {
+ newDomChild.parentNode = this;
+ }
+
+ return newChild;
+ }
+ }
+
+ /**
+ * Replaces the oldChild with the newChild.
+ */
+ public Node replaceChild(Node newChild, Node oldChild) throws DOMException {
+ ChildNode newDomChild = (ChildNode) newChild;
+ ChildNode oldDomChild = (ChildNode) oldChild;
+
+ if (this == newChild || !isAncestor(newChild)) {
+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "HIERARCHY_REQUEST_ERR", null));
+ }
+
+ if (!this.ownerNode.equals(newDomChild.ownerNode)) {
+ throw new DOMException(DOMException.WRONG_DOCUMENT_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "WRONG_DOCUMENT_ERR", null));
+ }
+
+ if (this.isReadonly()) {
+ throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "NO_MODIFICATION_ALLOWED_ERR", null));
+ }
+
+ Iterator children = this.getChildren();
+ boolean found = false;
+ while (children.hasNext()) {
+ ChildNode tempNode = (ChildNode) children.next();
+ if (tempNode.equals(oldChild)) {
+ if (newChild instanceof DocumentFragmentimpl) {
+ DocumentFragmentimpl docFrag =
+ (DocumentFragmentimpl) newDomChild;
+ ChildNode child = (ChildNode) docFrag.getFirstChild();
+ child.parentNode = this;
+ this.replaceChild(child, oldChild);
+ } else {
+ if (this.firstChild == oldDomChild) {
+
+ newDomChild.parentNode = this;
+
+ if(this.firstChild.nextSibling != null) {
+ this.firstChild.nextSibling.previousSibling = newDomChild;
+ newDomChild.nextSibling = this.firstChild.nextSibling;
+ }
+
+ //Cleanup the current first child
+ this.firstChild.parentNode = null;
+ this.firstChild.nextSibling = null;
+
+ //Set the new first child
+ this.firstChild = newDomChild;
+
+ } else {
+ newDomChild.nextSibling = oldDomChild.nextSibling;
+ newDomChild.previousSibling = oldDomChild.previousSibling;
+
+ oldDomChild.previousSibling.nextSibling = newDomChild;
+
+ // If the old child is not the last
+ if (oldDomChild.nextSibling != null) {
+ oldDomChild.nextSibling.previousSibling = newDomChild;
+ } else {
+ this.lastChild = newDomChild;
+ }
+
+ if (newDomChild.parentNode == null) {
+ newDomChild.parentNode = this;
+ }
+ }
+ }
+ found = true;
+
+ // remove the old child's references to this tree
+ oldDomChild.nextSibling = null;
+ oldDomChild.previousSibling = null;
+ oldDomChild.parentNode = null;
+ }
+ }
+
+ if (!found)
+ throw new DOMException(DOMException.NOT_FOUND_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR",
+ null));
+
+ return oldChild;
+ }
+
+ /**
+ * Removes the given child from the DOM Tree.
+ */
+ public Node removeChild(Node oldChild) throws DOMException {
+ // Check if this node is readonly
+ if (this.isReadonly()) {
+ throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "NO_MODIFICATION_ALLOWED_ERR", null));
+ }
+
+ // Check if the Child is there
+ Iterator children = this.getChildren();
+ boolean childFound = false;
+ while (children.hasNext()) {
+ ChildNode tempNode = (ChildNode) children.next();
+ if (tempNode.equals(oldChild)) {
+
+ if (this.firstChild == tempNode) {
+ // If this is the first child
+ this.firstChild = null;
+ this.lastChild = null;
+ tempNode.parentNode = null;
+ } else if (this.lastChild == tempNode) {
+ // not the first child, but the last child
+ ChildNode prevSib = tempNode.previousSibling;
+ prevSib.nextSibling = null;
+ tempNode.parentNode = null;
+ tempNode.previousSibling = null;
+ } else {
+
+ ChildNode oldDomChild = (ChildNode) oldChild;
+ ChildNode privChild = oldDomChild.previousSibling;
+
+ privChild.nextSibling = oldDomChild.nextSibling;
+ oldDomChild.nextSibling.previousSibling = privChild;
+
+ // Remove old child's references to this tree
+ oldDomChild.nextSibling = null;
+ oldDomChild.previousSibling = null;
+ }
+ // Child found
+ childFound = true;
+ }
+ }
+
+ if (!childFound)
+ throw new DOMException(DOMException.NOT_FOUND_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN, "NOT_FOUND_ERR",
+ null));
+
+ return oldChild;
+ }
+
+ private boolean isAncestor(Node newNode) {
+
+ // TODO isAncestor
+ return true;
+ }
+
+ public Node cloneNode(boolean deep) {
+
+ ParentNode newnode = (ParentNode) super.cloneNode(deep);
+
+ // set owner document
+ newnode.ownerNode = ownerNode;
+
+ // Need to break the association w/ original kids
+ newnode.firstChild = null;
+ newnode.lastChild = null;
+
+ // Then, if deep, clone the kids too.
+ if (deep) {
+ for (ChildNode child = firstChild; child != null;
+ child = child.nextSibling) {
+ newnode.appendChild(child.cloneNode(true));
+ }
+ }
+
+ return newnode;
+
+ }
+}
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/TextImpl.java
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/TextImpl.java?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/TextImpl.java (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/TextImpl.java Mon Mar 27 00:02:06 2006
@@ -0,0 +1,512 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axiom.om.impl.dom;
+
+import org.apache.axiom.attachments.DataHandlerUtils;
+import org.apache.axiom.om.OMAttribute;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.axiom.om.OMText;
+import org.apache.axiom.om.OMXMLParserWrapper;
+import org.apache.axiom.om.impl.OMOutputImpl;
+import org.apache.axiom.om.impl.mtom.MTOMStAXSOAPModelBuilder;
+import org.apache.axiom.om.util.Base64;
+import org.apache.axiom.om.util.UUIDGenerator;
+import org.w3c.dom.DOMException;
+import org.w3c.dom.Node;
+import org.w3c.dom.Text;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class TextImpl extends CharacterImpl implements Text, OMText {
+
+ private String mimeType;
+
+ private boolean optimize;
+
+ private boolean isBinary;
+
+ /**
+ *
+ */
+ private String contentID = null;
+
+ /**
+ * Field dataHandler contains the DataHandler. Declaring as Object to remove
+ * the dependency on Javax.activation.DataHandler
+ */
+ private Object dataHandlerObject = null;
+
+ /**
+ * Field nameSpace is used when serializing Binary stuff as MTOM optimized.
+ */
+ protected OMNamespace ns = null;
+
+ /**
+ * Field localName is used when serializing Binary stuff as MTOM optimized.
+ */
+ protected String localName = "Include";
+
+ /**
+ * Field attribute is used when serializing Binary stuff as MTOM optimized.
+ */
+ protected OMAttribute attribute;
+
+ /**
+ * Creates a text node with the given text required by the OMDOMFactory. The
+ * owner document should be set properly when appending this to a DOM tree.
+ *
+ * @param text
+ */
+ public TextImpl(String text, OMFactory factory) {
+ super(factory);
+ this.textValue = new StringBuffer(text);
+ this.done = true;
+ this.ns = new NamespaceImpl("http://www.w3.org/2004/08/xop/include",
+ "xop", factory);
+ }
+
+ /**
+ * @param contentID
+ * @param parent
+ * @param builder
+ * Used when the builder is encountered with a XOP:Include tag
+ * Stores a reference to the builder and the content-id. Supports
+ * deffered parsing of MIME messages
+ */
+ public TextImpl(String contentID, OMElement parent,
+ OMXMLParserWrapper builder, OMFactory factory) {
+ super((DocumentImpl) ((ParentNode) parent).getOwnerDocument(), factory);
+ this.contentID = contentID;
+ this.optimize = true;
+ this.isBinary = true;
+ this.done = true;
+ this.builder = builder;
+ this.ns = new NamespaceImpl("http://www.w3.org/2004/08/xop/include",
+ "xop", factory);
+ }
+
+ public TextImpl(String text, String mimeType, boolean optimize,
+ OMFactory factory) {
+ this(text, mimeType, optimize, true, factory);
+ }
+
+ public TextImpl(String text, String mimeType, boolean optimize,
+ boolean isBinary, OMFactory factory) {
+ this(text, factory);
+ this.mimeType = mimeType;
+ this.optimize = optimize;
+ this.isBinary = isBinary;
+ }
+
+ /**
+ * @param dataHandler
+ * @param optimize
+ * To send binary content. Created progrmatically.
+ */
+ public TextImpl(Object dataHandler, boolean optimize, OMFactory factory) {
+ super(factory);
+ this.dataHandlerObject = dataHandler;
+ this.isBinary = true;
+ this.optimize = optimize;
+ done = true;
+ this.ns = new NamespaceImpl("http://www.w3.org/2004/08/xop/include",
+ "xop", factory);
+ }
+
+ /**
+ * @param ownerNode
+ */
+ public TextImpl(DocumentImpl ownerNode, OMFactory factory) {
+ super(ownerNode, factory);
+ this.done = true;
+ this.ns = new NamespaceImpl("http://www.w3.org/2004/08/xop/include",
+ "xop", factory);
+ }
+
+ /**
+ * @param ownerNode
+ * @param value
+ */
+ public TextImpl(DocumentImpl ownerNode, String value, OMFactory factory) {
+ super(ownerNode, value, factory);
+ this.done = true;
+ this.ns = new NamespaceImpl("http://www.w3.org/2004/08/xop/include",
+ "xop", factory);
+ }
+
+ /**
+ * @param ownerNode
+ * @param value
+ */
+ public TextImpl(DocumentImpl ownerNode, String value, String mimeType,
+ boolean optimize, OMFactory factory) {
+ this(ownerNode, value, factory);
+ this.mimeType = mimeType;
+ this.optimize = optimize;
+ this.isBinary = true;
+ done = true;
+ }
+
+ /**
+ * Breaks this node into two nodes at the specified 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.
+ */
+ public Text splitText(int offset) throws DOMException {
+ if (this.isReadonly()) {
+ throw new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN,
+ "NO_MODIFICATION_ALLOWED_ERR", null));
+ }
+ if (offset < 0 || offset > this.textValue.length()) {
+ throw new DOMException(DOMException.INDEX_SIZE_ERR,
+ DOMMessageFormatter.formatMessage(
+ DOMMessageFormatter.DOM_DOMAIN, "INDEX_SIZE_ERR",
+ null));
+ }
+ String newValue = this.textValue.substring(offset);
+ this.deleteData(offset, this.textValue.length());
+
+ TextImpl newText = (TextImpl) this.getOwnerDocument().createTextNode(
+ newValue);
+
+ if (this.parentNode != null) {
+ newText.setParent(this.parentNode);
+ }
+
+ this.insertSiblingAfter(newText);
+
+ return newText;
+ }
+
+ // /
+ // /org.w3c.dom.Node methods
+ // /
+ public String getNodeName() {
+ return "#text";
+ }
+
+ public short getNodeType() {
+ return Node.TEXT_NODE;
+ }
+
+ // /
+ // /OMNode methods
+ // /
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.apache.axiom.om.OMNode#getType()
+ */
+ public int getType() throws OMException {
+ return Node.TEXT_NODE;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.apache.axiom.om.OMNode#setType(int)
+ */
+ public void setType(int nodeType) throws OMException {
+ // do not do anything here
+ // Its not clear why we should let someone change the type of a node
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.apache.axiom.om.OMNode#serialize(org.apache.axiom.om.OMOutput)
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ serializeLocal(omOutput);
+ }
+
+ public void serializeAndConsume(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ serializeLocal(omOutput);
+ }
+
+ public boolean isOptimized() {
+ return this.optimize;
+ }
+
+ public void setOptimize(boolean value) {
+ this.optimize = value;
+ }
+
+ public void discard() throws OMException {
+ if (done) {
+ this.detach();
+ } else {
+ builder.discard((OMElement) this.parentNode);
+ }
+ }
+
+ /**
+ * Writes the relevant output.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ private void writeOutput(OMOutputImpl omOutput) throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ int type = getType();
+ if (type == Node.TEXT_NODE || type == SPACE_NODE) {
+ writer.writeCharacters(this.getText());
+ } else if (type == Node.CDATA_SECTION_NODE) {
+ writer.writeCData(this.getText());
+ } else if (type == Node.ENTITY_REFERENCE_NODE) {
+ writer.writeEntityRef(this.getText());
+ }
+ }
+
+ public String getText() {
+ if (this.textValue != null) {
+ return this.textValue.toString();
+ } else {
+ try {
+ InputStream inStream;
+ inStream = this.getInputStream();
+ // int x = inStream.available();
+ byte[] data;
+ StringBuffer text = new StringBuffer();
+ do {
+ data = new byte[1024];
+ int len;
+ while ((len = inStream.read(data)) > 0) {
+ byte[] temp = new byte[len];
+ System.arraycopy(data, 0, temp, 0, len);
+ text.append(Base64.encode(temp));
+ }
+
+ } while (inStream.available() > 0);
+ return text.toString();
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+ }
+
+ public String getNodeValue() throws DOMException {
+ return this.getText();
+ }
+
+ public String getContentID() {
+ if (contentID == null) {
+ contentID = UUIDGenerator.getUUID() + "@apache.org";
+ }
+ return this.contentID;
+ }
+
+ public Object getDataHandler() {
+ /*
+ * this should return a DataHandler containing the binary data
+ * reperesented by the Base64 strings stored in OMText
+ */
+ if (textValue != null & isBinary) {
+ return DataHandlerUtils
+ .getDataHandlerFromText(textValue.toString(), mimeType);
+ } else {
+
+ if (dataHandlerObject == null) {
+ if (contentID == null) {
+ throw new RuntimeException("ContentID is null");
+ }
+ dataHandlerObject = ((MTOMStAXSOAPModelBuilder) builder)
+ .getDataHandler(contentID);
+ }
+ return dataHandlerObject;
+ }
+ }
+
+ public java.io.InputStream getInputStream() throws OMException {
+ if (isBinary) {
+ if (dataHandlerObject == null) {
+ getDataHandler();
+ }
+ InputStream inStream;
+ javax.activation.DataHandler dataHandler = (javax.activation.DataHandler) dataHandlerObject;
+ try {
+ inStream = dataHandler.getDataSource().getInputStream();
+ } catch (IOException e) {
+ throw new OMException(
+ "Cannot get InputStream from DataHandler." + e);
+ }
+ return inStream;
+ } else {
+ throw new OMException("Unsupported Operation");
+ }
+ }
+
+ private void serializeLocal(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ if (!this.isBinary) {
+ writeOutput(omOutput);
+ } else {
+ if (omOutput.isOptimized()) {
+ if (contentID == null) {
+ contentID = omOutput.getNextContentId();
+ }
+ // send binary as MTOM optimised
+ this.attribute = new AttrImpl(this.ownerNode, "href",
+ new NamespaceImpl("", "", this.factory),
+ "cid:" + getContentID(),
+ this.factory);
+ this.serializeStartpart(omOutput);
+ omOutput.writeOptimized(this);
+ omOutput.getXmlStreamWriter().writeEndElement();
+ } else {
+ omOutput.getXmlStreamWriter().writeCharacters(this.getText());
+ }
+ }
+ }
+
+ /*
+ * Methods to copy from OMSerialize utils.
+ */
+ private void serializeStartpart(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ String nameSpaceName;
+ String writer_prefix;
+ String prefix;
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (this.ns != null) {
+ nameSpaceName = this.ns.getName();
+ writer_prefix = writer.getPrefix(nameSpaceName);
+ prefix = this.ns.getPrefix();
+ if (nameSpaceName != null) {
+ if (writer_prefix != null) {
+ writer
+ .writeStartElement(nameSpaceName, this
+ .getLocalName());
+ } else {
+ if (prefix != null) {
+ writer.writeStartElement(prefix, this.getLocalName(),
+ nameSpaceName);
+ // TODO FIX ME
+ // writer.writeNamespace(prefix, nameSpaceName);
+ writer.setPrefix(prefix, nameSpaceName);
+ } else {
+ writer.writeStartElement(nameSpaceName, this
+ .getLocalName());
+ writer.writeDefaultNamespace(nameSpaceName);
+ writer.setDefaultNamespace(nameSpaceName);
+ }
+ }
+ } else {
+ writer.writeStartElement(this.getLocalName());
+ }
+ } else {
+ writer.writeStartElement(this.getLocalName());
+ }
+ // add the elements attribute "href"
+ serializeAttribute(this.attribute, omOutput);
+ // add the namespace
+ serializeNamespace(this.ns, omOutput);
+ }
+
+ /**
+ * Method serializeAttribute.
+ *
+ * @param attr
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ static void serializeAttribute(OMAttribute attr, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ // first check whether the attribute is associated with a namespace
+ OMNamespace ns = attr.getNamespace();
+ String prefix;
+ String namespaceName;
+ if (ns != null) {
+ // add the prefix if it's availble
+ prefix = ns.getPrefix();
+ namespaceName = ns.getName();
+ if (prefix != null) {
+ writer.writeAttribute(prefix, namespaceName, attr
+ .getLocalName(), attr.getAttributeValue());
+ } else {
+ writer.writeAttribute(namespaceName, attr.getLocalName(), attr
+ .getAttributeValue());
+ }
+ } else {
+ writer
+ .writeAttribute(attr.getLocalName(), attr
+ .getAttributeValue());
+ }
+ }
+
+ /**
+ * Method serializeNamespace.
+ *
+ * @param namespace
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ static void serializeNamespace(OMNamespace namespace, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (namespace != null) {
+ String uri = namespace.getName();
+ String ns_prefix = namespace.getPrefix();
+ writer.writeNamespace(ns_prefix, namespace.getName());
+ writer.setPrefix(ns_prefix, uri);
+ }
+ }
+
+ public Node cloneNode(boolean deep) {
+ TextImpl textImpl = new TextImpl(this.textValue.toString(), this.factory);
+ textImpl.setOwnerDocument(this.ownerNode);
+ return textImpl;
+ }
+
+ /*
+ * DOM-Level 3 methods
+ */
+
+ public String getWholeText() {
+ // TODO TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public boolean isElementContentWhitespace() {
+ // TODO TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public Text replaceWholeText(String arg0) throws DOMException {
+ // TODO TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public String toString() {
+ return (this.textValue != null) ? textValue.toString() : "";
+ }
+
+}
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/XMLChar.java
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/XMLChar.java?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/XMLChar.java (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/XMLChar.java Mon Mar 27 00:02:06 2006
@@ -0,0 +1,644 @@
+/*
+ * Copyright 1999-2002,2004 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.axiom.om.impl.dom;
+
+/**
+ * This class defines the basic XML character properties. The data
+ * in this class can be used to verify that a character is a valid
+ * XML character or if the character is a space, name start, or name
+ * character.
+ * <p>
+ * A series of convenience methods are supplied to ease the burden
+ * of the developer. Because inlining the checks can improve per
+ * character performance, the tables of character properties are
+ * public. Using the character as an index into the <code>CHARS</code>
+ * array and applying the appropriate mask flag (e.g.
+ * <code>MASK_VALID</code>), yields the same results as calling the
+ * convenience methods. There is one exception: check the comments
+ * for the <code>isValid</code> method for details.
+ *
+ */
+public class XMLChar {
+
+ //
+ // Constants
+ //
+
+ /** Character flags. */
+ private static final byte[] CHARS = new byte[1 << 16];
+
+ /** Valid character mask. */
+ public static final int MASK_VALID = 0x01;
+
+ /** Space character mask. */
+ public static final int MASK_SPACE = 0x02;
+
+ /** Name start character mask. */
+ public static final int MASK_NAME_START = 0x04;
+
+ /** Name character mask. */
+ public static final int MASK_NAME = 0x08;
+
+ /** Pubid character mask. */
+ public static final int MASK_PUBID = 0x10;
+
+ /**
+ * Content character mask. Special characters are those that can
+ * be considered the start of markup, such as '<' and '&'.
+ * The various newline characters are considered special as well.
+ * All other valid XML characters can be considered content.
+ * <p>
+ * This is an optimization for the inner loop of character scanning.
+ */
+ public static final int MASK_CONTENT = 0x20;
+
+ /** NCName start character mask. */
+ public static final int MASK_NCNAME_START = 0x40;
+
+ /** NCName character mask. */
+ public static final int MASK_NCNAME = 0x80;
+
+ //
+ // Static initialization
+ //
+
+ static {
+
+ //
+ // [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] |
+ // [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+ //
+
+ int charRange[] = {
+ 0x0009, 0x000A, 0x000D, 0x000D, 0x0020, 0xD7FF, 0xE000, 0xFFFD,
+ };
+
+ //
+ // [3] S ::= (#x20 | #x9 | #xD | #xA)+
+ //
+
+ int spaceChar[] = {
+ 0x0020, 0x0009, 0x000D, 0x000A,
+ };
+
+ //
+ // [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' |
+ // CombiningChar | Extender
+ //
+
+ int nameChar[] = {
+ 0x002D, 0x002E, // '-' and '.'
+ };
+
+ //
+ // [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ //
+
+ int nameStartChar[] = {
+ 0x003A, 0x005F, // ':' and '_'
+ };
+
+ //
+ // [13] PubidChar ::= #x20 | 0xD | 0xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
+ //
+
+ int pubidChar[] = {
+ 0x000A, 0x000D, 0x0020, 0x0021, 0x0023, 0x0024, 0x0025, 0x003D,
+ 0x005F
+ };
+
+ int pubidRange[] = {
+ 0x0027, 0x003B, 0x003F, 0x005A, 0x0061, 0x007A
+ };
+
+ //
+ // [84] Letter ::= BaseChar | Ideographic
+ //
+
+ int letterRange[] = {
+ // BaseChar
+ 0x0041, 0x005A, 0x0061, 0x007A, 0x00C0, 0x00D6, 0x00D8, 0x00F6,
+ 0x00F8, 0x0131, 0x0134, 0x013E, 0x0141, 0x0148, 0x014A, 0x017E,
+ 0x0180, 0x01C3, 0x01CD, 0x01F0, 0x01F4, 0x01F5, 0x01FA, 0x0217,
+ 0x0250, 0x02A8, 0x02BB, 0x02C1, 0x0388, 0x038A, 0x038E, 0x03A1,
+ 0x03A3, 0x03CE, 0x03D0, 0x03D6, 0x03E2, 0x03F3, 0x0401, 0x040C,
+ 0x040E, 0x044F, 0x0451, 0x045C, 0x045E, 0x0481, 0x0490, 0x04C4,
+ 0x04C7, 0x04C8, 0x04CB, 0x04CC, 0x04D0, 0x04EB, 0x04EE, 0x04F5,
+ 0x04F8, 0x04F9, 0x0531, 0x0556, 0x0561, 0x0586, 0x05D0, 0x05EA,
+ 0x05F0, 0x05F2, 0x0621, 0x063A, 0x0641, 0x064A, 0x0671, 0x06B7,
+ 0x06BA, 0x06BE, 0x06C0, 0x06CE, 0x06D0, 0x06D3, 0x06E5, 0x06E6,
+ 0x0905, 0x0939, 0x0958, 0x0961, 0x0985, 0x098C, 0x098F, 0x0990,
+ 0x0993, 0x09A8, 0x09AA, 0x09B0, 0x09B6, 0x09B9, 0x09DC, 0x09DD,
+ 0x09DF, 0x09E1, 0x09F0, 0x09F1, 0x0A05, 0x0A0A, 0x0A0F, 0x0A10,
+ 0x0A13, 0x0A28, 0x0A2A, 0x0A30, 0x0A32, 0x0A33, 0x0A35, 0x0A36,
+ 0x0A38, 0x0A39, 0x0A59, 0x0A5C, 0x0A72, 0x0A74, 0x0A85, 0x0A8B,
+ 0x0A8F, 0x0A91, 0x0A93, 0x0AA8, 0x0AAA, 0x0AB0, 0x0AB2, 0x0AB3,
+ 0x0AB5, 0x0AB9, 0x0B05, 0x0B0C, 0x0B0F, 0x0B10, 0x0B13, 0x0B28,
+ 0x0B2A, 0x0B30, 0x0B32, 0x0B33, 0x0B36, 0x0B39, 0x0B5C, 0x0B5D,
+ 0x0B5F, 0x0B61, 0x0B85, 0x0B8A, 0x0B8E, 0x0B90, 0x0B92, 0x0B95,
+ 0x0B99, 0x0B9A, 0x0B9E, 0x0B9F, 0x0BA3, 0x0BA4, 0x0BA8, 0x0BAA,
+ 0x0BAE, 0x0BB5, 0x0BB7, 0x0BB9, 0x0C05, 0x0C0C, 0x0C0E, 0x0C10,
+ 0x0C12, 0x0C28, 0x0C2A, 0x0C33, 0x0C35, 0x0C39, 0x0C60, 0x0C61,
+ 0x0C85, 0x0C8C, 0x0C8E, 0x0C90, 0x0C92, 0x0CA8, 0x0CAA, 0x0CB3,
+ 0x0CB5, 0x0CB9, 0x0CE0, 0x0CE1, 0x0D05, 0x0D0C, 0x0D0E, 0x0D10,
+ 0x0D12, 0x0D28, 0x0D2A, 0x0D39, 0x0D60, 0x0D61, 0x0E01, 0x0E2E,
+ 0x0E32, 0x0E33, 0x0E40, 0x0E45, 0x0E81, 0x0E82, 0x0E87, 0x0E88,
+ 0x0E94, 0x0E97, 0x0E99, 0x0E9F, 0x0EA1, 0x0EA3, 0x0EAA, 0x0EAB,
+ 0x0EAD, 0x0EAE, 0x0EB2, 0x0EB3, 0x0EC0, 0x0EC4, 0x0F40, 0x0F47,
+ 0x0F49, 0x0F69, 0x10A0, 0x10C5, 0x10D0, 0x10F6, 0x1102, 0x1103,
+ 0x1105, 0x1107, 0x110B, 0x110C, 0x110E, 0x1112, 0x1154, 0x1155,
+ 0x115F, 0x1161, 0x116D, 0x116E, 0x1172, 0x1173, 0x11AE, 0x11AF,
+ 0x11B7, 0x11B8, 0x11BC, 0x11C2, 0x1E00, 0x1E9B, 0x1EA0, 0x1EF9,
+ 0x1F00, 0x1F15, 0x1F18, 0x1F1D, 0x1F20, 0x1F45, 0x1F48, 0x1F4D,
+ 0x1F50, 0x1F57, 0x1F5F, 0x1F7D, 0x1F80, 0x1FB4, 0x1FB6, 0x1FBC,
+ 0x1FC2, 0x1FC4, 0x1FC6, 0x1FCC, 0x1FD0, 0x1FD3, 0x1FD6, 0x1FDB,
+ 0x1FE0, 0x1FEC, 0x1FF2, 0x1FF4, 0x1FF6, 0x1FFC, 0x212A, 0x212B,
+ 0x2180, 0x2182, 0x3041, 0x3094, 0x30A1, 0x30FA, 0x3105, 0x312C,
+ 0xAC00, 0xD7A3,
+ // Ideographic
+ 0x3021, 0x3029, 0x4E00, 0x9FA5,
+ };
+ int letterChar[] = {
+ // BaseChar
+ 0x0386, 0x038C, 0x03DA, 0x03DC, 0x03DE, 0x03E0, 0x0559, 0x06D5,
+ 0x093D, 0x09B2, 0x0A5E, 0x0A8D, 0x0ABD, 0x0AE0, 0x0B3D, 0x0B9C,
+ 0x0CDE, 0x0E30, 0x0E84, 0x0E8A, 0x0E8D, 0x0EA5, 0x0EA7, 0x0EB0,
+ 0x0EBD, 0x1100, 0x1109, 0x113C, 0x113E, 0x1140, 0x114C, 0x114E,
+ 0x1150, 0x1159, 0x1163, 0x1165, 0x1167, 0x1169, 0x1175, 0x119E,
+ 0x11A8, 0x11AB, 0x11BA, 0x11EB, 0x11F0, 0x11F9, 0x1F59, 0x1F5B,
+ 0x1F5D, 0x1FBE, 0x2126, 0x212E,
+ // Ideographic
+ 0x3007,
+ };
+
+ //
+ // [87] CombiningChar ::= ...
+ //
+
+ int combiningCharRange[] = {
+ 0x0300, 0x0345, 0x0360, 0x0361, 0x0483, 0x0486, 0x0591, 0x05A1,
+ 0x05A3, 0x05B9, 0x05BB, 0x05BD, 0x05C1, 0x05C2, 0x064B, 0x0652,
+ 0x06D6, 0x06DC, 0x06DD, 0x06DF, 0x06E0, 0x06E4, 0x06E7, 0x06E8,
+ 0x06EA, 0x06ED, 0x0901, 0x0903, 0x093E, 0x094C, 0x0951, 0x0954,
+ 0x0962, 0x0963, 0x0981, 0x0983, 0x09C0, 0x09C4, 0x09C7, 0x09C8,
+ 0x09CB, 0x09CD, 0x09E2, 0x09E3, 0x0A40, 0x0A42, 0x0A47, 0x0A48,
+ 0x0A4B, 0x0A4D, 0x0A70, 0x0A71, 0x0A81, 0x0A83, 0x0ABE, 0x0AC5,
+ 0x0AC7, 0x0AC9, 0x0ACB, 0x0ACD, 0x0B01, 0x0B03, 0x0B3E, 0x0B43,
+ 0x0B47, 0x0B48, 0x0B4B, 0x0B4D, 0x0B56, 0x0B57, 0x0B82, 0x0B83,
+ 0x0BBE, 0x0BC2, 0x0BC6, 0x0BC8, 0x0BCA, 0x0BCD, 0x0C01, 0x0C03,
+ 0x0C3E, 0x0C44, 0x0C46, 0x0C48, 0x0C4A, 0x0C4D, 0x0C55, 0x0C56,
+ 0x0C82, 0x0C83, 0x0CBE, 0x0CC4, 0x0CC6, 0x0CC8, 0x0CCA, 0x0CCD,
+ 0x0CD5, 0x0CD6, 0x0D02, 0x0D03, 0x0D3E, 0x0D43, 0x0D46, 0x0D48,
+ 0x0D4A, 0x0D4D, 0x0E34, 0x0E3A, 0x0E47, 0x0E4E, 0x0EB4, 0x0EB9,
+ 0x0EBB, 0x0EBC, 0x0EC8, 0x0ECD, 0x0F18, 0x0F19, 0x0F71, 0x0F84,
+ 0x0F86, 0x0F8B, 0x0F90, 0x0F95, 0x0F99, 0x0FAD, 0x0FB1, 0x0FB7,
+ 0x20D0, 0x20DC, 0x302A, 0x302F,
+ };
+
+ int combiningCharChar[] = {
+ 0x05BF, 0x05C4, 0x0670, 0x093C, 0x094D, 0x09BC, 0x09BE, 0x09BF,
+ 0x09D7, 0x0A02, 0x0A3C, 0x0A3E, 0x0A3F, 0x0ABC, 0x0B3C, 0x0BD7,
+ 0x0D57, 0x0E31, 0x0EB1, 0x0F35, 0x0F37, 0x0F39, 0x0F3E, 0x0F3F,
+ 0x0F97, 0x0FB9, 0x20E1, 0x3099, 0x309A,
+ };
+
+ //
+ // [88] Digit ::= ...
+ //
+
+ int digitRange[] = {
+ 0x0030, 0x0039, 0x0660, 0x0669, 0x06F0, 0x06F9, 0x0966, 0x096F,
+ 0x09E6, 0x09EF, 0x0A66, 0x0A6F, 0x0AE6, 0x0AEF, 0x0B66, 0x0B6F,
+ 0x0BE7, 0x0BEF, 0x0C66, 0x0C6F, 0x0CE6, 0x0CEF, 0x0D66, 0x0D6F,
+ 0x0E50, 0x0E59, 0x0ED0, 0x0ED9, 0x0F20, 0x0F29,
+ };
+
+ //
+ // [89] Extender ::= ...
+ //
+
+ int extenderRange[] = {
+ 0x3031, 0x3035, 0x309D, 0x309E, 0x30FC, 0x30FE,
+ };
+
+ int extenderChar[] = {
+ 0x00B7, 0x02D0, 0x02D1, 0x0387, 0x0640, 0x0E46, 0x0EC6, 0x3005,
+ };
+
+ //
+ // SpecialChar ::= '<', '&', '\n', '\r', ']'
+ //
+
+ int specialChar[] = {
+ '<', '&', '\n', '\r', ']',
+ };
+
+ //
+ // Initialize
+ //
+
+ // set valid characters
+ for (int i = 0; i < charRange.length; i += 2) {
+ for (int j = charRange[i]; j <= charRange[i + 1]; j++) {
+ CHARS[j] |= MASK_VALID | MASK_CONTENT;
+ }
+ }
+
+ // remove special characters
+ for (int i = 0; i < specialChar.length; i++) {
+ CHARS[specialChar[i]] = (byte)(CHARS[specialChar[i]] & ~MASK_CONTENT);
+ }
+
+ // set space characters
+ for (int i = 0; i < spaceChar.length; i++) {
+ CHARS[spaceChar[i]] |= MASK_SPACE;
+ }
+
+ // set name start characters
+ for (int i = 0; i < nameStartChar.length; i++) {
+ CHARS[nameStartChar[i]] |= MASK_NAME_START | MASK_NAME |
+ MASK_NCNAME_START | MASK_NCNAME;
+ }
+ for (int i = 0; i < letterRange.length; i += 2) {
+ for (int j = letterRange[i]; j <= letterRange[i + 1]; j++) {
+ CHARS[j] |= MASK_NAME_START | MASK_NAME |
+ MASK_NCNAME_START | MASK_NCNAME;
+ }
+ }
+ for (int i = 0; i < letterChar.length; i++) {
+ CHARS[letterChar[i]] |= MASK_NAME_START | MASK_NAME |
+ MASK_NCNAME_START | MASK_NCNAME;
+ }
+
+ // set name characters
+ for (int i = 0; i < nameChar.length; i++) {
+ CHARS[nameChar[i]] |= MASK_NAME | MASK_NCNAME;
+ }
+ for (int i = 0; i < digitRange.length; i += 2) {
+ for (int j = digitRange[i]; j <= digitRange[i + 1]; j++) {
+ CHARS[j] |= MASK_NAME | MASK_NCNAME;
+ }
+ }
+ for (int i = 0; i < combiningCharRange.length; i += 2) {
+ for (int j = combiningCharRange[i]; j <= combiningCharRange[i + 1]; j++) {
+ CHARS[j] |= MASK_NAME | MASK_NCNAME;
+ }
+ }
+ for (int i = 0; i < combiningCharChar.length; i++) {
+ CHARS[combiningCharChar[i]] |= MASK_NAME | MASK_NCNAME;
+ }
+ for (int i = 0; i < extenderRange.length; i += 2) {
+ for (int j = extenderRange[i]; j <= extenderRange[i + 1]; j++) {
+ CHARS[j] |= MASK_NAME | MASK_NCNAME;
+ }
+ }
+ for (int i = 0; i < extenderChar.length; i++) {
+ CHARS[extenderChar[i]] |= MASK_NAME | MASK_NCNAME;
+ }
+
+ // remove ':' from allowable MASK_NCNAME_START and MASK_NCNAME chars
+ CHARS[':'] &= ~(MASK_NCNAME_START | MASK_NCNAME);
+
+ // set Pubid characters
+ for (int i = 0; i < pubidChar.length; i++) {
+ CHARS[pubidChar[i]] |= MASK_PUBID;
+ }
+ for (int i = 0; i < pubidRange.length; i += 2) {
+ for (int j = pubidRange[i]; j <= pubidRange[i + 1]; j++) {
+ CHARS[j] |= MASK_PUBID;
+ }
+ }
+
+ } // <clinit>()
+
+ //
+ // Public static methods
+ //
+
+ /**
+ * Returns true if the specified character is a supplemental character.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isSupplemental(int c) {
+ return (c >= 0x10000 && c <= 0x10FFFF);
+ }
+
+ /**
+ * Returns true the supplemental character corresponding to the given
+ * surrogates.
+ *
+ * @param h The high surrogate.
+ * @param l The low surrogate.
+ */
+ public static int supplemental(char h, char l) {
+ return (h - 0xD800) * 0x400 + (l - 0xDC00) + 0x10000;
+ }
+
+ /**
+ * Returns the high surrogate of a supplemental character
+ *
+ * @param c The supplemental character to "split".
+ */
+ public static char highSurrogate(int c) {
+ return (char) (((c - 0x00010000) >> 10) + 0xD800);
+ }
+
+ /**
+ * Returns the low surrogate of a supplemental character
+ *
+ * @param c The supplemental character to "split".
+ */
+ public static char lowSurrogate(int c) {
+ return (char) (((c - 0x00010000) & 0x3FF) + 0xDC00);
+ }
+
+ /**
+ * Returns whether the given character is a high surrogate
+ *
+ * @param c The character to check.
+ */
+ public static boolean isHighSurrogate(int c) {
+ return (0xD800 <= c && c <= 0xDBFF);
+ }
+
+ /**
+ * Returns whether the given character is a low surrogate
+ *
+ * @param c The character to check.
+ */
+ public static boolean isLowSurrogate(int c) {
+ return (0xDC00 <= c && c <= 0xDFFF);
+ }
+
+
+ /**
+ * Returns true if the specified character is valid. This method
+ * also checks the surrogate character range from 0x10000 to 0x10FFFF.
+ * <p>
+ * If the program chooses to apply the mask directly to the
+ * <code>CHARS</code> array, then they are responsible for checking
+ * the surrogate character range.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isValid(int c) {
+ return (c < 0x10000 && (CHARS[c] & MASK_VALID) != 0) ||
+ (0x10000 <= c && c <= 0x10FFFF);
+ } // isValid(int):boolean
+
+ /**
+ * Returns true if the specified character is invalid.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isInvalid(int c) {
+ return !isValid(c);
+ } // isInvalid(int):boolean
+
+ /**
+ * Returns true if the specified character can be considered content.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isContent(int c) {
+ return (c < 0x10000 && (CHARS[c] & MASK_CONTENT) != 0) ||
+ (0x10000 <= c && c <= 0x10FFFF);
+ } // isContent(int):boolean
+
+ /**
+ * Returns true if the specified character can be considered markup.
+ * Markup characters include '<', '&', and '%'.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isMarkup(int c) {
+ return c == '<' || c == '&' || c == '%';
+ } // isMarkup(int):boolean
+
+ /**
+ * Returns true if the specified character is a space character
+ * as defined by production [3] in the XML 1.0 specification.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isSpace(int c) {
+ return c < 0x10000 && (CHARS[c] & MASK_SPACE) != 0;
+ } // isSpace(int):boolean
+
+ /**
+ * Returns true if the specified character is a space character
+ * as amdended in the XML 1.1 specification.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isXML11Space(int c) {
+ return (c < 0x10000 && (CHARS[c] & MASK_SPACE) != 0) ||
+ c == 0x85 || c == 0x2028;
+ } // isXML11Space(int):boolean
+
+ /**
+ * Returns true if the specified character is a valid name start
+ * character as defined by production [5] in the XML 1.0
+ * specification.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isNameStart(int c) {
+ return c < 0x10000 && (CHARS[c] & MASK_NAME_START) != 0;
+ } // isNameStart(int):boolean
+
+ /**
+ * Returns true if the specified character is a valid name
+ * character as defined by production [4] in the XML 1.0
+ * specification.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isName(int c) {
+ return c < 0x10000 && (CHARS[c] & MASK_NAME) != 0;
+ } // isName(int):boolean
+
+ /**
+ * Returns true if the specified character is a valid NCName start
+ * character as defined by production [4] in Namespaces in XML
+ * recommendation.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isNCNameStart(int c) {
+ return c < 0x10000 && (CHARS[c] & MASK_NCNAME_START) != 0;
+ } // isNCNameStart(int):boolean
+
+ /**
+ * Returns true if the specified character is a valid NCName
+ * character as defined by production [5] in Namespaces in XML
+ * recommendation.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isNCName(int c) {
+ return c < 0x10000 && (CHARS[c] & MASK_NCNAME) != 0;
+ } // isNCName(int):boolean
+
+ /**
+ * Returns true if the specified character is a valid Pubid
+ * character as defined by production [13] in the XML 1.0
+ * specification.
+ *
+ * @param c The character to check.
+ */
+ public static boolean isPubid(int c) {
+ return c < 0x10000 && (CHARS[c] & MASK_PUBID) != 0;
+ } // isPubid(int):boolean
+
+ /*
+ * [5] Name ::= (Letter | '_' | ':') (NameChar)*
+ */
+ /**
+ * Check to see if a string is a valid Name according to [5]
+ * in the XML 1.0 Recommendation
+ *
+ * @param name string to check
+ * @return true if name is a valid Name
+ */
+ public static boolean isValidName(String name) {
+ if (name.length() == 0)
+ return false;
+ char ch = name.charAt(0);
+ if(!isNameStart(ch))
+ return false;
+ for (int i = 1; i < name.length(); i++ ) {
+ ch = name.charAt(i);
+ if(!isName(ch) ){
+ return false;
+ }
+ }
+ return true;
+ } // isValidName(String):boolean
+
+
+ /*
+ * from the namespace rec
+ * [4] NCName ::= (Letter | '_') (NCNameChar)*
+ */
+ /**
+ * Check to see if a string is a valid NCName according to [4]
+ * from the XML Namespaces 1.0 Recommendation
+ *
+ * @param ncName string to check
+ * @return true if name is a valid NCName
+ */
+ public static boolean isValidNCName(String ncName) {
+ if (ncName.length() == 0)
+ return false;
+ char ch = ncName.charAt(0);
+ if(!isNCNameStart(ch))
+ return false;
+ for (int i = 1; i < ncName.length(); i++ ) {
+ ch = ncName.charAt(i);
+ if(!isNCName(ch) ){
+ return false;
+ }
+ }
+ return true;
+ } // isValidNCName(String):boolean
+
+ /*
+ * [7] Nmtoken ::= (NameChar)+
+ */
+ /**
+ * Check to see if a string is a valid Nmtoken according to [7]
+ * in the XML 1.0 Recommendation
+ *
+ * @param nmtoken string to check
+ * @return true if nmtoken is a valid Nmtoken
+ */
+ public static boolean isValidNmtoken(String nmtoken) {
+ if (nmtoken.length() == 0)
+ return false;
+ for (int i = 0; i < nmtoken.length(); i++ ) {
+ char ch = nmtoken.charAt(i);
+ if( ! isName( ch ) ){
+ return false;
+ }
+ }
+ return true;
+ } // isValidName(String):boolean
+
+
+
+
+
+ // encodings
+
+ /**
+ * Returns true if the encoding name is a valid IANA encoding.
+ * This method does not verify that there is a decoder available
+ * for this encoding, only that the characters are valid for an
+ * IANA encoding name.
+ *
+ * @param ianaEncoding The IANA encoding name.
+ */
+ public static boolean isValidIANAEncoding(String ianaEncoding) {
+ if (ianaEncoding != null) {
+ int length = ianaEncoding.length();
+ if (length > 0) {
+ char c = ianaEncoding.charAt(0);
+ if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
+ for (int i = 1; i < length; i++) {
+ c = ianaEncoding.charAt(i);
+ if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
+ (c < '0' || c > '9') && c != '.' && c != '_' &&
+ c != '-') {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+ }
+ return false;
+ } // isValidIANAEncoding(String):boolean
+
+ /**
+ * Returns true if the encoding name is a valid Java encoding.
+ * This method does not verify that there is a decoder available
+ * for this encoding, only that the characters are valid for an
+ * Java encoding name.
+ *
+ * @param javaEncoding The Java encoding name.
+ */
+ public static boolean isValidJavaEncoding(String javaEncoding) {
+ if (javaEncoding != null) {
+ int length = javaEncoding.length();
+ if (length > 0) {
+ for (int i = 1; i < length; i++) {
+ char c = javaEncoding.charAt(i);
+ if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') &&
+ (c < '0' || c > '9') && c != '.' && c != '_' &&
+ c != '-') {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+ return false;
+ } // isValidIANAEncoding(String):boolean
+
+} // class XMLChar
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/factory/OMDOMFactory.java
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/factory/OMDOMFactory.java?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/factory/OMDOMFactory.java (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/factory/OMDOMFactory.java Mon Mar 27 00:02:06 2006
@@ -0,0 +1,303 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axiom.om.impl.dom.factory;
+
+import org.apache.axiom.om.OMAttribute;
+import org.apache.axiom.om.OMComment;
+import org.apache.axiom.om.OMContainer;
+import org.apache.axiom.om.OMDocType;
+import org.apache.axiom.om.OMDocument;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMException;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNamespace;
+import org.apache.axiom.om.OMProcessingInstruction;
+import org.apache.axiom.om.OMText;
+import org.apache.axiom.om.OMXMLParserWrapper;
+import org.apache.axiom.om.impl.OMNodeEx;
+import org.apache.axiom.om.impl.dom.AttrImpl;
+import org.apache.axiom.om.impl.dom.CommentImpl;
+import org.apache.axiom.om.impl.dom.DocumentFragmentimpl;
+import org.apache.axiom.om.impl.dom.DocumentImpl;
+import org.apache.axiom.om.impl.dom.ElementImpl;
+import org.apache.axiom.om.impl.dom.NamespaceImpl;
+import org.apache.axiom.om.impl.dom.OMDOMException;
+import org.apache.axiom.om.impl.dom.ParentNode;
+import org.apache.axiom.om.impl.dom.TextImpl;
+import org.w3c.dom.Node;
+
+import javax.xml.namespace.QName;
+
+public class OMDOMFactory implements OMFactory {
+
+ protected DocumentImpl document;
+
+ public OMDOMFactory() {
+ }
+
+ public OMDOMFactory(DocumentImpl doc) {
+ this.document = doc;
+ }
+
+ public OMDocument createOMDocument() {
+ if (this.document == null)
+ this.document = new DocumentImpl(this);
+
+ return this.document;
+ }
+
+ /**
+ * Configure this factory to use the given document. Use with care.
+ *
+ * @param document
+ */
+ public void setDocument(DocumentImpl document) {
+ this.document = document;
+ }
+
+ public OMElement createOMElement(String localName, OMNamespace ns) {
+ return new ElementImpl((DocumentImpl) this.createOMDocument(),
+ localName, (NamespaceImpl) ns, this);
+ }
+
+ public OMElement createOMElement(String localName, OMNamespace ns,
+ OMContainer parent) throws OMDOMException {
+ switch (((ParentNode) parent).getNodeType()) {
+ case Node.ELEMENT_NODE: // We are adding a new child to an elem
+ ElementImpl parentElem = (ElementImpl) parent;
+ ElementImpl elem = new ElementImpl((DocumentImpl) parentElem
+ .getOwnerDocument(), localName, (NamespaceImpl) ns, this);
+ parentElem.appendChild(elem);
+ return elem;
+
+ case Node.DOCUMENT_NODE:
+ DocumentImpl docImpl = (DocumentImpl) parent;
+ ElementImpl elem2 = new ElementImpl(docImpl, localName,
+ (NamespaceImpl) ns, this);
+ return elem2;
+
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ DocumentFragmentimpl docFragImpl = (DocumentFragmentimpl) parent;
+ ElementImpl elem3 = new ElementImpl((DocumentImpl) docFragImpl
+ .getOwnerDocument(), localName, (NamespaceImpl) ns, this);
+ return elem3;
+ default:
+ throw new OMDOMException(
+ "The parent container can only be an ELEMENT, DOCUMENT " +
+ "or a DOCUMENT FRAGMENT");
+ }
+ }
+
+ /**
+ * Creates an OMElement with the builder.
+ */
+ public OMElement createOMElement(String localName, OMNamespace ns,
+ OMContainer parent, OMXMLParserWrapper builder) {
+ switch (((ParentNode) parent).getNodeType()) {
+ case Node.ELEMENT_NODE: // We are adding a new child to an elem
+ ElementImpl parentElem = (ElementImpl) parent;
+ ElementImpl elem = new ElementImpl((DocumentImpl) parentElem
+ .getOwnerDocument(), localName, (NamespaceImpl) ns,
+ builder, this);
+ parentElem.appendChild(elem);
+ return elem;
+ case Node.DOCUMENT_NODE:
+ DocumentImpl docImpl = (DocumentImpl) parent;
+ ElementImpl elem2 = new ElementImpl(docImpl, localName,
+ (NamespaceImpl) ns, builder, this);
+ docImpl.appendChild(elem2);
+ return elem2;
+
+ case Node.DOCUMENT_FRAGMENT_NODE:
+ DocumentFragmentimpl docFragImpl = (DocumentFragmentimpl) parent;
+ ElementImpl elem3 = new ElementImpl((DocumentImpl) docFragImpl
+ .getOwnerDocument(), localName, (NamespaceImpl) ns,
+ builder, this);
+ return elem3;
+ default:
+ throw new OMDOMException(
+ "The parent container can only be an ELEMENT, DOCUMENT " +
+ "or a DOCUMENT FRAGMENT");
+ }
+ }
+
+ /**
+ * Creates an OMElement.
+ *
+ * @see org.apache.axiom.om.OMFactory#createOMElement(java.lang.String,
+ * java.lang.String, java.lang.String)
+ */
+ public OMElement createOMElement(String localName, String namespaceURI,
+ String namespacePrefix) {
+ NamespaceImpl ns = new NamespaceImpl(namespaceURI, namespacePrefix,
+ this);
+ return this.createOMElement(localName, ns);
+ }
+
+ /**
+ * Creates a new OMDOM Element node and adds it to the given parent.
+ *
+ * @see #createOMElement(String, OMNamespace, OMContainer)
+ * @see org.apache.axiom.om.OMFactory#createOMElement(
+ * javax.xml.namespace.QName, org.apache.axiom.om.OMContainer)
+ */
+ public OMElement createOMElement(QName qname, OMContainer parent)
+ throws OMException {
+ NamespaceImpl ns;
+ if (qname.getPrefix() != null) {
+ ns = new NamespaceImpl(qname.getNamespaceURI(), qname.getPrefix(), this);
+ } else {
+ ns = new NamespaceImpl(qname.getNamespaceURI(), this);
+ }
+ return createOMElement(qname.getLocalPart(), ns, parent);
+ }
+
+ /**
+ * Creates a new OMNamespace.
+ *
+ * @see org.apache.axiom.om.OMFactory#createOMNamespace(java.lang.String,
+ * java.lang.String)
+ */
+ public OMNamespace createOMNamespace(String uri, String prefix) {
+ return new NamespaceImpl(uri, prefix, this);
+ }
+
+ /**
+ * Creates a new OMDOM Text node with the given value and appends it to the
+ * given parent element.
+ *
+ * @see org.apache.axiom.om.OMFactory#createText(
+ * org.apache.axiom.om.OMElement,java.lang.String)
+ */
+ public OMText createText(OMElement parent, String text) {
+ ElementImpl parentElem = (ElementImpl) parent;
+ TextImpl txt = new TextImpl((DocumentImpl) parentElem
+ .getOwnerDocument(), text, this);
+ parentElem.addChild(txt);
+ return txt;
+ }
+
+ public OMText createText(OMElement parent, String text, int type) {
+ OMText textNode = createText(parent, text);
+ ((OMNodeEx) textNode).setType(type);
+ return textNode;
+ }
+
+ /**
+ * Creates a OMDOM Text node carrying the given value.
+ *
+ * @see org.apache.axiom.om.OMFactory#createText(java.lang.String)
+ */
+ public OMText createText(String s) {
+ return new TextImpl(s, this);
+ }
+
+ /**
+ * Creates a Character node of the given type.
+ *
+ * @see org.apache.axiom.om.OMFactory#createText(java.lang.String, int)
+ */
+ public OMText createText(String text, int type) {
+ switch (type) {
+ case Node.TEXT_NODE:
+ return new TextImpl(text, this);
+ default:
+ throw new OMDOMException("Only Text nodes are supported right now");
+ }
+ }
+
+ /**
+ * Creates a new OMDOM Text node with the value of the given text value
+ * along with the MTOM optimization parameters and returns it.
+ *
+ * @see org.apache.axiom.om.OMFactory#createText(java.lang.String,
+ * java.lang.String, boolean)
+ */
+ public OMText createText(String text, String mimeType, boolean optimize) {
+ return new TextImpl(text, mimeType, optimize, this);
+ }
+
+ /**
+ * Creates a new OMDOM Text node with the given datahandler and the given
+ * MTOM optimization configuration and returns it.
+ *
+ * @see org.apache.axiom.om.OMFactory#createText(java.lang.Object, boolean)
+ */
+ public OMText createText(Object dataHandler, boolean optimize) {
+ return new TextImpl(dataHandler, optimize, this);
+ }
+
+ /**
+ * Creates an OMDOM Text node, adds it to the give parent element and
+ * returns it.
+ *
+ * @see org.apache.axiom.om.OMFactory#createText(org.apache.axiom.om.OMElement,
+ * java.lang.String, java.lang.String, boolean)
+ */
+ public OMText createText(OMElement parent, String s, String mimeType,
+ boolean optimize) {
+ TextImpl text = new TextImpl((DocumentImpl) ((ElementImpl) parent)
+ .getOwnerDocument(), s, mimeType, optimize, this);
+ parent.addChild(text);
+ return text;
+ }
+
+ public OMText createText(String contentID, OMElement parent,
+ OMXMLParserWrapper builder) {
+ TextImpl text = new TextImpl(contentID, parent, builder, this);
+ parent.addChild(text);
+ return text;
+ }
+
+ public OMAttribute createOMAttribute(String localName, OMNamespace ns,
+ String value) {
+ return new AttrImpl(this.getDocument(), localName, ns, value, this);
+ }
+
+ public OMDocType createOMDocType(OMContainer parent, String content) {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public OMProcessingInstruction createOMProcessingInstruction(
+ OMContainer parent, String piTarget, String piData) {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public OMComment createOMComment(OMContainer parent, String content) {
+ DocumentImpl doc = null;
+ if (parent instanceof DocumentImpl) {
+ doc = (DocumentImpl) parent;
+ } else {
+ doc = (DocumentImpl) ((ParentNode) parent).getOwnerDocument();
+ }
+
+ CommentImpl comment = new CommentImpl(doc, content, this);
+ parent.addChild(comment);
+ return comment;
+ }
+
+ public DocumentImpl getDocument() {
+ return (DocumentImpl) this.createOMDocument();
+ }
+
+ public OMDocument createOMDocument(OMXMLParserWrapper builder) {
+ this.document = new DocumentImpl(builder, this);
+ return this.document;
+ }
+
+}
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderFactoryImpl.java
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderFactoryImpl.java?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderFactoryImpl.java (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderFactoryImpl.java Mon Mar 27 00:02:06 2006
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axiom.om.impl.dom.jaxp;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+
+public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory {
+
+ /**
+ * Temporary solution until DOOM's DocumentBuilder module is done.
+ * Use ThreadLocal to determine whether or not DOOM implementation is required.
+ * By default (isDOOMRequired() == false), we will use the one from JDK (Crimson)
+ */
+ private static DocumentBuilderFactory originalDocumentBuilderFactory = null;
+ private static String originalDocumentBuilderFactoryClassName = null;
+ private static ThreadLocal documentBuilderFactoryTracker = new ThreadLocal();
+
+ public static boolean isDOOMRequired() {
+ Object value = documentBuilderFactoryTracker.get();
+ return (value != null);
+ }
+
+ public static void setDOOMRequired(boolean isDOOMRequired) {
+ String systemKey = DocumentBuilderFactory.class.getName();
+ if (isDOOMRequired) {
+ if (!isDOOMRequired()) {
+ originalDocumentBuilderFactory = DocumentBuilderFactory.newInstance();
+ originalDocumentBuilderFactoryClassName = originalDocumentBuilderFactory.getClass().getName();
+ documentBuilderFactoryTracker.set(Boolean.TRUE);
+ System.setProperty(systemKey, DocumentBuilderFactoryImpl.class.getName());
+ }
+ } else {
+ String currentFactoryClassName = DocumentBuilderFactory.newInstance().getClass().getName();
+ if (currentFactoryClassName != null && currentFactoryClassName.equals(DocumentBuilderFactoryImpl.class.getName())) {
+ System.getProperties().remove(systemKey);
+ if (originalDocumentBuilderFactoryClassName != null) {
+ System.setProperty(DocumentBuilderFactory.class.getName(), originalDocumentBuilderFactoryClassName);
+ }
+ }
+ documentBuilderFactoryTracker.set(null);
+ originalDocumentBuilderFactory = null;
+ }
+ }
+
+
+ public DocumentBuilderFactoryImpl() {
+ super();
+ }
+
+ public DocumentBuilder newDocumentBuilder()
+ throws ParserConfigurationException {
+ /**
+ * Determine which DocumentBuilder implementation should be returned
+ */
+ return isDOOMRequired()
+ ? new DocumentBuilderImpl()
+ : originalDocumentBuilderFactory.newDocumentBuilder();
+ }
+
+ public Object getAttribute(String arg0) throws IllegalArgumentException {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public void setAttribute(String arg0, Object arg1)
+ throws IllegalArgumentException {
+ // // TODO
+ // throw new UnsupportedOperationException("TODO");
+ }
+
+ public static DocumentBuilderFactory newInstance() {
+ return new DocumentBuilderFactoryImpl();
+ }
+
+ public void setFeature(String arg0, boolean arg1)
+ throws ParserConfigurationException {
+ // TODO TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public boolean getFeature(String arg0) throws ParserConfigurationException {
+ // TODO TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+}
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderImpl.java
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderImpl.java?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderImpl.java (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/jaxp/DocumentBuilderImpl.java Mon Mar 27 00:02:06 2006
@@ -0,0 +1,156 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.axiom.om.impl.dom.jaxp;
+
+import org.apache.axiom.om.impl.builder.StAXOMBuilder;
+import org.apache.axiom.om.impl.dom.DOMImplementationImpl;
+import org.apache.axiom.om.impl.dom.DocumentImpl;
+import org.apache.axiom.om.impl.dom.ElementImpl;
+import org.apache.axiom.om.impl.dom.factory.OMDOMFactory;
+import org.w3c.dom.DOMImplementation;
+import org.w3c.dom.Document;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.ErrorHandler;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class DocumentBuilderImpl extends DocumentBuilder {
+
+ public DocumentBuilderImpl() {
+ super();
+ }
+
+ /**
+ * Returns whether the parser is configured to understand namespaces or not.
+ * The StAX parser used by this DOM impl is namespace aware therefore this
+ * will always return true.
+ *
+ * @see javax.xml.parsers.DocumentBuilder#isNamespaceAware()
+ */
+ public boolean isNamespaceAware() {
+ return true;
+ }
+
+ /**
+ * The StAX builder used is the org.apache.axiom.om.impl.llom.StAXOMBuilder
+ * is a validating builder.
+ *
+ * @see javax.xml.parsers.DocumentBuilder#isValidating()
+ */
+ public boolean isValidating() {
+ return true;
+ }
+
+ public DOMImplementation getDOMImplementation() {
+ return new DOMImplementationImpl();
+ }
+
+ /**
+ * Returns a new document impl.
+ *
+ * @see javax.xml.parsers.DocumentBuilder#newDocument()
+ */
+ public Document newDocument() {
+ OMDOMFactory factory = new OMDOMFactory();
+ DocumentImpl documentImpl = new DocumentImpl(factory);
+ documentImpl.setComplete(true);
+ return documentImpl;
+ }
+
+ public void setEntityResolver(EntityResolver arg0) {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public void setErrorHandler(ErrorHandler arg0) {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ public Document parse(InputSource inputSource) throws SAXException,
+ IOException {
+ try {
+ OMDOMFactory factory = new OMDOMFactory();
+ // Not really sure whether this will work :-?
+ XMLStreamReader reader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(inputSource.getCharacterStream());
+ StAXOMBuilder builder = new StAXOMBuilder(factory, reader);
+ DocumentImpl doc = (DocumentImpl) builder.getDocument();
+ ((ElementImpl) doc.getDocumentElement()).build();
+ return (DocumentImpl) builder.getDocument();
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+
+ /**
+ * @see javax.xml.parsers.DocumentBuilder#parse(java.io.InputStream)
+ */
+ public Document parse(InputStream is) throws SAXException, IOException {
+ try {
+ OMDOMFactory factory = new OMDOMFactory();
+ XMLStreamReader reader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(is);
+ StAXOMBuilder builder = new StAXOMBuilder(factory, reader);
+ return (DocumentImpl) builder.getDocument();
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+
+ /**
+ * @see javax.xml.parsers.DocumentBuilder#parse(java.io.File)
+ */
+ public Document parse(File file) throws SAXException, IOException {
+ try {
+ OMDOMFactory factory = new OMDOMFactory();
+ XMLStreamReader reader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new FileInputStream(file));
+ StAXOMBuilder builder = new StAXOMBuilder(factory, reader);
+ return (DocumentImpl) builder.getDocument();
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+
+ /**
+ * @see javax.xml.parsers.DocumentBuilder#parse(java.io.InputStream,
+ * java.lang.String)
+ */
+ public Document parse(InputStream is, String systemId) throws SAXException,
+ IOException {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+ /**
+ * @see javax.xml.parsers.DocumentBuilder#parse(java.lang.String)
+ */
+ public Document parse(String uri) throws SAXException, IOException {
+ // TODO
+ throw new UnsupportedOperationException("TODO");
+ }
+
+}
Added: webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/msg/DOMMessages.properties
URL: http://svn.apache.org/viewcvs/webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/msg/DOMMessages.properties?rev=389047&view=auto
==============================================================================
--- webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/msg/DOMMessages.properties (added)
+++ webservices/commons/trunk/modules/axiom/src/org/apache/axiom/om/impl/dom/msg/DOMMessages.properties Mon Mar 27 00:02:06 2006
@@ -0,0 +1,66 @@
+# This file stores localized messages for the Xerces
+# DOM implementation.
+#
+# The messages are arranged in key and value tuples in a ListResourceBundle.
+#
+# @version $Id: DOMMessages.properties,v 1.10 2004/07/05 22:36:53 mrglavas Exp $
+
+ BadMessageKey = The error message corresponding to the message key can not be found.
+ FormatFailed = An internal error occurred while formatting the following message:\n
+
+# DOM Core
+
+# exception codes
+DOMSTRING_SIZE_ERR = The specified range of text does not fit into a DOMString.
+HIERARCHY_REQUEST_ERR = An attempt was made to insert a node where it is not permitted.
+INDEX_SIZE_ERR = The index or size is negative, or greater than the allowed value.
+INUSE_ATTRIBUTE_ERR = An attempt is made to add an attribute that is already in use elsewhere.
+INVALID_ACCESS_ERR = A parameter or an operation is not supported by the underlying object.
+INVALID_CHARACTER_ERR = An invalid or illegal XML character is specified.
+INVALID_MODIFICATION_ERR = An attempt is made to modify the type of the underlying object.
+INVALID_STATE_ERR = An attempt is made to use an object that is not, or is no longer, usable.
+NAMESPACE_ERR = An attempt is made to create or change an object in a way which is incorrect with regard to namespaces.
+NOT_FOUND_ERR = An attempt is made to reference a node in a context where it does not exist.
+NOT_SUPPORTED_ERR = The implementation does not support the requested type of object or operation.
+NO_DATA_ALLOWED_ERR = Data is specified for a node which does not support data.
+NO_MODIFICATION_ALLOWED_ERR = An attempt is made to modify an object where modifications are not allowed.
+SYNTAX_ERR = An invalid or illegal string is specified.
+VALIDATION_ERR = A call to a method such as insertBefore or removeChild would make the Node invalid with respect to document grammar.
+WRONG_DOCUMENT_ERR = A node is used in a different document than the one that created it.
+TYPE_MISMATCH_ERR = The value type for this parameter name is incompatible with the expected value type.
+
+#error messages or exceptions
+FEATURE_NOT_SUPPORTED = The parameter {0} is recognized but the requested value cannot be set.
+FEATURE_NOT_FOUND = The parameter {0} is not recognized.
+STRING_TOO_LONG = The resulting string is too long to fit in a DOMString: ''{0}''.
+
+#DOM Level 3 DOMError codes
+wf-invalid-character = The text {0} of the {1} node contains invalid XML characters.
+wf-invalid-character-in-node-name = The {0} node named {1} contains invalid XML characters.
+cdata-sections-splitted = CDATA sections containing the CDATA section termination marker '']]>''
+doctype-not-allowed = DOCTYPE declaration is not allowed.
+unsupported-encoding = The encoding {0} is not supported.
+
+#Error codes used in DOM Normalizer
+InvalidXMLCharInDOM = An invalid XML character (Unicode: 0x{0}) was found in the DOM during normalization.
+UndeclaredEntRefInAttrValue = The attribute \"{0}\" value \"{1}\" referenced an entity that was not declared.
+NullLocalElementName = A null local name was encountered during namespace normalization of element {0}.
+NullLocalAttrName = A null local name was encountered during namespace normalization of attribute {0}.
+
+#Error codes used in DOMParser
+InvalidDocumentClassName = The class name of the document factory \"{0}\" used to construct the DOM tree is not of type org.w3c.dom.Document.
+MissingDocumentClassName = The class name of the document factory \"{0}\" used to construct the DOM tree could not be found.
+CannotCreateDocumentClass = The class named \"{0}\" could not be constructed as a org.w3c.dom.Document.
+
+# Error codes used by JAXP DocumentBuilder
+jaxp-order-not-supported = Property ''{0}'' must be set before setting property ''{1}''.
+jaxp-null-input-source = The source specified cannot be null.
+
+#Ranges
+BAD_BOUNDARYPOINTS_ERR = The boundary-points of a Range do not meet specific requirements.
+INVALID_NODE_TYPE_ERR = The container of a 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.
+
+
+#Events
+UNSPECIFIED_EVENT_TYPE_ERR = The Event's type was not specified by initializing the event before the method was called.
+