/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.axis2.rmi.custombeans;
import org.apache.axis2.rmi.databind.AbstractRMIBean;
import org.apache.axis2.rmi.databind.JavaObjectSerializer;
import org.apache.axis2.rmi.databind.XmlStreamParser;
import org.apache.axis2.rmi.exception.XmlParsingException;
import org.apache.axis2.rmi.exception.XmlSerializingException;
import org.apache.axis2.rmi.util.Constants;
import org.apache.axis2.rmi.util.NamespacePrefix;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import javax.xml.namespace.QName;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.XMLStreamWriter;
import java.util.HashMap;
import java.util.Map;
/**
* this class is used to handle dom element related things.
*/
public class DomElementBean extends AbstractRMIBean {
private Element domElement;
public DomElementBean(Element domElement) {
this.domElement = domElement;
}
public void serialize(XMLStreamWriter writer,
JavaObjectSerializer serializer,
QName parentQName,
NamespacePrefix namespacePrefix)
throws XMLStreamException, XmlSerializingException {
// first write the start element for parent
writeStartElement(writer,
parentQName.getNamespaceURI(),
parentQName.getLocalPart(),
namespacePrefix);
serializeDomElement(this.domElement,writer,namespacePrefix);
writer.writeEndElement();
}
public static Object parse(XMLStreamReader reader,
XmlStreamParser parser)
throws XMLStreamException, XmlParsingException {
// this must be in the start state
while(!reader.isStartElement()){
reader.next();
}
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
documentBuilderFactory.setNamespaceAware(true);
Element domElement = null;
try {
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
Document document = documentBuilder.newDocument();
// check whether the element is null or not
String nillable = reader.getAttributeValue(Constants.URI_DEFAULT_SCHEMA_XSI,"nil");
if ("true".equals(nillable) || "1".equals(nillable)){
while(!reader.isEndElement()){
reader.next();
}
} else {
// point to the next element
reader.next();
// since this is a document element reader must be at the start element of the
// dom document
if (reader.isStartElement()){
domElement = getDOMElement(reader,document,new HashMap(),new NamespacePrefix());
} else {
throw new XmlParsingException("Dom element is not point to a start element");
}
}
} catch (ParserConfigurationException e) {
throw new XmlParsingException("Error while creating the document factory ",e);
}
return domElement;
}
private static Element getDOMElement(XMLStreamReader reader,
Document document,
Map namespaceToPrefixMap,
NamespacePrefix namespacePrefix)
throws XMLStreamException, XmlParsingException {
// reader must be at a start element
while(!reader.isStartElement()){
reader.next();
}
if (!namespaceToPrefixMap.containsKey(reader.getNamespaceURI())){
namespaceToPrefixMap.put(reader.getNamespaceURI(),
"ns" + namespacePrefix.getNamesapcePrefix());
}
QName elementQName = reader.getName();
String prefix = (String) namespaceToPrefixMap.get(reader.getNamespaceURI());
Element element = document.createElementNS(reader.getNamespaceURI(),
prefix + ":" + reader.getLocalName());
// set the attributes
Attr attribute = null;
String attributeNamespace = null;
String attributePrefix = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
attributeNamespace = reader.getAttributeNamespace(i);
if ((attributeNamespace == null) || attributeNamespace.equals("")) {
// this attribute has no namespace
element.setAttribute(reader.getAttributeLocalName(i),reader.getAttributeValue(i));
} else {
attributeNamespace = reader.getAttributeNamespace(i);
if (!namespaceToPrefixMap.containsKey(attributeNamespace)) {
namespaceToPrefixMap.put(attributeNamespace,
"ns" + namespacePrefix.getNamesapcePrefix());
}
attributePrefix = (String) namespaceToPrefixMap.get(attributeNamespace);
element.setAttributeNS(attributeNamespace,
attributePrefix + ":" + reader.getAttributeLocalName(i),
reader.getAttributeValue(i));
}
}
reader.next();
int state;
// at the end we have to point the reader to end of this element.
while (!reader.isEndElement() || !reader.getName().equals(elementQName)) {
state = reader.getEventType();
if (state == XMLStreamConstants.START_ELEMENT) {
element.appendChild(getDOMElement(reader, document, namespaceToPrefixMap, namespacePrefix));
} else if (state == XMLStreamConstants.CHARACTERS) {
element.appendChild(document.createTextNode(reader.getText()));
}
reader.next();
}
return element;
}
private void serializeDomElement(Element domElement,
XMLStreamWriter writer,
NamespacePrefix namespacePrefix) throws XMLStreamException, XmlSerializingException {
// first write the start element
writeStartElement(writer,domElement.getNamespaceURI(),domElement.getLocalName(),namespacePrefix);
// write the attributes writer now at the start element
NamedNodeMap attributes = domElement.getAttributes();
Attr attribute;
QName attributeQName;
for (int i = 0; i < attributes.getLength(); i++) {
attribute = (Attr) attributes.item(i);
attributeQName = new QName(attribute.getNamespaceURI(), attribute.getName());
writeAttribute(writer, attribute.getValue(), attributeQName, namespacePrefix);
}
// write the other children
NodeList nodeList = domElement.getChildNodes();
Node node;
Text textNode;
for (int i = 0; i < nodeList.getLength(); i++) {
node = nodeList.item(i);
if (node instanceof Element) {
// write the element
serializeDomElement((Element) node, writer, namespacePrefix);
} else if (node instanceof Text) {
textNode = (Text) node;
writer.writeCharacters(textNode.getNodeValue());
} else {
throw new XmlSerializingException("Unknown dom element node found node type ==>"
+ node.getNodeType());
}
}
writer.writeEndElement();
}
}