| /* | |
| * 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.databind; | |
| import org.apache.axis2.rmi.Configurator; | |
| import org.apache.axis2.rmi.exception.MetaDataPopulateException; | |
| import org.apache.axis2.rmi.exception.SchemaGenerationException; | |
| import org.apache.axis2.rmi.exception.XmlParsingException; | |
| import org.apache.axis2.rmi.metadata.AttributeField; | |
| import org.apache.axis2.rmi.metadata.ElementField; | |
| import org.apache.axis2.rmi.metadata.Operation; | |
| import org.apache.axis2.rmi.metadata.Parameter; | |
| import org.apache.axis2.rmi.metadata.Type; | |
| import org.apache.axis2.rmi.metadata.impl.TypeImpl; | |
| import org.apache.axis2.rmi.types.MapType; | |
| import org.apache.axis2.rmi.util.Constants; | |
| import org.apache.axis2.rmi.util.JavaTypeToQNameMap; | |
| import javax.xml.namespace.QName; | |
| import javax.xml.stream.XMLStreamException; | |
| import javax.xml.stream.XMLStreamReader; | |
| import java.lang.reflect.Array; | |
| import java.lang.reflect.InvocationTargetException; | |
| import java.lang.reflect.Method; | |
| import java.util.ArrayList; | |
| import java.util.Calendar; | |
| import java.util.Collection; | |
| import java.util.HashMap; | |
| import java.util.HashSet; | |
| import java.util.Iterator; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.Set; | |
| public class XmlStreamParser { | |
| private Configurator configurator; | |
| private Map qNameToTypeMap; | |
| private SimpleTypeHandler simpleTypeHandler; | |
| private Class simpleTypeHandlerClass; | |
| private boolean readerPriorAccess; | |
| private boolean priorAccessDetermined = false; | |
| public XmlStreamParser(Map processedTypeMap, | |
| Configurator configurator, | |
| Map schemaMap) { | |
| this.configurator = configurator; | |
| this.simpleTypeHandler = this.configurator.getSimpleTypeHandler(); | |
| this.simpleTypeHandlerClass = this.simpleTypeHandler.getClass(); | |
| try { | |
| populateQNameToTypeMap(processedTypeMap, schemaMap); | |
| } catch (MetaDataPopulateException e) { | |
| // TODO: what to do this exceptions is not going to happen | |
| } catch (SchemaGenerationException e) { | |
| // TODO: what to do this exceptions is not going to happen | |
| } | |
| } | |
| private void populateQNameToTypeMap(Map processedTypeMap, Map schemaMap) | |
| throws MetaDataPopulateException, | |
| SchemaGenerationException { | |
| // first add all the proceced type map values | |
| Set defaultTypeMapKeys = JavaTypeToQNameMap.getKeys(); | |
| Class typeClass; | |
| for (Iterator iter = defaultTypeMapKeys.iterator(); iter.hasNext();) { | |
| typeClass = (Class) iter.next(); | |
| if (!processedTypeMap.containsKey(typeClass)) { | |
| Type newType = new TypeImpl(typeClass); | |
| processedTypeMap.put(typeClass, newType); | |
| newType.populateMetaData(this.configurator, processedTypeMap); | |
| newType.generateSchema(this.configurator, schemaMap); | |
| } | |
| } | |
| this.qNameToTypeMap = new HashMap(); | |
| Type type = null; | |
| for (Iterator iter = processedTypeMap.values().iterator(); iter.hasNext();) { | |
| type = (Type) iter.next(); | |
| this.qNameToTypeMap.put(type.getXmlType().getQname(), type); | |
| } | |
| } | |
| public Object getOutputObject(XMLStreamReader reader_in, | |
| Operation operation) | |
| throws XMLStreamException, XmlParsingException { | |
| Object returnObject = null; | |
| determinePriorAccess(reader_in); | |
| StatefulXMLStreamReader reader = getStatefulReader(reader_in); | |
| advanceToFirstElement(reader); | |
| // first check whether we have got the correct input element or not | |
| if (reader.getLocalName().equals(operation.getOutPutElement().getName()) && | |
| reader.getNamespaceURI().equals(operation.getOutPutElement().getNamespace())) { | |
| reader.next(); | |
| if (operation.getOutputParameter() != null) { | |
| // i.e this is not a void return type | |
| returnObject = getObjectForParameter(reader, operation.getOutputParameter()); | |
| } | |
| } | |
| return returnObject; | |
| } | |
| public Object[] getInputParameters(XMLStreamReader reader_in, | |
| Operation operation) | |
| throws XMLStreamException, | |
| XmlParsingException { | |
| determinePriorAccess(reader_in); | |
| StatefulXMLStreamReader reader = getStatefulReader(reader_in); | |
| List returnObjects = new ArrayList(); | |
| advanceToFirstElement(reader); | |
| // first check whether we have got the correct input element or not | |
| if (reader.getLocalName().equals(operation.getInputElement().getName()) && | |
| reader.getNamespaceURI().equals(operation.getInputElement().getNamespace())) { | |
| // point the reader to parameters | |
| reader.next(); | |
| Parameter parameter = null; | |
| List inputParameters = operation.getInputParameters(); | |
| QName parameterQName = null; | |
| int startDepth = reader.getDepth(); | |
| for (Iterator iter = inputParameters.iterator(); iter.hasNext();) { | |
| parameter = (Parameter) iter.next(); | |
| parameterQName = new QName(parameter.getNamespace(), parameter.getName()); | |
| returnObjects.add(getObjectForParameter(reader, parameter)); | |
| // if the reader is at the end of this parameter | |
| // then we move it to next element. | |
| if (reader.isEndElement() && reader.getName().equals(parameterQName) | |
| && (readerPriorAccess || reader.getDepth() == startDepth - 1)){ | |
| reader.next(); | |
| } | |
| } | |
| } else { | |
| throw new XmlParsingException("Unexpected Subelement " + reader.getName() + " but " + | |
| "expected " + operation.getInputElement().getName()); | |
| } | |
| return returnObjects.toArray(); | |
| } | |
| /** | |
| * parameter has the same logic as the attribute. so reader pre and post conditions same. | |
| * | |
| * @param reader | |
| * @param parameter | |
| * @return | |
| * @throws XMLStreamException | |
| * @throws XmlParsingException | |
| */ | |
| public Object getObjectForParameter(XMLStreamReader reader_in, | |
| Parameter parameter) | |
| throws XMLStreamException, | |
| XmlParsingException { | |
| QName parameterQName = new QName(parameter.getNamespace(), parameter.getName()); | |
| determinePriorAccess(reader_in); | |
| StatefulXMLStreamReader reader = getStatefulReader(reader_in); | |
| return getObjectForElement(reader, | |
| parameterQName, | |
| parameter.getType(), | |
| parameter.isArray(), | |
| parameter.getElement().isNillable(), | |
| parameter.getElement().isMinOccurs0(), | |
| parameter.getClassType(), | |
| parameter.getJavaClass()); | |
| } | |
| /** | |
| * when calls to this method reader must point to the start of the type. | |
| * if it is a simple type it points the the text | |
| * if it is a complex type it points to the start element of the first attribute. and we returning | |
| * from the method it should point to the end element of the last parameter. | |
| * | |
| * @param reader | |
| * @param type | |
| * @return | |
| * @throws XMLStreamException | |
| * @throws XmlParsingException | |
| */ | |
| public Object getObjectForType(XMLStreamReader reader_in, | |
| Type type) | |
| throws XMLStreamException, | |
| XmlParsingException { | |
| try { | |
| determinePriorAccess(reader_in); | |
| StatefulXMLStreamReader reader = getStatefulReader(reader_in); | |
| Object returnObject = null; | |
| if (type.getXmlType().isSimpleType()) { | |
| // this is a simple known type for us | |
| // constructor should be able to invoke with the string. | |
| if (type.getJavaClass().equals(Object.class)) { | |
| returnObject = new Object(); | |
| } else { | |
| // find the object for this string using converter util classes | |
| returnObject = getSimpleTypeObject(type, reader, reader.getText()); | |
| } | |
| } else { | |
| // first we have to point to the reader to the beginning for the element | |
| while (!reader.isStartElement() && !reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| int startDepth = reader.getDepth(); | |
| // this is a complex type | |
| returnObject = type.getJavaClass().newInstance(); | |
| // we have to get all the elementField and populate them | |
| List elementFields = type.getAllElementFields(); | |
| ElementField elementField; | |
| Object elementFieldObject; | |
| QName elementFieldQName = null; | |
| for (Iterator iter = elementFields.iterator(); iter.hasNext();) { | |
| elementField = (ElementField) iter.next(); | |
| elementFieldObject = getObjectForElementField(reader, elementField); | |
| elementFieldQName = new QName(elementField.getNamespace(), elementField.getName()); | |
| if (elementFieldObject != null) { | |
| elementField.getSetterMethod().invoke(returnObject, new Object[]{elementFieldObject}); | |
| } | |
| // if the reader is at the end of this elementField | |
| // then we move it to next element. | |
| if (reader.isEndElement() && reader.getName().equals(elementFieldQName) | |
| && (readerPriorAccess || reader.getDepth() == startDepth - 1)){ | |
| reader.next(); | |
| } | |
| } | |
| } | |
| return returnObject; | |
| } catch (InstantiationException e) { | |
| throw new XmlParsingException("Constructor invoking exception for type " + type.getName()); | |
| } catch (IllegalAccessException e) { | |
| throw new XmlParsingException("Constructor invoking exception for type " + type.getName()); | |
| } catch (InvocationTargetException e) { | |
| e.printStackTrace(); | |
| throw new XmlParsingException("Constructor invoking exception for type " + type.getName()); | |
| } | |
| } | |
| private Object getSimpleTypeObject(Type type, StatefulXMLStreamReader reader, String value) | |
| throws XmlParsingException { | |
| Object returnObject; | |
| String methodName = null; | |
| try { | |
| methodName = getMethodName(type.getJavaClass().getName()); | |
| Method methodToInvoke = this.simpleTypeHandlerClass.getMethod(methodName,new Class[]{String.class}); | |
| returnObject = methodToInvoke.invoke(this.simpleTypeHandler,new Object[]{value}); | |
| } catch (NoSuchMethodException e) { | |
| throw new XmlParsingException("Can not invoke the converter util class method " + methodName, e); | |
| } catch (IllegalAccessException e) { | |
| throw new XmlParsingException("Can not invoke the converter util class method " + methodName, e); | |
| } catch (InvocationTargetException e) { | |
| throw new XmlParsingException("Can not invoke the converter util class method " + methodName, e); | |
| } | |
| return returnObject; | |
| } | |
| private String getMethodName(String className) { | |
| // first handle some exceptional classes | |
| if (className.equals(Integer.class.getName())) { | |
| return "convertToInt"; | |
| } else if (className.equals(Calendar.class.getName())) { | |
| return "convertToDateTime"; | |
| } | |
| if (className.indexOf(".") > -1) { | |
| className = className.substring(className.lastIndexOf(".") + 1); | |
| } else { | |
| // this is a primitive type class | |
| // so capitalize the first letter | |
| className = className.substring(0, 1).toUpperCase() + className.substring(1); | |
| } | |
| return "convertTo" + className; | |
| } | |
| /** | |
| * give the relevant object for elementField. | |
| * | |
| * @param reader | |
| * @param elementField | |
| * @return | |
| * @throws XMLStreamException | |
| * @throws XmlParsingException | |
| */ | |
| private Object getObjectForElementField(StatefulXMLStreamReader reader, | |
| ElementField elementField) | |
| throws XMLStreamException, | |
| XmlParsingException { | |
| QName elementFieldQName = new QName(elementField.getNamespace(), elementField.getName()); | |
| return getObjectForElement(reader, | |
| elementFieldQName, | |
| elementField.getType(), | |
| elementField.isArray(), | |
| elementField.getElement().isNillable(), | |
| elementField.getElement().isMinOccurs0(), | |
| elementField.getClassType(), | |
| elementField.getPropertyDescriptor().getPropertyType()); | |
| } | |
| /** | |
| * element parser corresponds to parse the element (for an attribute or parameter) correctly. | |
| * when calling to this method reader must point to the start element of the element. and when returning | |
| * it should point to the corresponding end element of the element. | |
| * if the element is an array it may point to the start element of the next element. | |
| * | |
| * @param reader | |
| * @param elementQName | |
| * @param elementType | |
| * @param isArray | |
| * @param classType | |
| * @param javaClass - if this is a list javaClass for the list | |
| * @return | |
| * @throws XMLStreamException | |
| * @throws XmlParsingException | |
| */ | |
| private Object getObjectForElement(StatefulXMLStreamReader reader, | |
| QName elementQName, | |
| Type elementType, | |
| boolean isArray, | |
| boolean isNillable, | |
| boolean isMinOccurs0, | |
| int classType, | |
| Class javaClass) | |
| throws XMLStreamException, | |
| XmlParsingException { | |
| // first we have to point to the reader to the beginning for the element | |
| while (!reader.isStartElement() && !reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| // first validate the attribute | |
| if (reader.getName().equals(elementQName)) { | |
| String nillble = reader.getAttributeValue(Constants.URI_DEFAULT_SCHEMA_XSI, "nil"); | |
| // actual element type may be different from the element type given | |
| // if extensions has used. | |
| Type actualElementType = elementType; | |
| QName typeQName = getTypeQName(reader); | |
| if ((typeQName != null) && !elementType.getXmlType().getQname().equals(typeQName)) { | |
| // i.e this is an extension type | |
| if (this.qNameToTypeMap.containsKey(typeQName)) { | |
| actualElementType = (Type) this.qNameToTypeMap.get(typeQName); | |
| } else { | |
| throw new XmlParsingException("Unknown type found ==> " + typeQName); | |
| } | |
| } | |
| // point to the complex type elements | |
| if (isArray) { | |
| Collection objectsCollection = getCollectionObject(classType, javaClass); | |
| // read the first element | |
| if ("true".equals(nillble) || "1".equals(nillble)) { | |
| // this is a nill attribute | |
| while (!reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| if (isNillable){ | |
| objectsCollection.add(null); | |
| } else { | |
| throw new XmlParsingException("Element " + elementQName + " can not be null"); | |
| } | |
| } else { | |
| Object returnObject = getElementObjectFromReader(actualElementType, reader); | |
| objectsCollection.add(returnObject); | |
| // we have to move the cursor until the end element of this attribute | |
| while (!reader.isEndElement() || !reader.getName().equals(elementQName)) { | |
| reader.next(); | |
| } | |
| } | |
| boolean loop = true; | |
| while (loop) { | |
| while (!reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| reader.next(); | |
| // now we are at the end element of the first element | |
| while (!reader.isStartElement() && !reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| // in this step if it is an end element we have found an end element | |
| // so have to exit from the loop | |
| if (reader.isEndElement()) { | |
| loop = false; | |
| } else { | |
| // now it should be in a start element | |
| // check whether still we read the original element attributes. otherwise return | |
| if (reader.getName().equals(elementQName)) { | |
| nillble = reader.getAttributeValue(Constants.URI_DEFAULT_SCHEMA_XSI, "nil"); | |
| // since this is a new element we check for extensions | |
| actualElementType = elementType; | |
| typeQName = getTypeQName(reader); | |
| if ((typeQName != null) && !elementType.getXmlType().getQname().equals(typeQName)) { | |
| // i.e this is an extension type | |
| if (this.qNameToTypeMap.containsKey(typeQName)) { | |
| actualElementType = (Type) this.qNameToTypeMap.get(typeQName); | |
| } else { | |
| throw new XmlParsingException("Unknown type found ==> " + typeQName); | |
| } | |
| } | |
| if ("true".equals(nillble) || "1".equals(nillble)) { | |
| // this is a nill attribute | |
| while (!reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| if (isNillable) { | |
| objectsCollection.add(null); | |
| } else { | |
| throw new XmlParsingException("Element " + elementQName + " can not be null"); | |
| } | |
| } else { | |
| Object returnObject = getElementObjectFromReader(actualElementType, reader); | |
| objectsCollection.add(returnObject); | |
| // we have to move the cursor until the end element of this attribute | |
| while (!reader.isEndElement() || !reader.getName().equals(elementQName)) { | |
| reader.next(); | |
| } | |
| } | |
| } else { | |
| loop = false; | |
| } | |
| } | |
| } | |
| // this is very important in handling primitives | |
| // they can not have null values so if array then we have to return the | |
| // array object is null | |
| // for other also it is convenient to assume like that. | |
| if ((Constants.OTHER_TYPE & classType) == Constants.OTHER_TYPE){ | |
| // i.e this is not a collection type | |
| List objectsList = (List) objectsCollection; | |
| if ((objectsCollection.size() == 0) || | |
| ((objectsCollection.size() == 1) && (objectsList.get(0) == null))) { | |
| return null; | |
| } else { | |
| // create an array with the original element type | |
| Object objectArray = Array.newInstance(elementType.getJavaClass(), objectsCollection.size()); | |
| for (int i = 0; i < objectsCollection.size(); i++) { | |
| Array.set(objectArray, i, objectsList.get(i)); | |
| } | |
| return objectArray; | |
| } | |
| } else if ((Constants.COLLECTION_TYPE & classType) == Constants.COLLECTION_TYPE){ | |
| if ((objectsCollection.size() == 0) || | |
| ((objectsCollection.size() == 1) && (objectsCollection.iterator().next() == null))){ | |
| return null; | |
| } else { | |
| return objectsCollection; | |
| } | |
| } else if ((Constants.MAP_TYPE & classType) == Constants.MAP_TYPE){ | |
| if ((objectsCollection.size() == 0) || | |
| ((objectsCollection.size() == 1) && (objectsCollection.iterator().next() == null))) { | |
| return null; | |
| } else { | |
| List mapObjectsList = (List) objectsCollection; | |
| MapType mapType = null; | |
| Map mapObject = null; | |
| if (javaClass.isInterface()) { | |
| mapObject = new HashMap(); | |
| } else { | |
| try { | |
| mapObject = (Map) javaClass.newInstance(); | |
| } catch (InstantiationException e) { | |
| throw new XmlParsingException("Can not instantiate the java class " + javaClass.getName(), e); | |
| } catch (IllegalAccessException e) { | |
| throw new XmlParsingException("Can not instantiate the java class " + javaClass.getName(), e); | |
| } | |
| } | |
| for (Iterator iter = mapObjectsList.iterator(); iter.hasNext();) { | |
| mapType = (MapType) iter.next(); | |
| mapObject.put(mapType.getKey(), mapType.getValue()); | |
| } | |
| return mapObject; | |
| } | |
| } else { | |
| throw new XmlParsingException("Unknow class type " + classType); | |
| } | |
| } else { | |
| if ("true".equals(nillble) || "1".equals(nillble)) { | |
| // this is a nill attribute | |
| while (!reader.isEndElement()) { | |
| reader.next(); | |
| } | |
| reader.next(); | |
| if (isNillable) { | |
| return null; | |
| } else { | |
| throw new XmlParsingException("Element " + elementQName + " can not be null"); | |
| } | |
| } else { | |
| Object returnObject = getElementObjectFromReader(actualElementType, reader); | |
| // we have to move the cursor until the end element of this attribute | |
| while (!reader.isEndElement() || !reader.getName().equals(elementQName)) { | |
| reader.next(); | |
| } | |
| return returnObject; | |
| } | |
| } | |
| } else { | |
| if (isMinOccurs0) { | |
| return null; | |
| } else { | |
| throw new XmlParsingException("Unexpected Subelement " + reader.getName() + " but " + | |
| "expected " + elementQName.getLocalPart()); | |
| } | |
| } | |
| } | |
| private Object getElementObjectFromReader(Type elementType, | |
| StatefulXMLStreamReader reader) | |
| throws XmlParsingException, XMLStreamException { | |
| Object returnObject = null; | |
| if (RMIBean.class.isAssignableFrom(elementType.getJavaClass())) { | |
| // this is an rmi bean | |
| // so invoke the static parse method | |
| try { | |
| Method parseMethod = elementType.getJavaClass().getMethod("parse", new Class[]{XMLStreamReader.class, XmlStreamParser.class}); | |
| returnObject = parseMethod.invoke(null, new Object[]{reader, this}); | |
| } catch (NoSuchMethodException e) { | |
| throw new XmlParsingException("parse method has not been implemented correctly for the rmi bean " | |
| + elementType.getJavaClass().getName(), e); | |
| } catch (IllegalAccessException e) { | |
| throw new XmlParsingException("can not access parse method of the rmi bean " | |
| + elementType.getJavaClass().getName(), e); | |
| } catch (InvocationTargetException e) { | |
| throw new XmlParsingException("can not invoke parse method of the rmi bean " | |
| + elementType.getJavaClass().getName(), e); | |
| } | |
| } else { | |
| // read the attributes. | |
| Map javaMethodToValueMap = getJavaMethodValueHashMap(elementType, reader); | |
| reader.next(); | |
| returnObject = getObjectForType(reader, elementType); | |
| populateObjectAttributes(javaMethodToValueMap, returnObject); | |
| } | |
| return returnObject; | |
| } | |
| private void populateObjectAttributes(Map javaMethodToValueMap, Object returnObject) throws XmlParsingException { | |
| Method javaMehtod; | |
| try { | |
| for (Iterator iter = javaMethodToValueMap.keySet().iterator();iter.hasNext();){ | |
| javaMehtod = (Method) iter.next(); | |
| javaMehtod.invoke(returnObject,new Object[]{javaMethodToValueMap.get(javaMehtod)}); | |
| } | |
| } catch (IllegalAccessException e) { | |
| throw new XmlParsingException("Can not set the attribute value"); | |
| } catch (InvocationTargetException e) { | |
| throw new XmlParsingException("Can not set the attribute value"); | |
| } | |
| } | |
| private Map getJavaMethodValueHashMap(Type actualElementType, StatefulXMLStreamReader reader) | |
| throws XmlParsingException { | |
| AttributeField attributeField; | |
| String attributeVlaue; | |
| Object attributeObject; | |
| Map javaMethodToValueMap = new HashMap(); | |
| for (Iterator iter = actualElementType.getAllAttributeFields().iterator();iter.hasNext();){ | |
| attributeField = (AttributeField) iter.next(); | |
| attributeVlaue = reader.getAttributeValue(attributeField.getNamespace(), | |
| attributeField.getName()); | |
| if (attributeVlaue != null) { | |
| attributeObject = getSimpleTypeObject(attributeField.getType(), reader, attributeVlaue); | |
| javaMethodToValueMap.put(attributeField.getSetterMethod(), attributeObject); | |
| } else if (attributeField.isRequried()){ | |
| throw new XmlParsingException("Required attribute " + attributeField.getName() + " is missing"); | |
| } | |
| } | |
| return javaMethodToValueMap; | |
| } | |
| /** | |
| * returns the collection object according to the type. | |
| * @param classType | |
| * @param javaClass | |
| * @return | |
| * @throws XmlParsingException | |
| */ | |
| private Collection getCollectionObject(int classType, | |
| Class javaClass) | |
| throws XmlParsingException { | |
| Collection objectsCollection = null; | |
| try { | |
| if ((Constants.OTHER_TYPE & classType) == Constants.OTHER_TYPE) { | |
| // i.e this is not a list or a map | |
| objectsCollection = new ArrayList(); | |
| } else { | |
| if (javaClass.isInterface()) { | |
| if ((Constants.LIST_TYPE & classType) == Constants.LIST_TYPE) { | |
| objectsCollection = new ArrayList(); | |
| } else if ((Constants.SET_TYPE & classType) == Constants.SET_TYPE) { | |
| objectsCollection = new HashSet(); | |
| } else if ((Constants.COLLECTION_TYPE & classType) == Constants.COLLECTION_TYPE) { | |
| objectsCollection = new ArrayList(); | |
| } else if ((Constants.MAP_TYPE & classType) == Constants.MAP_TYPE) { | |
| objectsCollection = new ArrayList(); | |
| } | |
| } else { | |
| if ((Constants.COLLECTION_TYPE & classType) == Constants.COLLECTION_TYPE) { | |
| objectsCollection = (Collection) javaClass.newInstance(); | |
| } else if ((Constants.MAP_TYPE & classType) == Constants.MAP_TYPE) { | |
| objectsCollection = new ArrayList(); | |
| } | |
| } | |
| } | |
| } catch (InstantiationException e) { | |
| throw new XmlParsingException("Problem with instanciating the element class " + | |
| javaClass.getName() , e); | |
| } catch (IllegalAccessException e) { | |
| throw new XmlParsingException("Problem with instanciating the element class " + | |
| javaClass.getName() , e); | |
| } | |
| return objectsCollection; | |
| } | |
| /** | |
| * reader must be at the start of the element | |
| * | |
| * @param reader | |
| * @return qName for the type attribute | |
| */ | |
| private QName getTypeQName(StatefulXMLStreamReader reader) { | |
| QName typeQName = null; | |
| String typeValue = reader.getAttributeValue(Constants.URI_2001_SCHEMA_XSI, "type"); | |
| if ((typeValue != null) && !typeValue.equals("")) { | |
| int index = typeValue.indexOf(":"); | |
| String nsPrefix = ""; | |
| if (index > -1) { | |
| nsPrefix = typeValue.substring(0, index); | |
| } | |
| String localPart = typeValue.substring(index + 1); | |
| typeQName = new QName(reader.getNamespaceURI(nsPrefix), localPart); | |
| } | |
| return typeQName; | |
| } | |
| /** | |
| * Determine if the reader has been advanced beyond its initial location, prior | |
| * to the methods within XmlStreamParser being called. | |
| * | |
| * @param reader The XMLStreamReader on which the XmlStreamParser is acting. | |
| * @return true if the reader has been advanced beyond its initial location, false otherwise | |
| */ | |
| private boolean determinePriorAccess(XMLStreamReader reader) { | |
| if (!priorAccessDetermined) { | |
| if (reader.getLocation().getCharacterOffset() == 0) | |
| readerPriorAccess = false; | |
| else | |
| readerPriorAccess = true; | |
| priorAccessDetermined = true; | |
| } | |
| return readerPriorAccess; | |
| } | |
| /** | |
| * Provide a mechanism (a stack) to track the current state of the XMLStream | |
| * | |
| * @param reader_in the XMLStreamReader that the XmlStreamParser is acting on | |
| * @return a StatefulXMLStreamReader to monitor the state of the XMLStreamReader | |
| */ | |
| private StatefulXMLStreamReader getStatefulReader(XMLStreamReader reader_in) { | |
| if (reader_in instanceof StatefulXMLStreamReader) | |
| return (StatefulXMLStreamReader) reader_in; | |
| else | |
| return new StatefulXMLStreamReader(reader_in, readerPriorAccess); | |
| } | |
| /** | |
| * Advance the reader to point to the beginning of the element | |
| * @param reader the StatefulXMLStreamReader we are using to parse the XMLStream | |
| */ | |
| private void advanceToFirstElement(StatefulXMLStreamReader reader) throws XMLStreamException { | |
| if (readerPriorAccess) { | |
| while (!reader.isStartElement() && !reader.isEndElement() && reader.hasNext()) { | |
| reader.next(); | |
| } | |
| } else { | |
| while (reader.getDepth() == 0 && reader.hasNext()) { | |
| reader.next(); | |
| } | |
| } | |
| } | |
| } |