| /* |
| * Copyright 2001-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.axis.encoding.ser; |
| |
| import org.apache.axis.Constants; |
| import org.apache.axis.components.logger.LogFactory; |
| import org.apache.axis.encoding.DeserializationContext; |
| import org.apache.axis.encoding.Deserializer; |
| import org.apache.axis.encoding.DeserializerImpl; |
| import org.apache.axis.encoding.DeserializerTarget; |
| import org.apache.axis.message.SOAPHandler; |
| import org.apache.axis.utils.ClassUtils; |
| import org.apache.axis.utils.JavaUtils; |
| import org.apache.axis.utils.Messages; |
| import org.apache.axis.wsdl.symbolTable.SchemaUtils; |
| import org.apache.commons.logging.Log; |
| import org.apache.axis.soap.SOAPConstants; |
| |
| import org.xml.sax.Attributes; |
| import org.xml.sax.SAXException; |
| |
| import javax.xml.namespace.QName; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.StringTokenizer; |
| |
| |
| /** |
| * An ArrayDeserializer handles deserializing SOAP |
| * arrays. |
| * |
| * Some code borrowed from ApacheSOAP - thanks to Matt Duftler! |
| * |
| * @author Glen Daniels (gdaniels@apache.org) |
| * |
| * Multi-reference stuff: |
| * @author Rich Scheuerle (scheu@us.ibm.com) |
| */ |
| public class ArrayDeserializer extends DeserializerImpl |
| { |
| protected static Log log = |
| LogFactory.getLog(ArrayDeserializer.class.getName()); |
| |
| public QName arrayType = null; |
| public int curIndex = 0; |
| QName defaultItemType; |
| int length; |
| Class arrayClass = null; |
| ArrayList mDimLength = null; // If set, array of multi-dim lengths |
| ArrayList mDimFactor = null; // If set, array of factors for multi-dim [] |
| SOAPConstants soapConstants = SOAPConstants.SOAP11_CONSTANTS; |
| |
| /** |
| * This method is invoked after startElement when the element requires |
| * deserialization (i.e. the element is not an href & the value is not nil) |
| * DeserializerImpl provides default behavior, which simply |
| * involves obtaining a correct Deserializer and plugging its handler. |
| * @param namespace is the namespace of the element |
| * @param localName is the name of the element |
| * @param prefix is the prefix of the element |
| * @param attributes are the attrs on the element...used to get the type |
| * @param context is the DeserializationContext |
| */ |
| public void onStartElement(String namespace, String localName, |
| String prefix, Attributes attributes, |
| DeserializationContext context) |
| throws SAXException |
| { |
| // Deserializing the xml array requires processing the |
| // xsi:type= attribute, the soapenc:arrayType attribute, |
| // and the xsi:type attributes of the individual elements. |
| // |
| // The xsi:type=<qName> attribute is used to determine the java |
| // type of the array to instantiate. Axis expects it |
| // to be set to the generic "soapenc:Array" or to |
| // a specific qName. If the generic "soapenc:Array" |
| // specification is used, Axis determines the array |
| // type by examining the soapenc:arrayType attribute. |
| // |
| // The soapenc:arrayType=<qname><dims> is used to determine |
| // i) the number of dimensions, |
| // ii) the length of each dimension, |
| // iii) the default xsi:type of each of the elements. |
| // |
| // If the arrayType attribute is missing, Axis assumes |
| // a single dimension array with length equal to the number |
| // of nested elements. In such cases, the default xsi:type of |
| // the elements is determined using the array xsi:type. |
| // |
| // The xsi:type attributes of the individual elements of the |
| // array are used to determine the java type of the element. |
| // If the xsi:type attribute is missing for an element, the |
| // default xsi:type value is used. |
| |
| if (log.isDebugEnabled()) { |
| log.debug("Enter: ArrayDeserializer::startElement()"); |
| } |
| |
| soapConstants = context.getSOAPConstants(); |
| |
| // Get the qname for the array type=, set it to null if |
| // the generic type is used. |
| QName typeQName = context.getTypeFromAttributes(namespace, |
| localName, |
| attributes); |
| if (typeQName == null) { |
| typeQName = getDefaultType(); |
| } |
| |
| if (typeQName != null && |
| Constants.equals(Constants.SOAP_ARRAY, typeQName)) { |
| typeQName = null; |
| } |
| |
| // Now get the arrayType value |
| QName arrayTypeValue = context.getQNameFromString( |
| Constants.getValue(attributes, |
| Constants.URIS_SOAP_ENC, |
| soapConstants.getAttrItemType())); |
| |
| // The first part of the arrayType expression is |
| // the default item type qname. |
| // The second part is the dimension information |
| String dimString = null; |
| QName innerQName = null; |
| String innerDimString = ""; |
| if (arrayTypeValue != null) { |
| if (soapConstants != SOAPConstants.SOAP12_CONSTANTS) { |
| // Doing SOAP 1.1 |
| // Array dimension noted like this : [][x] |
| String arrayTypeValueNamespaceURI = |
| arrayTypeValue.getNamespaceURI(); |
| String arrayTypeValueLocalPart = |
| arrayTypeValue.getLocalPart(); |
| |
| int leftBracketIndex = |
| arrayTypeValueLocalPart.lastIndexOf('['); |
| int rightBracketIndex = |
| arrayTypeValueLocalPart.lastIndexOf(']'); |
| if (leftBracketIndex == -1 |
| || rightBracketIndex == -1 |
| || rightBracketIndex < leftBracketIndex) { |
| throw new IllegalArgumentException( |
| Messages.getMessage("badArrayType00", |
| "" + arrayTypeValue)); |
| } |
| |
| dimString = |
| arrayTypeValueLocalPart.substring(leftBracketIndex + 1, |
| rightBracketIndex); |
| arrayTypeValueLocalPart = |
| arrayTypeValueLocalPart.substring(0, leftBracketIndex); |
| |
| // If multi-dim array set to soapenc:Array |
| if (arrayTypeValueLocalPart.endsWith("]")) { |
| defaultItemType = Constants.SOAP_ARRAY; |
| int bracket = arrayTypeValueLocalPart.indexOf("["); |
| innerQName = new QName(arrayTypeValueNamespaceURI, |
| arrayTypeValueLocalPart.substring(0, bracket)); |
| innerDimString = arrayTypeValueLocalPart.substring(bracket); |
| } else { |
| defaultItemType = new QName(arrayTypeValueNamespaceURI, |
| arrayTypeValueLocalPart); |
| } |
| |
| } else { |
| String arraySizeValue = attributes.getValue(soapConstants.getEncodingURI(), Constants.ATTR_ARRAY_SIZE); |
| int leftStarIndex = arraySizeValue.lastIndexOf('*'); |
| |
| // Skip to num if any |
| if (leftStarIndex != -1) { |
| // "*" => "" |
| if (leftStarIndex == 0 && arraySizeValue.length() == 1) { |
| // "* *" => "" |
| } else if (leftStarIndex == (arraySizeValue.length() - 1)) { |
| throw new IllegalArgumentException( |
| Messages.getMessage("badArraySize00", |
| "" + arraySizeValue)); |
| // "* N" => "N" |
| } else { |
| dimString = arraySizeValue.substring(leftStarIndex + 2); |
| innerQName = arrayTypeValue; |
| innerDimString = arraySizeValue.substring(0, leftStarIndex + 1); |
| } |
| } else { |
| dimString = arraySizeValue; |
| } |
| |
| if (innerDimString == null || innerDimString.length() == 0) { |
| defaultItemType = arrayTypeValue; |
| } else { |
| defaultItemType = Constants.SOAP_ARRAY12; |
| } |
| } |
| } |
| |
| // If no type QName and no defaultItemType qname, use xsd:anyType |
| if (defaultItemType == null && typeQName == null) { |
| Class destClass = context.getDestinationClass(); |
| if (destClass != null && destClass.isArray()) { |
| // This will get set OK down below... |
| } else { |
| defaultItemType = Constants.XSD_ANYTYPE; |
| } |
| } |
| |
| // Determine the class type for the array. |
| arrayClass = null; |
| if (typeQName != null) { |
| arrayClass = context.getTypeMapping(). |
| getClassForQName(typeQName); |
| } |
| |
| if (typeQName == null || arrayClass == null) { |
| // type= information is not sufficient. |
| // Get an array of the default item type. |
| Class arrayItemClass = null; |
| QName compQName = defaultItemType; |
| |
| // Nested array, use the innermost qname |
| String dims = "[]"; |
| if (innerQName != null) { |
| compQName = innerQName; |
| |
| if (soapConstants == SOAPConstants.SOAP12_CONSTANTS) { |
| // With SOAP 1.2 Array, we append [] for each * found |
| int offset = 0; |
| while ((offset = innerDimString.indexOf('*', offset)) != -1) { |
| dims += "[]"; |
| offset ++; |
| } |
| } else { |
| // With SOAP 1.1 Array, we can append directly the complete innerDimString |
| dims += innerDimString; |
| } |
| } |
| |
| // item Class |
| arrayItemClass = context.getTypeMapping().getClassForQName(compQName); |
| if (arrayItemClass != null) { |
| try { |
| // Append the dimension found to the classname computed from the itemClass |
| // to form the array classname |
| // |
| String loadableArrayClassName = JavaUtils.getLoadableClassName( |
| JavaUtils.getTextClassName(arrayItemClass.getName()) + dims); |
| arrayClass = ClassUtils.forName(loadableArrayClassName, |
| true, |
| arrayItemClass.getClassLoader()); |
| } catch (Exception e) { |
| throw new SAXException( |
| Messages.getMessage("noComponent00", |
| "" + defaultItemType)); |
| } |
| } |
| } |
| if (arrayClass == null) { |
| arrayClass = context.getDestinationClass(); |
| } |
| |
| if (arrayClass == null) { |
| throw new SAXException( |
| Messages.getMessage("noComponent00", "" + defaultItemType)); |
| } |
| |
| if (dimString == null || dimString.length() == 0) { |
| // Size determined using length of the members |
| value = new ArrayListExtension(arrayClass); |
| } else { |
| try |
| { |
| StringTokenizer tokenizer; |
| if (soapConstants == SOAPConstants.SOAP12_CONSTANTS) { |
| tokenizer = new StringTokenizer(dimString); |
| } else { |
| tokenizer = new StringTokenizer(dimString, "[],"); |
| } |
| |
| length = Integer.parseInt(tokenizer.nextToken()); |
| if (tokenizer.hasMoreTokens()) { |
| // If the array is passed as a multi-dimensional array |
| // (i.e. int[2][3]) then store all of the |
| // mult-dim lengths. |
| // The valueReady method uses this array to set the |
| // proper mult-dim element. |
| mDimLength = new ArrayList(); |
| mDimLength.add(new Integer(length)); |
| |
| while(tokenizer.hasMoreTokens()) { |
| mDimLength.add( |
| new Integer( |
| Integer.parseInt(tokenizer.nextToken()))); |
| } |
| } |
| |
| // Create an ArrayListExtension class to store the ArrayList |
| // plus converted objects. |
| ArrayList list = new ArrayListExtension(arrayClass, length); |
| |
| // This is expensive as our array may not grown this big. |
| // Prevents problems when XML claims a huge size |
| // that it doesn't actually fill. |
| //for (int i = 0; i < length; i++) { |
| // list.add(null); |
| //} |
| value = list; |
| |
| } |
| catch (NumberFormatException e) |
| { |
| throw new IllegalArgumentException( |
| Messages.getMessage("badInteger00", dimString)); |
| } |
| } |
| |
| // If soapenc:offset specified, set the current index accordingly |
| String offset = Constants.getValue(attributes, |
| Constants.URIS_SOAP_ENC, |
| Constants.ATTR_OFFSET); |
| if (offset != null) { |
| if (soapConstants == SOAPConstants.SOAP12_CONSTANTS) { |
| throw new SAXException(Messages.getMessage("noSparseArray")); |
| } |
| |
| int leftBracketIndex = offset.lastIndexOf('['); |
| int rightBracketIndex = offset.lastIndexOf(']'); |
| |
| if (leftBracketIndex == -1 |
| || rightBracketIndex == -1 |
| || rightBracketIndex < leftBracketIndex) |
| { |
| throw new SAXException( |
| Messages.getMessage("badOffset00", offset)); |
| } |
| |
| curIndex = |
| convertToIndex(offset.substring(leftBracketIndex + 1, |
| rightBracketIndex), |
| "badOffset00"); |
| } |
| |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: ArrayDeserializer::startElement()"); |
| } |
| } |
| |
| |
| /** |
| * onStartChild is called on each child element. |
| * @param namespace is the namespace of the child element |
| * @param localName is the local name of the child element |
| * @param prefix is the prefix used on the name of the child element |
| * @param attributes are the attributes of the child element |
| * @param context is the deserialization context. |
| * @return is a Deserializer to use to deserialize a child (must be |
| * a derived class of SOAPHandler) or null if no deserialization should |
| * be performed. |
| */ |
| public SOAPHandler onStartChild(String namespace, |
| String localName, |
| String prefix, |
| Attributes attributes, |
| DeserializationContext context) |
| throws SAXException |
| { |
| if (log.isDebugEnabled()) { |
| log.debug("Enter: ArrayDeserializer.onStartChild()"); |
| } |
| |
| // If the position attribute is set, |
| // use it to update the current index |
| if (attributes != null) { |
| String pos = |
| Constants.getValue(attributes, |
| Constants.URIS_SOAP_ENC, |
| Constants.ATTR_POSITION); |
| if (pos != null) { |
| if (soapConstants == SOAPConstants.SOAP12_CONSTANTS) { |
| throw new SAXException(Messages.getMessage("noSparseArray")); |
| } |
| |
| int leftBracketIndex = pos.lastIndexOf('['); |
| int rightBracketIndex = pos.lastIndexOf(']'); |
| |
| if (leftBracketIndex == -1 |
| || rightBracketIndex == -1 |
| || rightBracketIndex < leftBracketIndex) |
| { |
| throw new SAXException( |
| Messages.getMessage("badPosition00", pos)); |
| } |
| |
| curIndex = |
| convertToIndex(pos.substring(leftBracketIndex + 1, |
| rightBracketIndex), |
| "badPosition00"); |
| } |
| |
| // If the xsi:nil attribute, set the value to null |
| // and return since there is nothing to deserialize. |
| if (context.isNil(attributes)) { |
| setChildValue(null, new Integer(curIndex++)); |
| return null; |
| } |
| } |
| |
| // Use the xsi:type setting on the attribute if it exists. |
| QName itemType = context.getTypeFromAttributes(namespace, |
| localName, |
| attributes); |
| |
| // Get the deserializer for the type. |
| Deserializer dSer = null; |
| if (itemType != null && (context.getCurElement().getHref() == null)) { |
| dSer = context.getDeserializerForType(itemType); |
| } |
| |
| if (dSer == null) { |
| // No deserializer can be found directly. Need to look harder |
| QName defaultType = defaultItemType; |
| Class javaType = null; |
| if (arrayClass != null && |
| arrayClass.isArray() && |
| defaultType == null) { |
| javaType = arrayClass.getComponentType(); |
| defaultType = context.getTypeMapping().getTypeQName(javaType); |
| } |
| |
| // We don't have a deserializer, the safest thing to do |
| // is to set up using the DeserializerImpl below. |
| // The DeserializerImpl will take care of href/id and |
| // install the appropriate serializer, etc. The problem |
| // is that takes a lot of time and will occur |
| // all the time if no xsi:types are sent. Most of the |
| // time an item is a simple schema type (i.e. String) |
| // so the following shortcut is used to get a Deserializer |
| // for these cases. |
| if (itemType == null && dSer == null) { |
| if (defaultType != null && SchemaUtils.isSimpleSchemaType(defaultType)) { |
| dSer = context.getDeserializer(javaType, defaultType); |
| } |
| } |
| |
| // If no deserializer is |
| // found, the deserializer is set to DeserializerImpl(). |
| // It is possible that the element has an href, thus we |
| // won't know the type until the definitition is encountered. |
| if (dSer == null) { |
| dSer = new DeserializerImpl(); |
| // Determine a default type for the deserializer |
| if (itemType == null) { |
| dSer.setDefaultType(defaultType); |
| } |
| } |
| } |
| |
| |
| // Register the callback value target, and |
| // keep track of this index so we know when it has been set. |
| dSer.registerValueTarget( |
| new DeserializerTarget(this, new Integer(curIndex))); |
| |
| // The framework handles knowing when the value is complete, as |
| // long as we tell it about each child we're waiting on... |
| addChildDeserializer(dSer); |
| |
| curIndex++; |
| |
| // In case of multi-array, we need to specify the destination class |
| // of the children elements of this element array deserializer. |
| context.setDestinationClass(arrayClass.getComponentType()); |
| |
| if (log.isDebugEnabled()) { |
| log.debug("Exit: ArrayDeserializer.onStartChild()"); |
| } |
| |
| return (SOAPHandler)dSer; |
| } |
| |
| public void onEndChild(String namespace, String localName, DeserializationContext context) throws SAXException { |
| // reverse onStartChild operation. |
| context.setDestinationClass(arrayClass); |
| } |
| |
| public void characters(char[] chars, int i, int i1) throws SAXException { |
| for (int idx = i; i < i1; i++) { |
| if (!Character.isWhitespace(chars[idx])) |
| throw new SAXException(Messages.getMessage("charsInArray")); |
| } |
| } |
| |
| /** |
| * set is called during deserialization to assign |
| * the Object value to the array position indicated by hint. |
| * The hint is always a single Integer. If the array being |
| * deserialized is a multi-dimensional array, the hint is |
| * converted into a series of indices to set the correct |
| * nested position. |
| * The array deserializer always deserializes into |
| * an ArrayList, which is converted and copied into the |
| * actual array after completion (by valueComplete). |
| * It is important to wait until all indices have been |
| * processed before invoking valueComplete. |
| * @param value value of the array element |
| * @param hint index of the array element (Integer) |
| **/ |
| public void setChildValue(Object value, Object hint) throws SAXException |
| { |
| if (log.isDebugEnabled()) { |
| log.debug("Enter: ArrayDeserializer::setValue(" + value + ", " + hint + ")"); |
| } |
| ArrayList list = (ArrayList)this.value; |
| int offset = ((Integer)hint).intValue(); |
| |
| if (this.mDimLength == null) { |
| // Normal Case: Set the element in the list |
| // grow the list if necessary to accomodate the new member |
| while (list.size() <= offset) { |
| list.add(null); |
| } |
| |
| list.set(offset, value); |
| } else { |
| // Multi-Dim Array case: Need to find the nested ArrayList |
| // and set the proper element. |
| |
| // Convert the offset into a series of indices |
| ArrayList mDimIndex = toMultiIndex(offset); |
| |
| // Get/Create the nested ArrayList |
| for(int i=0; i < mDimLength.size(); i++) { |
| int length = ((Integer)mDimLength.get(i)).intValue(); |
| int index = ((Integer)mDimIndex.get(i)).intValue(); |
| while (list.size() < length) { |
| list.add(null); |
| } |
| // If not the last dimension, get the nested ArrayList |
| // Else set the value |
| if (i < mDimLength.size()-1) { |
| if (list.get(index) == null) { |
| list.set(index, new ArrayList()); |
| } |
| list = (ArrayList) list.get(index); |
| } else { |
| list.set(index, value); |
| } |
| } |
| } |
| } |
| |
| /** |
| * When valueComplete() is invoked on the array, |
| * first convert the array value into the expected array. |
| * Then call super.valueComplete() to inform referents |
| * that the array value is ready. |
| **/ |
| public void valueComplete() throws SAXException |
| { |
| if (componentsReady()) { |
| try { |
| if (arrayClass != null) { |
| value = JavaUtils.convert(value, arrayClass); |
| } |
| } catch (RuntimeException e) { |
| // We must ignore exceptions from convert for Arrays with null - why? |
| } |
| } |
| |
| super.valueComplete(); |
| } |
| |
| /** |
| * Converts the given string to an index. |
| * Assumes the string consists of a brackets surrounding comma |
| * separated digits. For example "[2]" or [2,3]". |
| * The routine returns a single index. |
| * For example "[2]" returns 2. |
| * For example "[2,3]" depends on the size of the multiple dimensions. |
| * if the dimensions are "[3,5]" then 13 is returned (2*5) + 3. |
| * @param text representing index text |
| * @param exceptKey exception message key |
| * @return index |
| */ |
| private int convertToIndex(String text, String exceptKey) |
| throws SAXException { |
| StringTokenizer tokenizer = new StringTokenizer(text, "[],"); |
| int index = 0; |
| try { |
| if (mDimLength == null) { |
| // Normal Case: Single dimension |
| index = Integer.parseInt(tokenizer.nextToken()); |
| if (tokenizer.hasMoreTokens()) { |
| throw new SAXException( |
| Messages.getMessage(exceptKey, text)); |
| } |
| } |
| else { |
| // Multiple Dimensions: |
| int dim = -1; |
| ArrayList work = new ArrayList(); |
| while(tokenizer.hasMoreTokens()) { |
| // Problem if the number of dimensions specified exceeds |
| // the number of dimensions of arrayType |
| dim++; |
| if (dim >= mDimLength.size()) { |
| throw new SAXException( |
| Messages.getMessage(exceptKey, text)); |
| } |
| // Get the next token and convert to integer |
| int workIndex = Integer.parseInt(tokenizer.nextToken()); |
| |
| // Problem if the index is out of range. |
| if (workIndex < 0 || |
| workIndex >= |
| ((Integer)mDimLength.get(dim)).intValue()) { |
| throw new SAXException( |
| Messages.getMessage(exceptKey, text)); |
| } |
| work.add(new Integer(workIndex)); |
| } |
| index = toSingleIndex(work); // Convert to single index |
| } |
| } catch (SAXException e) { |
| throw e; |
| } catch (Exception e) { |
| throw new SAXException(Messages.getMessage(exceptKey, text)); |
| } |
| return index; |
| } |
| |
| /** |
| * Converts single index to list of multiple indices. |
| * @param single index |
| * @return list of multiple indices or null if not multiple indices. |
| */ |
| private ArrayList toMultiIndex(int single) { |
| if (mDimLength == null) |
| return null; |
| |
| // Calculate the index factors if not already known |
| if (mDimFactor == null) { |
| mDimFactor = new ArrayList(); |
| for (int i=0; i < mDimLength.size(); i++) { |
| int factor = 1; |
| for (int j=i+1; j<mDimLength.size(); j++) { |
| factor *= ((Integer)mDimLength.get(j)).intValue(); |
| } |
| mDimFactor.add(new Integer(factor)); |
| } |
| } |
| |
| ArrayList rc = new ArrayList(); |
| for (int i=0; i < mDimLength.size(); i++) { |
| int factor = ((Integer)mDimFactor.get(i)).intValue(); |
| rc.add(new Integer(single / factor)); |
| single = single % factor; |
| } |
| return rc; |
| } |
| |
| /** |
| * Converts multiple index to single index. |
| * @param indexArray list of multiple indices |
| * @return single index |
| */ |
| private int toSingleIndex(ArrayList indexArray) { |
| if (mDimLength == null || indexArray == null) |
| return -1; |
| |
| // Calculate the index factors if not already known |
| if (mDimFactor == null) { |
| mDimFactor = new ArrayList(); |
| for (int i=0; i < mDimLength.size(); i++) { |
| int factor = 1; |
| for (int j=i+1; j<mDimLength.size(); j++) { |
| factor *= ((Integer)mDimLength.get(j)).intValue(); |
| } |
| mDimFactor.add(new Integer(factor)); |
| } |
| } |
| |
| int single = 0; |
| for (int i=0; i < indexArray.size(); i++) { |
| single += ((Integer)mDimFactor.get(i)).intValue()* |
| ((Integer)indexArray.get(i)).intValue(); |
| } |
| return single; |
| } |
| |
| /** |
| * During processing, the Array Deserializer stores the array in |
| * an ArrayListExtension class. This class contains all of the |
| * normal function of an ArrayList, plus it keeps a list of the |
| * converted array values. This class is essential to support |
| * arrays that are multi-referenced. |
| **/ |
| public class ArrayListExtension extends ArrayList |
| implements JavaUtils.ConvertCache { |
| private HashMap table = null; |
| private Class arrayClass = null; // The array class. |
| /** |
| * Constructors |
| */ |
| ArrayListExtension(Class arrayClass) { |
| super(); |
| this.arrayClass = arrayClass; |
| // Don't use the array class as a hint |
| // if it can't be instantiated |
| if (arrayClass == null || |
| arrayClass.isInterface() || |
| java.lang.reflect.Modifier.isAbstract( |
| arrayClass.getModifiers())) { |
| arrayClass = null; |
| } |
| } |
| ArrayListExtension(Class arrayClass, int length) { |
| // Sanity check the array size, 50K is big enough to start |
| super(length > 50000 ? 50000 : length); |
| this.arrayClass = arrayClass; |
| // Don't use the array class as a hint |
| // if it can't be instantiated |
| if (arrayClass == null || |
| arrayClass.isInterface() || |
| java.lang.reflect.Modifier.isAbstract( |
| arrayClass.getModifiers())) { |
| arrayClass = null; |
| } |
| } |
| /** |
| * Store converted value |
| **/ |
| public void setConvertedValue(Class cls, Object value) { |
| if (table == null) |
| table = new HashMap(); |
| table.put(cls, value); |
| } |
| /** |
| * Get previously converted value |
| **/ |
| public Object getConvertedValue(Class cls) { |
| if (table == null) |
| return null; |
| return table.get(cls); |
| } |
| |
| /** |
| * Get the destination array class described by the xml |
| **/ |
| public Class getDestClass() { |
| return arrayClass; |
| } |
| } |
| |
| } |
