Information

0
Story Points

Technologies

Decompiled Java File
package org.exolab.castor.xml;

import java.io.PrintWriter;
import java.io.Serializable;
import java.io.StringWriter;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.StringTokenizer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.castor.core.util.Base64Decoder;
import org.castor.core.util.HexDecoder;
import org.castor.xml.InternalContext;
import org.castor.xml.UnmarshalListener;
import org.castor.xml.UnmarshalListenerAdapter;
import org.exolab.castor.mapping.ClassDescriptor;
import org.exolab.castor.mapping.ExtendedFieldHandler;
import org.exolab.castor.mapping.FieldHandler;
import org.exolab.castor.mapping.MapItem;
import org.exolab.castor.mapping.loader.FieldHandlerImpl;
import org.exolab.castor.types.AnyNode;
import org.exolab.castor.util.DefaultObjectFactory;
import org.exolab.castor.util.ObjectFactory;
import org.exolab.castor.xml.AttributeSet;
import org.exolab.castor.xml.IDResolver;
import org.exolab.castor.xml.IDResolverImpl;
import org.exolab.castor.xml.Introspector;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.MarshalFramework;
import org.exolab.castor.xml.Namespaces;
import org.exolab.castor.xml.NodeType;
import org.exolab.castor.xml.ReferenceInfo;
import org.exolab.castor.xml.ResolverException;
import org.exolab.castor.xml.UnmarshalState;
import org.exolab.castor.xml.ValidationContext;
import org.exolab.castor.xml.ValidationException;
import org.exolab.castor.xml.Validator;
import org.exolab.castor.xml.XMLClassDescriptor;
import org.exolab.castor.xml.XMLFieldDescriptor;
import org.exolab.castor.xml.MarshalFramework.InheritanceMatch;
import org.exolab.castor.xml.MarshalFramework.InternalXMLClassDescriptor;
import org.exolab.castor.xml.descriptors.PrimitivesClassDescriptor;
import org.exolab.castor.xml.descriptors.StringClassDescriptor;
import org.exolab.castor.xml.util.AttributeSetImpl;
import org.exolab.castor.xml.util.ContainerElement;
import org.exolab.castor.xml.util.SAX2ANY;
import org.exolab.castor.xml.util.XMLClassDescriptorImpl;
import org.exolab.castor.xml.util.XMLFieldDescriptorImpl;
import org.xml.sax.AttributeList;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.DocumentHandler;
import org.xml.sax.ErrorHandler;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

public final class UnmarshalHandler extends MarshalFramework implements ContentHandler, DocumentHandler, ErrorHandler {
   private static final Log LOG = LogFactory.getLog(UnmarshalHandler.class);
   private static final String ERROR_DID_NOT_FIND_CLASSDESCRIPTOR = "unable to find or create a ClassDescriptor for class: ";
   private static final String XML_PREFIX = "xml";
   private static final String XMLNS = "xmlns";
   private static final String XMLNS_PREFIX = "xmlns:";
   private static final int XMLNS_PREFIX_LENGTH = "xmlns:".length();
   private static final String XSI_TYPE = "type";
   private static final String XML_SPACE = "space";
   private static final String XML_SPACE_WITH_PREFIX = "xml:space";
   private static final String PRESERVE = "preserve";
   private Stack _stateInfo;
   private UnmarshalState _topState;
   private Class _topClass;
   private Object _topObject;
   private boolean _clearCollections;
   private Locator _locator;
   private IDResolver _idResolver;
   private UnmarshalListener _unmarshalListener;
   private boolean _validate;
   private Hashtable _resolveTable;
   private Map _javaPackages;
   private ClassLoader _loader;
   private static final StringClassDescriptor STRING_DESCRIPTOR = new StringClassDescriptor();
   private SAX2ANY _anyUnmarshaller;
   private int _depth;
   private AnyNode _node;
   private Namespaces _namespaces;
   private HashMap _namespaceToPackage;
   private ObjectFactory _objectFactory;
   private boolean _reuseObjects;
   private boolean _strictAttributes;
   private boolean _strictElements;
   private int _ignoreElementDepth;
   private boolean _createNamespaceScope;
   private UnmarshalHandler.ElementInfo _elemInfo;
   private AttributeSetImpl _reusableAtts;
   private boolean _wsPreserve;

   protected UnmarshalHandler() {
      this((Class)null);
   }

   protected UnmarshalHandler(Class topClass) {
      this((InternalContext)null, topClass);
   }

   protected UnmarshalHandler(InternalContext internalContext, Class topClass) {
      super(internalContext);
      this._stateInfo = null;
      this._topState = null;
      this._topClass = null;
      this._topObject = null;
      this._clearCollections = false;
      this._locator = null;
      this._idResolver = null;
      this._unmarshalListener = null;
      this._validate = true;
      this._resolveTable = new Hashtable();
      this._javaPackages = null;
      this._loader = null;
      this._anyUnmarshaller = null;
      this._depth = 0;
      this._node = null;
      this._namespaces = null;
      this._namespaceToPackage = null;
      this._objectFactory = new DefaultObjectFactory();
      this._reuseObjects = false;
      this._strictAttributes = false;
      this._strictElements = true;
      this._ignoreElementDepth = 0;
      this._createNamespaceScope = true;
      this._elemInfo = null;
      this._reusableAtts = null;
      this._wsPreserve = false;
      this._stateInfo = new Stack();
      this._idResolver = new IDResolverImpl();
      this._javaPackages = new HashMap();
      this._topClass = topClass;
      this._namespaces = new Namespaces();
      this._namespaceToPackage = new HashMap();
   }

   public void addNamespaceToPackageMapping(String nsURI, String packageName) {
      if(nsURI == null) {
         nsURI = "";
      }

      if(packageName == null) {
         packageName = "";
      }

      this._namespaceToPackage.put(nsURI, packageName);
   }

   public Object getCurrentObject() {
      if(!this._stateInfo.isEmpty()) {
         UnmarshalState state = (UnmarshalState)this._stateInfo.peek();
         if(state != null) {
            return state._object;
         }
      }

      return null;
   }

   public Object getObject() {
      return this._topState != null?this._topState._object:null;
   }

   public void setClassLoader(ClassLoader loader) {
      this._loader = loader;
   }

   public void setClearCollections(boolean clear) {
      this._clearCollections = clear;
   }

   /** @deprecated */
   public void setDebug(boolean debug) {
   }

   public void setIDResolver(IDResolver idResolver) {
      ((IDResolverImpl)this._idResolver).setResolver(idResolver);
   }

   public void setIgnoreExtraAttributes(boolean ignoreExtraAtts) {
      this._strictAttributes = !ignoreExtraAtts;
   }

   public void setIgnoreExtraElements(boolean ignoreExtraElems) {
      this._strictElements = !ignoreExtraElems;
   }

   /** @deprecated */
   public void setLogWriter(PrintWriter printWriter) {
   }

   public void setReuseObjects(boolean reuse) {
      this._reuseObjects = reuse;
   }

   public void setRootObject(Object root) {
      this._topObject = root;
   }

   /** @deprecated */
   public void setUnmarshalListener(org.exolab.castor.xml.UnmarshalListener listener) {
      if(listener == null) {
         listener = null;
      } else {
         UnmarshalListenerAdapter adapter = new UnmarshalListenerAdapter();
         adapter.setOldListener(listener);
         this._unmarshalListener = adapter;
      }

   }

   public void setUnmarshalListener(UnmarshalListener listener) {
      this._unmarshalListener = listener;
   }

   public void setValidation(boolean validate) {
      this._validate = validate;
   }

   public void setWhitespacePreserve(boolean preserve) {
      this._wsPreserve = preserve;
   }

   public void characters(char[] ch, int start, int length) throws SAXException {
      if(LOG.isTraceEnabled()) {
         StringBuffer state = new StringBuffer(21 + length);
         state.append("#characters: ");
         state.append(ch, start, length);
         LOG.trace(state.toString());
      }

      if(this._ignoreElementDepth <= 0) {
         if(!this._stateInfo.empty()) {
            if(this._anyUnmarshaller != null) {
               this._anyUnmarshaller.characters(ch, start, length);
            } else {
               UnmarshalState var8 = (UnmarshalState)this._stateInfo.peek();
               boolean removedTrailingWhitespace = false;
               boolean removedLeadingWhitespace = false;
               if(!var8._wsPreserve) {
                  boolean whitespace;
                  while(length > 0) {
                     whitespace = false;
                     switch(ch[start]) {
                     case '\t':
                     case '\n':
                     case '\r':
                     case ' ':
                        whitespace = true;
                     }

                     if(!whitespace) {
                        break;
                     }

                     removedLeadingWhitespace = true;
                     ++start;
                     --length;
                  }

                  if(length == 0) {
                     removedTrailingWhitespace = removedLeadingWhitespace;
                  } else {
                     while(length > 0) {
                        whitespace = false;
                        switch(ch[start + length - 1]) {
                        case '\t':
                        case '\n':
                        case '\r':
                        case ' ':
                           whitespace = true;
                        }

                        if(!whitespace) {
                           break;
                        }

                        removedTrailingWhitespace = true;
                        --length;
                     }
                  }
               }

               if(var8._buffer == null) {
                  var8._buffer = new StringBuffer();
               } else if(!var8._wsPreserve && length > 0 && (var8._trailingWhitespaceRemoved || removedLeadingWhitespace)) {
                  var8._buffer.append(' ');
               }

               var8._trailingWhitespaceRemoved = removedTrailingWhitespace;
               var8._buffer.append(ch, start, length);
            }

         }
      }
   }

   public void endDocument() throws SAXException {
   }

   public void endElement(String name) throws SAXException {
      if(LOG.isTraceEnabled()) {
         LOG.trace("#endElement: " + name);
      }

      if(this._ignoreElementDepth > 0) {
         --this._ignoreElementDepth;
      } else {
         if(this._anyUnmarshaller != null) {
            this._anyUnmarshaller.endElement(name);
            --this._depth;
            if(this._depth != 0) {
               return;
            }

            this._node = this._anyUnmarshaller.getStartingNode();
            this._anyUnmarshaller = null;
         }

         if(this._stateInfo.empty()) {
            throw new SAXException("missing start element: " + name);
         } else {
            int idx = name.indexOf(58);
            if(idx >= 0) {
               name = name.substring(idx + 1);
            }

            UnmarshalState state = (UnmarshalState)this._stateInfo.pop();
            XMLFieldDescriptor descriptor = state._fieldDesc;
            if(!state._elementName.equals(name)) {
               if(descriptor.isContainer()) {
                  this._stateInfo.push(state);
                  StringBuffer var20 = null;
                  if(state._buffer != null && !isWhitespace(state._buffer) && state._classDesc.getContentDescriptor() == null) {
                     var20 = state._buffer;
                     state._buffer = null;
                  }

                  this.endElement(state._elementName);
                  if(var20 != null) {
                     state = (UnmarshalState)this._stateInfo.peek();
                     if(state._buffer == null) {
                        state._buffer = var20;
                     } else {
                        state._buffer.append(var20.toString());
                     }
                  }

                  this.endElement(name);
               } else {
                  String var19 = "error in xml, expecting </" + state._elementName;
                  var19 = var19 + ">, but received </" + name + "> instead.";
                  throw new SAXException(var19);
               }
            } else {
               Class type = state._type;
               String var31;
               if(type == null) {
                  if(!state._wrapper) {
                     LOG.info("Ignoring " + state._elementName + " no descriptor was found");
                  }

                  StringBuffer var21 = null;
                  if(state._buffer != null && !isWhitespace(state._buffer)) {
                     var21 = state._buffer;
                     state._buffer = null;
                  }

                  if(var21 != null) {
                     UnmarshalState var44 = state;
                     var31 = state._elementName;

                     label292:
                     while(true) {
                        while(true) {
                           if((var44 = var44._parent) == null) {
                              break label292;
                           }

                           if(!var44._wrapper && var44._classDesc != null) {
                              XMLFieldDescriptor var35 = var44._classDesc.getContentDescriptor();
                              if(var35 != null && var31.equals(var35.getLocationPath())) {
                                 if(var44._buffer == null) {
                                    var44._buffer = var21;
                                 } else {
                                    var44._buffer.append(var21.toString());
                                 }
                              }
                           } else {
                              var31 = var44._elementName + "/" + var31;
                           }
                        }
                     }
                  }

                  this._namespaces = this._namespaces.getParent();
               } else {
                  boolean byteArray = false;
                  if(type.isArray()) {
                     byteArray = type.getComponentType() == Byte.TYPE;
                  }

                  if(state._object == null && !state._primitiveOrImmutable) {
                     this._namespaces = this._namespaces.getParent();
                  } else {
                     String ex;
                     if(state._primitiveOrImmutable) {
                        String val = null;
                        if(state._buffer != null) {
                           val = state._buffer.toString();
                           state._buffer.setLength(0);
                        }

                        if(type == String.class && !((XMLFieldDescriptorImpl)descriptor).isDerivedFromXSList()) {
                           if(val != null) {
                              state._object = val;
                           } else if(state._nil) {
                              state._object = null;
                           } else {
                              state._object = "";
                           }
                        } else if(byteArray && !descriptor.isDerivedFromXSList()) {
                           if(val == null) {
                              state._object = new byte[0];
                           } else {
                              state._object = this.decodeBinaryData(descriptor, val);
                           }
                        } else if(state._args != null) {
                           state._object = this.createInstance(state._type, state._args);
                        } else if(descriptor.isMultivalued() && descriptor.getSchemaType() != null && descriptor.getSchemaType().equals("list") && ((XMLFieldDescriptorImpl)descriptor).isDerivedFromXSList()) {
                           StringTokenizer fieldState = new StringTokenizer(val);
                           ArrayList firstOccurance = new ArrayList();

                           while(fieldState.hasMoreTokens()) {
                              ex = fieldState.nextToken();
                              if(isPrimitive(descriptor.getFieldType())) {
                                 firstOccurance.add(this.toPrimitiveObject(type, ex, state._fieldDesc));
                              } else {
                                 Class sw = descriptor.getFieldType();
                                 if(sw.isArray() && sw.getComponentType() == Byte.TYPE) {
                                    firstOccurance.add(this.decodeBinaryData(descriptor, ex));
                                 }
                              }
                           }

                           state._object = firstOccurance;
                        } else if(state._nil) {
                           state._object = null;
                        } else {
                           state._object = this.toPrimitiveObject(type, val, state._fieldDesc);
                        }
                     } else if(UnmarshalHandler.ArrayHandler.class.isAssignableFrom(state._type)) {
                        state._object = ((UnmarshalHandler.ArrayHandler)state._object).getObject();
                        state._type = state._object.getClass();
                     }

                     UnmarshalState var27;
                     if(state._buffer != null && state._buffer.length() > 0 && state._classDesc != null) {
                        XMLFieldDescriptor var23 = state._classDesc.getContentDescriptor();
                        if(var23 != null) {
                           Object var22 = state._buffer.toString();
                           if(isPrimitive(var23.getFieldType())) {
                              var22 = this.toPrimitiveObject(var23.getFieldType(), (String)var22, state._fieldDesc);
                           } else {
                              Class var24 = var23.getFieldType();
                              if(var24.isArray() && var24.getComponentType() == Byte.TYPE) {
                                 var22 = this.decodeBinaryData(descriptor, (String)var22);
                              }
                           }

                           try {
                              FieldHandler var26 = var23.getHandler();
                              boolean var32 = true;
                              if(this._reuseObjects) {
                                 Object var33 = var26.getValue(state._object);
                                 if(var33 != null) {
                                    var32 = !var33.equals(var22);
                                 }
                              }

                              if(var32) {
                                 var26.setValue(state._object, var22);
                              }
                           } catch (IllegalStateException var16) {
                              ex = "unable to add text content to ";
                              ex = ex + descriptor.getXMLName();
                              ex = ex + " due to the following error: " + var16;
                              throw new SAXException(ex, var16);
                           }
                        } else {
                           if(descriptor.isReference()) {
                              var27 = (UnmarshalState)this._stateInfo.peek();
                              this.processIDREF(state._buffer.toString(), descriptor, var27._object);
                              this._namespaces = this._namespaces.getParent();
                              return;
                           }

                           if(!isWhitespace(state._buffer)) {
                              var31 = "Illegal Text data found as child of: " + name;
                              var31 = var31 + "\n  value: \"" + state._buffer + "\"";
                              throw new SAXException(var31);
                           }
                        }
                     }

                     if(this._unmarshalListener != null && state._object != null) {
                        this._unmarshalListener.unmarshalled(state._object, state._parent == null?null:state._parent._object);
                     }

                     String var36;
                     if(this._stateInfo.empty()) {
                        if(this.isValidating()) {
                           ValidationException var39 = null;
                           ValidationException var29 = null;
                           if(this._resolveTable != null && !this.getInternalContext().getLenientIdValidation()) {
                              Enumeration var30 = this._resolveTable.keys();

                              while(var30.hasMoreElements()) {
                                 Object var43 = var30.nextElement();
                                 var36 = "unable to resolve reference: " + var43;
                                 if(var39 == null) {
                                    var39 = new ValidationException(var36);
                                    var29 = var39;
                                 } else {
                                    var29.setNext(new ValidationException(var36));
                                    var29 = var29.getNext();
                                 }
                              }
                           }

                           try {
                              Validator var34 = new Validator();
                              ValidationContext var45 = new ValidationContext();
                              var45.setInternalContext(this.getInternalContext());
                              var34.validate(state._object, var45);
                              if(!this.getInternalContext().getLenientIdValidation()) {
                                 var34.checkUnresolvedIdrefs(var45);
                              }

                              var45.cleanup();
                           } catch (ValidationException var17) {
                              if(var39 == null) {
                                 var39 = var17;
                              } else {
                                 var29.setNext(var17);
                              }
                           }

                           if(var39 != null) {
                              throw new SAXException(var39);
                           }
                        }

                     } else if(descriptor.isIncremental()) {
                        this._namespaces = this._namespaces.getParent();
                     } else {
                        Object var25 = state._object;
                        if(this._node != null) {
                           var25 = this._node;
                           this._node = null;
                        }

                        var27 = state;
                        boolean var28 = false;
                        state = (UnmarshalState)this._stateInfo.peek();
                        if(state._wrapper) {
                           state = var27._targetState;
                        }

                        if(!descriptor.isMultivalued()) {
                           if(state.isUsed(descriptor)) {
                              ex = "element \"" + name;
                              ex = ex + "\" occurs more than once. (parent class: " + state._type.getName() + ")";
                              var36 = name;

                              while(true) {
                                 UnmarshalState pw;
                                 do {
                                    if(this._stateInfo.isEmpty()) {
                                       ex = ex + "\n location: /" + var36;
                                       ValidationException var38 = new ValidationException(ex);
                                       throw new SAXException(var38);
                                    }

                                    pw = (UnmarshalState)this._stateInfo.pop();
                                 } while(!pw._wrapper && pw._fieldDesc.isContainer());

                                 var36 = state._elementName + "/" + var36;
                              }
                           }

                           state.markAsUsed(descriptor);
                           if(state._classDesc.getIdentity() == descriptor) {
                              state._key = var25;
                           }
                        } else {
                           if(!state.isUsed(descriptor)) {
                              var28 = true;
                           }

                           state.markAsUsed(descriptor);
                        }

                        try {
                           FieldHandler var42 = descriptor.getHandler();
                           var36 = descriptor.getSchemaType();
                           if(var36 != null && var36.equals("QName")) {
                              var25 = this.resolveNamespace(var25);
                           }

                           boolean var41 = true;
                           if(this._reuseObjects && var27._primitiveOrImmutable) {
                              Object var46 = var42.getValue(state._object);
                              if(var46 != null) {
                                 var41 = !var46.equals(var25);
                              }
                           }

                           if(descriptor.isMapped()) {
                              MapItem var47;
                              if(!(var25 instanceof MapItem)) {
                                 var47 = new MapItem(var27._key, var25);
                                 var25 = var47;
                              } else {
                                 var47 = (MapItem)var25;
                                 if(var47.getValue() == null) {
                                    var41 = false;
                                    this.addReference(var47.toString(), state._object, descriptor);
                                 }
                              }
                           }

                           if(var41) {
                              if(var28 && this._clearCollections) {
                                 var42.resetValue(state._object);
                              }

                              if(descriptor.isMultivalued() && descriptor.getSchemaType() != null && descriptor.getSchemaType().equals("list") && ((XMLFieldDescriptorImpl)descriptor).isDerivedFromXSList()) {
                                 List var48 = (List)var25;
                                 Iterator iterator = var48.iterator();

                                 while(iterator.hasNext()) {
                                    Object value = iterator.next();
                                    var42.setValue(state._object, value);
                                    if(this._unmarshalListener != null) {
                                       this._unmarshalListener.fieldAdded(descriptor.getFieldName(), state._object, var27._object);
                                    }
                                 }
                              } else {
                                 var42.setValue(state._object, var25);
                                 if(this._unmarshalListener != null) {
                                    this._unmarshalListener.fieldAdded(descriptor.getFieldName(), state._object, var27._object);
                                 }
                              }
                           }
                        } catch (Exception var18) {
                           StringWriter var37 = new StringWriter();
                           PrintWriter var40 = new PrintWriter(var37);
                           var18.printStackTrace(var40);
                           var40.flush();
                           String err = "unable to add \'" + name + "\' to <";
                           err = err + state._fieldDesc.getXMLName();
                           err = err + "> due to the following exception: \n";
                           err = err + ">>>--- Begin Exception ---<<< \n";
                           err = err + var37.toString();
                           err = err + ">>>---- End Exception ----<<< \n";
                           throw new SAXException(err, var18);
                        }

                        this._namespaces = this._namespaces.getParent();
                        if(state._fieldDesc.isContainer() && state._classDesc.isChoice() && !state._fieldDesc.isMultivalued()) {
                           this.endElement(state._elementName);
                        }

                     }
                  }
               }
            }
         }
      }
   }

   private byte[] decodeBinaryData(XMLFieldDescriptor descriptor, String binaryData) {
      byte[] decodedValue;
      if((!descriptor.isMultivalued() || !"hexBinary".equals(descriptor.getComponentType())) && !"hexBinary".equals(descriptor.getSchemaType())) {
         decodedValue = Base64Decoder.decode(binaryData);
      } else {
         decodedValue = HexDecoder.decode(binaryData);
      }

      return decodedValue;
   }

   public void endElement(String namespaceURI, String localName, String qName) throws SAXException {
      if(qName == null || qName.length() == 0) {
         String prefix;
         if(localName == null || localName.length() == 0) {
            prefix = "Missing either \'qName\' or \'localName\', both cannot be null or emtpy.";
            throw new SAXException(prefix);
         }

         qName = localName;
         if(namespaceURI != null && namespaceURI.length() > 0) {
            prefix = this._namespaces.getNamespacePrefix(namespaceURI);
            if(prefix != null && prefix.length() > 0) {
               qName = prefix + ":" + localName;
            }
         }
      }

      this.endElement(qName);
   }

   public void endPrefixMapping(String prefix) throws SAXException {
      if(this._anyUnmarshaller != null) {
         this._anyUnmarshaller.endPrefixMapping(prefix);
      }

   }

   public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
      if(this._ignoreElementDepth <= 0) {
         if(!this._stateInfo.empty()) {
            if(this._anyUnmarshaller != null) {
               this._anyUnmarshaller.ignorableWhitespace(ch, start, length);
            } else {
               UnmarshalState state = (UnmarshalState)this._stateInfo.peek();
               if(state._wsPreserve) {
                  if(state._buffer == null) {
                     state._buffer = new StringBuffer();
                  }

                  state._buffer.append(ch, start, length);
               }
            }

         }
      }
   }

   public void processingInstruction(String target, String data) throws SAXException {
   }

   public void setDocumentLocator(Locator locator) {
      this._locator = locator;
   }

   public Locator getDocumentLocator() {
      return this._locator;
   }

   public void skippedEntity(String name) throws SAXException {
   }

   public void startDocument() throws SAXException {
   }

   public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException {
      if(LOG.isTraceEnabled()) {
         if(qName != null && qName.length() > 0) {
            LOG.trace("#startElement: " + qName);
         } else {
            LOG.trace("#startElement: " + localName);
         }
      }

      if(!this._strictElements && this._ignoreElementDepth > 0) {
         ++this._ignoreElementDepth;
      } else if(this._anyUnmarshaller != null) {
         ++this._depth;
         this._anyUnmarshaller.startElement(namespaceURI, localName, qName, atts);
      } else {
         if(this._createNamespaceScope) {
            this._namespaces = this._namespaces.createNamespaces();
         } else {
            this._createNamespaceScope = true;
         }

         if(this._reusableAtts == null) {
            if(atts != null) {
               this._reusableAtts = new AttributeSetImpl(atts.getLength());
            } else {
               this._reusableAtts = new AttributeSetImpl();
            }
         } else {
            this._reusableAtts.clear();
         }

         boolean hasQNameAtts = false;
         int idx;
         String defaultNamespace;
         if(atts != null && atts.getLength() > 0) {
            for(idx = 0; idx < atts.getLength(); ++idx) {
               defaultNamespace = atts.getQName(idx);
               if(defaultNamespace != null && defaultNamespace.length() > 0) {
                  if(defaultNamespace.equals("xmlns")) {
                     this._namespaces.addNamespace("", atts.getValue(idx));
                  } else if(defaultNamespace.startsWith("xmlns:")) {
                     String idx1 = defaultNamespace.substring("xmlns:".length());
                     this._namespaces.addNamespace(idx1, atts.getValue(idx));
                  } else if(defaultNamespace.indexOf(58) < 0) {
                     this._reusableAtts.setAttribute(defaultNamespace, atts.getValue(idx), atts.getURI(idx));
                  } else {
                     hasQNameAtts = true;
                  }
               } else {
                  defaultNamespace = atts.getLocalName(idx);
                  if("xmlns".equals(defaultNamespace)) {
                     this._namespaces.addNamespace("", atts.getValue(idx));
                  } else {
                     this._reusableAtts.setAttribute(defaultNamespace, atts.getValue(idx), atts.getURI(idx));
                  }
               }
            }
         }

         if(hasQNameAtts) {
            for(idx = 0; idx < atts.getLength(); ++idx) {
               defaultNamespace = atts.getQName(idx);
               if(defaultNamespace != null && defaultNamespace.length() > 0 && !defaultNamespace.equals("xmlns") && !defaultNamespace.startsWith("xmlns:")) {
                  int var12 = defaultNamespace.indexOf(58);
                  if(var12 >= 0) {
                     String prefix = defaultNamespace.substring(0, var12);
                     defaultNamespace = defaultNamespace.substring(var12 + 1);
                     String nsURI = atts.getURI(idx);
                     if(nsURI == null || nsURI.length() == 0) {
                        nsURI = this._namespaces.getNamespaceURI(prefix);
                     }

                     this._reusableAtts.setAttribute(defaultNamespace, atts.getValue(idx), nsURI);
                  }
               }
            }
         }

         if(this._elemInfo == null) {
            this._elemInfo = new UnmarshalHandler.ElementInfo((String)null, atts);
         } else {
            this._elemInfo.clear();
            this._elemInfo._attributes = atts;
         }

         String var11;
         if(localName != null && localName.length() != 0) {
            if(qName != null && qName.length() != 0) {
               this._elemInfo._qName = qName;
            } else if(namespaceURI != null && namespaceURI.length() != 0) {
               var11 = this._namespaces.getNamespacePrefix(namespaceURI);
               if(var11 != null && var11.length() > 0) {
                  this._elemInfo._qName = var11 + ":" + localName;
               }
            } else {
               this._elemInfo._qName = localName;
            }
         } else {
            if(qName == null || qName.length() == 0) {
               var11 = "Missing either \'localName\' or \'qName\', both cannot be emtpy or null.";
               throw new SAXException(var11);
            }

            localName = qName;
            this._elemInfo._qName = qName;
         }

         idx = localName.indexOf(58);
         if(idx >= 0) {
            defaultNamespace = localName.substring(0, idx);
            localName = localName.substring(idx + 1);
            if(namespaceURI == null || namespaceURI.length() == 0) {
               namespaceURI = this._namespaces.getNamespaceURI(defaultNamespace);
            }
         } else {
            defaultNamespace = this._namespaces.getNamespaceURI("");
            if(defaultNamespace != null && !defaultNamespace.equals("http://castor.exolab.org")) {
               namespaceURI = defaultNamespace;
            }

            if(namespaceURI != null && namespaceURI.length() == 0) {
               namespaceURI = null;
            }
         }

         this.startElement(localName, namespaceURI, this._reusableAtts);
      }
   }

   public void startElement(String name, AttributeList attList) throws SAXException {
      if(LOG.isTraceEnabled()) {
         LOG.trace("#startElement: " + name);
      }

      if(!this._strictElements && this._ignoreElementDepth > 0) {
         ++this._ignoreElementDepth;
      } else if(this._anyUnmarshaller != null) {
         ++this._depth;
         this._anyUnmarshaller.startElement(name, attList);
      } else {
         if(this._elemInfo == null) {
            this._elemInfo = new UnmarshalHandler.ElementInfo(name, attList);
         } else {
            this._elemInfo.clear();
            this._elemInfo._qName = name;
            this._elemInfo._attributeList = attList;
         }

         String namespace = null;
         this._namespaces = this._namespaces.createNamespaces();
         AttributeSet atts = this.processAttributeList(attList);
         String prefix = "";
         int idx = name.indexOf(58);
         if(idx >= 0) {
            prefix = name.substring(0, idx);
            name = name.substring(idx + 1);
         }

         namespace = this._namespaces.getNamespaceURI(prefix);
         this.startElement(name, namespace, atts);
      }
   }

   private void startElement(String name, String namespace, AttributeSet atts) throws SAXException {
      UnmarshalState state = null;
      String xmlSpace = null;
      if(atts != null) {
         xmlSpace = atts.getValue("space", "http://www.w3.org/XML/1998/namespace");
         if(xmlSpace == null) {
            xmlSpace = atts.getValue("xml:space", "");
         }
      }

      String classDesc;
      XMLClassDescriptor cdInherited;
      String path;
      if(this._stateInfo.empty()) {
         if(this._topClass == null && this._topObject != null) {
            this._topClass = this._topObject.getClass();
         }

         if(this.getInternalContext().getXMLClassDescriptorResolver() == null) {
            String var44 = "XMLClassDescriptorResolver is not set!";
            LOG.warn(var44);
            throw new IllegalStateException(var44);
         } else {
            this._topState = new UnmarshalState();
            this._topState._elementName = name;
            this._topState._wsPreserve = xmlSpace != null?"preserve".equals(xmlSpace):this._wsPreserve;
            Object var39 = null;
            String var40 = null;
            if(this._topClass == null) {
               var40 = this.getInstanceType(atts, (String)null);
               if(var40 != null) {
                  try {
                     this._topClass = this.loadClass(var40, (ClassLoader)null);
                  } catch (ClassNotFoundException var29) {
                     ;
                  }

                  if(this._topClass == null) {
                     var39 = this.getClassDescriptor(var40);
                     if(var39 != null) {
                        this._topClass = ((XMLClassDescriptor)var39).getJavaClass();
                     }

                     if(this._topClass == null) {
                        throw new SAXException("Class not found: " + var40);
                     }
                  }
               } else {
                  var39 = this.resolveByXMLName(name, namespace, (ClassLoader)null);
                  if(var39 == null) {
                     var39 = this.getClassDescriptor(name, this._loader);
                     if(var39 == null) {
                        var39 = this.getClassDescriptor(this.getJavaNaming().toJavaClassName(name));
                     }
                  }

                  if(var39 != null) {
                     this._topClass = ((XMLClassDescriptor)var39).getJavaClass();
                  }
               }

               if(this._topClass == null) {
                  String var51 = "The class for the root element \'" + name + "\' could not be found.";
                  throw new SAXException(var51);
               }
            }

            XMLFieldDescriptorImpl var50 = new XMLFieldDescriptorImpl(this._topClass, name, name, NodeType.Element);
            this._topState._fieldDesc = var50;
            if(var39 == null) {
               var39 = this.getClassDescriptor(this._topClass);
            }

            if(var39 == null && isPrimitive(this._topClass)) {
               var39 = new PrimitivesClassDescriptor(this._topClass);
               var50.setIncremental(false);
               this._topState._primitiveOrImmutable = true;
            }

            var50.setClassDescriptor((ClassDescriptor)var39);
            if(var39 == null) {
               if(!isPrimitive(this._topClass) && !Serializable.class.isAssignableFrom(this._topClass)) {
                  throw new SAXException("The marshaller cannot unmarshal non primitive types that do not implement java.io.Serializable");
               } else {
                  classDesc = "unable to create XMLClassDescriptor for class: " + this._topClass.getName();
                  throw new SAXException(classDesc);
               }
            } else {
               this._topState._classDesc = (XMLClassDescriptor)var39;
               this._topState._type = this._topClass;
               if(this._topObject == null && !this._topState._primitiveOrImmutable) {
                  classDesc = this.getJavaPackage(this._topClass);
                  if(var40 == null) {
                     var40 = this.getInstanceType(atts, classDesc);
                  } else {
                     var40 = null;
                  }

                  if(var40 != null) {
                     Class var49 = null;

                     try {
                        cdInherited = this.getClassDescriptor(var40);
                        boolean var47 = true;
                        if(cdInherited != null) {
                           var49 = cdInherited.getJavaClass();
                           if(var49 != null) {
                              var47 = !var40.equals(var49.getName());
                           }
                        }

                        if(var47) {
                           try {
                              var49 = this.loadClass(var40, (ClassLoader)null);
                           } catch (ClassNotFoundException var36) {
                              if(cdInherited != null) {
                                 var49 = cdInherited.getJavaClass();
                              }
                           }
                        }

                        if(var49 == null) {
                           throw new SAXException("Class not found: " + var40);
                        }

                        if(!this._topClass.isAssignableFrom(var49)) {
                           path = var49 + " is not a subclass of " + this._topClass;
                           throw new SAXException(path);
                        }
                     } catch (Exception var37) {
                        String var46 = "unable to instantiate " + var40 + "; ";
                        throw new SAXException(var46 + var37, var37);
                     }

                     UnmarshalHandler.Arguments var45 = this.processConstructorArgs(atts, (XMLClassDescriptor)var39);
                     this._topState._object = this.createInstance(var49, var45);
                  } else {
                     UnmarshalHandler.Arguments var48 = this.processConstructorArgs(atts, (XMLClassDescriptor)var39);
                     this._topState._object = this.createInstance(this._topClass, var48);
                  }
               } else {
                  this._topState._object = this._topObject;
               }

               this._stateInfo.push(this._topState);
               if(!this._topState._primitiveOrImmutable) {
                  if(this._unmarshalListener != null) {
                     this._unmarshalListener.initialized(this._topState._object, this._topState._parent == null?null:this._topState._parent._object);
                  }

                  this.processAttributes(atts, (XMLClassDescriptor)var39);
                  if(this._unmarshalListener != null) {
                     this._unmarshalListener.attributesProcessed(this._topState._object, this._topState._parent == null?null:this._topState._parent._object);
                  }

                  this.processNamespaces((XMLClassDescriptor)var39);
               }

               classDesc = this.getJavaPackage(this._topClass);
               if(this.getMappedPackage(namespace) == null) {
                  this.addNamespaceToPackageMapping(namespace, classDesc);
               }

            }
         }
      } else {
         UnmarshalState parentState = (UnmarshalState)this._stateInfo.peek();

         XMLClassDescriptor cls;
         for(boolean canAccept = false; parentState._fieldDesc != null && parentState._fieldDesc.isContainer() && !canAccept; cls = null) {
            cls = parentState._classDesc;
            if(cls == null) {
               cls = (XMLClassDescriptor)parentState._fieldDesc.getClassDescriptor();
               if(cls == null) {
                  cls = this.getClassDescriptor(parentState._object.getClass());
               }
            }

            canAccept = cls.canAccept(name, namespace, parentState._object);
            if(!canAccept) {
               if(cls.getFieldDescriptor(name, namespace, NodeType.Element) != null && !parentState._fieldDesc.isMultivalued()) {
                  classDesc = "The container object (" + cls.getJavaClass().getName();
                  classDesc = classDesc + ") cannot accept the child object associated with the element \'" + name + "\'";
                  classDesc = classDesc + " because the container is already full!";
                  ValidationException descriptor = new ValidationException(classDesc);
                  throw new SAXException(descriptor);
               }

               this.endElement(parentState._elementName);
               parentState = (UnmarshalState)this._stateInfo.peek();
            }
         }

         state = new UnmarshalState();
         state._elementName = name;
         state._parent = parentState;
         if(xmlSpace != null) {
            state._wsPreserve = "preserve".equals(xmlSpace);
         } else {
            state._wsPreserve = parentState._wsPreserve;
         }

         this._stateInfo.push(state);
         if(parentState._object != null || parentState._wrapper) {
            cls = null;
            XMLClassDescriptor var41 = parentState._classDesc;
            if(var41 == null) {
               var41 = (XMLClassDescriptor)parentState._fieldDesc.getClassDescriptor();
               if(var41 == null) {
                  var41 = this.getClassDescriptor(parentState._object.getClass());
               }
            }

            XMLFieldDescriptor var43 = null;
            cdInherited = null;
            UnmarshalState targetState = parentState;
            path = "";
            StringBuffer pathBuf = null;
            int count = 0;

            boolean isWrapper;
            String object;
            String handler;
            for(isWrapper = false; var43 == null; ++count) {
               if(path.length() > 0) {
                  object = path + "/" + name;
                  var43 = var41.getFieldDescriptor(object, namespace, NodeType.Element);
               }

               if(var43 == null) {
                  var43 = var41.getFieldDescriptor(name, namespace, NodeType.Element);
               }

               if(var43 != null && !var43.isContainer() && namespace != null && namespace.length() > 0 && !namespaceEquals(namespace, var43.getNameSpaceURI()) && (var43.getNameSpaceURI() != null || !var43.matches("*"))) {
                  var43 = null;
               }

               if(var43 == null && !targetState._wrapper) {
                  InheritanceMatch[] var52 = null;

                  try {
                     var52 = this.searchInheritance(name, namespace, var41);
                  } catch (MarshalException var35) {
                     ;
                  }

                  if(var52.length != 0) {
                     InheritanceMatch var53 = null;

                     for(int useHandler = 0; useHandler < var52.length; ++useHandler) {
                        if(parentState._elementName.equals(var52[useHandler].parentFieldDesc.getLocationPath())) {
                           var53 = var52[useHandler];
                           break;
                        }
                     }

                     if(var53 == null) {
                        var53 = var52[0];
                     }

                     var43 = var53.parentFieldDesc;
                     cdInherited = var53.inheritedClassDesc;
                     break;
                  }

                  handler = name;
                  if(count > 0) {
                     handler = path + "/" + name;
                  }

                  isWrapper = isWrapper || hasFieldsAtLocation(handler, var41);
               } else if(var43 != null) {
                  object = var43.getLocationPath();
                  if(object == null) {
                     object = "";
                  }

                  if(path.equals(object)) {
                     break;
                  }

                  var43 = null;
               } else {
                  if(pathBuf == null) {
                     pathBuf = new StringBuffer();
                  } else {
                     pathBuf.setLength(0);
                  }

                  pathBuf.append(path);
                  pathBuf.append('/');
                  pathBuf.append(name);
                  isWrapper = isWrapper || hasFieldsAtLocation(pathBuf.toString(), var41);
               }

               if(targetState == this._topState) {
                  break;
               }

               if(count == 0) {
                  path = targetState._elementName;
               } else {
                  if(pathBuf == null) {
                     pathBuf = new StringBuffer();
                  } else {
                     pathBuf.setLength(0);
                  }

                  pathBuf.append(targetState._elementName);
                  pathBuf.append('/');
                  pathBuf.append(path);
                  path = pathBuf.toString();
               }

               targetState = targetState._parent;
               var41 = targetState._classDesc;
            }

            if(var43 != null && this.isValidating() && !this.getInternalContext().getLenientSequenceOrder()) {
               try {
                  var41.checkDescriptorForCorrectOrderWithinSequence(var43, parentState, name);
               } catch (ValidationException var34) {
                  throw new SAXException(var34);
               }
            }

            if(var43 == null) {
               var41 = var41;
               if(isWrapper) {
                  state._classDesc = new XMLClassDescriptorImpl(ContainerElement.class, name);
                  state._wrapper = true;
                  if(LOG.isDebugEnabled()) {
                     LOG.debug("wrapper-element: " + name);
                  }

                  this.processWrapperAttributes(atts);
               } else {
                  object = "unable to find FieldDescriptor for \'" + name;
                  object = object + "\' in ClassDescriptor of " + var41.getXMLName();
                  if(var41 instanceof InternalXMLClassDescriptor) {
                     var41 = ((InternalXMLClassDescriptor)var41).getClassDescriptor();
                  }

                  boolean var61 = this.getInternalContext().getBooleanProperty("org.exolab.castor.xml.lenient.introspected.element.strictness").booleanValue();
                  if(!this._strictElements) {
                     ++this._ignoreElementDepth;
                     this._stateInfo.pop();
                     this._namespaces = this._namespaces.getParent();
                     if(LOG.isDebugEnabled()) {
                        LOG.debug(object + " - ignoring extra element.");
                     }

                  } else if(var61 && Introspector.introspected(var41)) {
                     LOG.warn(object);
                  } else {
                     throw new SAXException(object);
                  }
               }
            } else {
               if(targetState != parentState) {
                  state._targetState = targetState;
                  parentState = targetState;
               }

               Object var54 = parentState._object;
               if(var43.isContainer()) {
                  if(LOG.isDebugEnabled()) {
                     LOG.debug("#container: " + var43.getFieldName());
                  }

                  state.clear();
                  state._wsPreserve = parentState._wsPreserve;
                  state._parent = parentState;
                  state._elementName = var43.getFieldName();
                  state._fieldDesc = var43;
                  state._classDesc = (XMLClassDescriptor)var43.getClassDescriptor();
                  handler = null;
                  Object var60;
                  if(!var43.isMultivalued()) {
                     FieldHandler var58 = var43.getHandler();
                     var60 = var58.getValue(var54);
                     if(var60 != null) {
                        if(state._classDesc != null) {
                           if(state._classDesc.canAccept(name, namespace, var60)) {
                              parentState.markAsNotUsed(var43);
                           }
                        } else {
                           parentState.markAsNotUsed(var43);
                        }
                     } else {
                        var60 = var58.newInstance(var54);
                     }
                  } else {
                     Class var59 = var43.getFieldType();

                     try {
                        var60 = var59.newInstance();
                     } catch (Exception var30) {
                        throw new SAXException(var30);
                     }
                  }

                  state._object = var60;
                  state._type = var60.getClass();
                  this._namespaces = this._namespaces.createNamespaces();
                  this.startElement(name, namespace, atts);
               } else {
                  state._fieldDesc = var43;
                  var41 = null;
                  if(cdInherited != null) {
                     var41 = cdInherited;
                  } else if(!name.equals(var43.getXMLName())) {
                     var41 = this.resolveByXMLName(name, namespace, (ClassLoader)null);
                  }

                  if(var41 == null) {
                     var41 = (XMLClassDescriptor)var43.getClassDescriptor();
                  }

                  FieldHandler var56 = var43.getHandler();
                  boolean var55 = true;

                  String nil;
                  String err;
                  Class var42;
                  try {
                     if(var41 != null) {
                        var42 = var41.getJavaClass();
                        if(var43.getFieldType() != var42) {
                           state._derived = true;
                        }
                     } else {
                        var42 = var43.getFieldType();
                     }

                     if(var42 == null) {
                        var42 = Object.class;
                     }

                     nil = this.getJavaPackage(parentState._type);
                     err = this.getInstanceType(atts, nil);
                     Class byteArray;
                     String err1;
                     if(err != null) {
                        byteArray = null;

                        try {
                           XMLClassDescriptor ex = this.getClassDescriptor(err, this._loader);
                           boolean var66 = true;
                           if(ex != null) {
                              byteArray = ex.getJavaClass();
                              var41 = ex;
                              if(byteArray != null) {
                                 var66 = !byteArray.getName().equals(err);
                              }
                           }

                           if(var66) {
                              byteArray = this.loadClass(err, (ClassLoader)null);
                              FieldHandler sx = var43.getHandler();
                              boolean idx = false;
                              if(sx instanceof FieldHandlerImpl) {
                                 idx = ((FieldHandlerImpl)sx).isCollection();
                              } else {
                                 idx = Introspector.isCollection(byteArray);
                              }

                              if(!idx && !var42.isAssignableFrom(byteArray) && !isPrimitive(var42)) {
                                 String err2 = byteArray.getName() + " is not a subclass of " + var42.getName();
                                 throw new SAXException(err2);
                              }
                           }

                           var42 = byteArray;
                           var55 = false;
                        } catch (Exception var33) {
                           err1 = "unable to instantiate " + err;
                           throw new SAXException(err1 + "; " + var33, var33);
                        }
                     }

                     if(var42 == Object.class && parentState._object instanceof UnmarshalHandler.ArrayHandler) {
                        var42 = ((UnmarshalHandler.ArrayHandler)parentState._object).componentType();
                     }

                     String var67;
                     if(var42 == Object.class) {
                        byteArray = parentState._type;
                        ClassLoader var62 = byteArray.getClassLoader();
                        var41 = this.resolveByXMLName(name, namespace, var62);
                        err1 = null;
                        if(var41 == null) {
                           err1 = this.getJavaNaming().toJavaClassName(name);
                           var41 = this.getClassDescriptor(err1, var62);
                        }

                        if(var41 == null) {
                           var67 = byteArray.getName();
                           int var71 = var67.lastIndexOf(46);
                           if(var71 > 0) {
                              var67 = var67.substring(0, var71 + 1);
                              err1 = var67 + err1;
                              var41 = this.getClassDescriptor(err1, var62);
                           }
                        }

                        if(var41 == null) {
                           this._anyUnmarshaller = new SAX2ANY(this._namespaces, state._wsPreserve);
                           if(this._elemInfo._attributeList != null) {
                              this._anyUnmarshaller.startElement(this._elemInfo._qName, this._elemInfo._attributeList);
                           } else {
                              this._anyUnmarshaller.startElement(namespace, name, this._elemInfo._qName, this._elemInfo._attributes);
                           }

                           this._depth = 1;
                           state._object = this._anyUnmarshaller.getStartingNode();
                           state._type = var42;
                           return;
                        }

                        var42 = var41.getJavaClass();
                        var55 = false;
                     }

                     boolean var63 = false;
                     if(var42.isArray()) {
                        var63 = var42.getComponentType() == Byte.TYPE;
                     }

                     UnmarshalHandler.Arguments var64;
                     if(!isPrimitive(var42) && !var43.isImmutable() && !var63) {
                        if(var41 == null) {
                           var41 = this.getClassDescriptor(var42);
                        }

                        if(!state._derived && var55) {
                           boolean var65 = true;
                           if(this._reuseObjects) {
                              state._object = var56.getValue(parentState._object);
                              var65 = state._object == null;
                           }

                           if(var65) {
                              UnmarshalHandler.Arguments var70 = this.processConstructorArgs(atts, var41);
                              if(var70._values != null && var70._values.length > 0) {
                                 if(!(var56 instanceof ExtendedFieldHandler)) {
                                    var67 = "constructor arguments can only be used with an ExtendedFieldHandler.";
                                    throw new SAXException(var67);
                                 }

                                 ExtendedFieldHandler var68 = (ExtendedFieldHandler)var56;
                                 state._object = var68.newInstance(parentState._object, var70._values);
                              } else {
                                 state._object = var56.newInstance(parentState._object);
                              }
                           }
                        }

                        if(state._object != null) {
                           var42 = state._object.getClass();
                           if(var41 != null && var41.getJavaClass() != var42) {
                              var41 = null;
                           }
                        } else {
                           try {
                              if(var42.isArray()) {
                                 state._object = new UnmarshalHandler.ArrayHandler(var42.getComponentType());
                                 var42 = UnmarshalHandler.ArrayHandler.class;
                              } else {
                                 var64 = this.processConstructorArgs(atts, var41);
                                 state._object = this.createInstance(var42, var64);
                              }
                           } catch (Exception var32) {
                              err1 = "unable to instantiate a new type of: ";
                              err1 = err1 + this.className(var42);
                              err1 = err1 + "; " + var32.getMessage();
                              SAXException var69 = new SAXException(err1, var32);
                              throw var69;
                           }
                        }
                     } else {
                        state._object = null;
                        state._primitiveOrImmutable = true;
                        if(var43.isImmutable()) {
                           if(var41 == null) {
                              var41 = this.getClassDescriptor(var42);
                           }

                           state._classDesc = var41;
                           var64 = this.processConstructorArgs(atts, var41);
                           if(var64 != null && var64.size() > 0) {
                              state._args = var64;
                           }
                        }
                     }

                     state._type = var42;
                  } catch (IllegalStateException var38) {
                     LOG.error(var38.toString());
                     throw new SAXException(var38);
                  }

                  if(var41 == null) {
                     var41 = this.getClassDescriptor(var42);
                  }

                  state._classDesc = var41;
                  if(state._object == null && !state._primitiveOrImmutable) {
                     nil = "unable to unmarshal: " + name + "\n";
                     nil = nil + " - unable to instantiate: " + this.className(var42);
                     throw new SAXException(nil);
                  } else {
                     if(var43.isIncremental()) {
                        if(LOG.isDebugEnabled()) {
                           LOG.debug("debug: Processing incrementally for element: " + name);
                        }

                        try {
                           var56.setValue(parentState._object, state._object);
                        } catch (IllegalStateException var31) {
                           err = "unable to add \"" + name + "\" to ";
                           err = err + parentState._fieldDesc.getXMLName();
                           err = err + " due to the following error: " + var31;
                           throw new SAXException(err, var31);
                        }
                     }

                     if(state._object != null) {
                        if(this._unmarshalListener != null) {
                           this._unmarshalListener.initialized(state._object, state._parent == null?null:state._parent._object);
                        }

                        this.processAttributes(atts, var41);
                        if(this._unmarshalListener != null) {
                           this._unmarshalListener.attributesProcessed(state._object, state._parent == null?null:state._parent._object);
                        }

                        this.processNamespaces(var41);
                     } else if(state._type != null && !state._primitiveOrImmutable) {
                        if(atts != null) {
                           this.processWrapperAttributes(atts);
                           StringBuffer var57 = new StringBuffer();
                           var57.append("The current object for element \'");
                           var57.append(name);
                           var57.append("\' is null. Processing attributes as location");
                           var57.append("/wrapper only and ignoring all other attribtes.");
                           LOG.warn(var57.toString());
                        }
                     } else if(atts != null) {
                        nil = atts.getValue("nil", "http://www.w3.org/2001/XMLSchema-instance");
                        state._nil = "true".equals(nil);
                        this.processWrapperAttributes(atts);
                     }

                  }
               }
            }
         }
      }
   }

   private boolean isValidating() {
      return this._validate;
   }

   public void startPrefixMapping(String prefix, String uri) throws SAXException {
      if(!"xml".equals(prefix) || !"http://www.w3.org/XML/1998/namespace".equals(uri)) {
         if(!"xmlns".equals(prefix)) {
            if(this._anyUnmarshaller != null) {
               this._anyUnmarshaller.startPrefixMapping(prefix, uri);
            } else if(this._createNamespaceScope) {
               this._namespaces = this._namespaces.createNamespaces();
               this._createNamespaceScope = false;
            }

            this._namespaces.addNamespace(prefix, uri);
         }
      }
   }

   public void error(SAXParseException exception) throws SAXException {
      String err = "Parsing Error : " + exception.getMessage() + '\n' + "Line : " + exception.getLineNumber() + '\n' + "Column : " + exception.getColumnNumber() + '\n';
      throw new SAXException(err, exception);
   }

   public void fatalError(SAXParseException exception) throws SAXException {
      String err = "Parsing Error : " + exception.getMessage() + '\n' + "Line : " + exception.getLineNumber() + '\n' + "Column : " + exception.getColumnNumber() + '\n';
      throw new SAXException(err, exception);
   }

   public void warning(SAXParseException exception) throws SAXException {
      String err = "Parsing Error : " + exception.getMessage() + '\n' + "Line : " + exception.getLineNumber() + '\n' + "Column : " + exception.getColumnNumber() + '\n';
      throw new SAXException(err, exception);
   }

   private void addReference(String idRef, Object parent, XMLFieldDescriptor descriptor) {
      ReferenceInfo refInfo = new ReferenceInfo(idRef, parent, descriptor);
      refInfo.setNext((ReferenceInfo)this._resolveTable.get(idRef));
      this._resolveTable.put(idRef, refInfo);
   }

   private Object createInstance(Class type, UnmarshalHandler.Arguments args) throws SAXException {
      Object instance = null;

      try {
         if(args == null) {
            instance = this._objectFactory.createInstance(type);
         } else {
            instance = this._objectFactory.createInstance(type, args._types, args._values);
         }

         return instance;
      } catch (Exception var6) {
         String msg = "Unable to instantiate " + type.getName() + "; ";
         throw new SAXException(msg, var6);
      }
   }

   private String getInstanceType(AttributeSet atts, String currentPackage) throws SAXException {
      if(atts == null) {
         return null;
      } else {
         String type = atts.getValue("type", "http://www.w3.org/2001/XMLSchema-instance");
         if(type != null) {
            if(type.startsWith("java:")) {
               return type.substring("java:".length());
            }

            int idx = type.indexOf(58);
            String typeNamespaceURI = null;
            String classDesc;
            if(idx >= 0) {
               classDesc = type.substring(0, idx);
               type = type.substring(idx + 1);
               typeNamespaceURI = this._namespaces.getNamespaceURI(classDesc);
            }

            classDesc = null;

            try {
               XMLClassDescriptor classDesc1 = this.getInternalContext().getXMLClassDescriptorResolver().resolveByXMLName(type, typeNamespaceURI, this._loader);
               if(classDesc1 != null) {
                  return classDesc1.getJavaClass().getName();
               }

               String rx = this.getJavaNaming().toJavaClassName(type);
               String adjClassName = rx;
               String mappedPackage = this.getMappedPackage(typeNamespaceURI);
               if(mappedPackage != null && mappedPackage.length() > 0) {
                  adjClassName = mappedPackage + "." + rx;
               }

               classDesc1 = this.getInternalContext().getXMLClassDescriptorResolver().resolve(adjClassName, this._loader);
               if(classDesc1 != null) {
                  return classDesc1.getJavaClass().getName();
               }

               if(currentPackage != null && currentPackage.length() > 0) {
                  adjClassName = currentPackage + '.' + rx;
               }

               classDesc1 = this.getInternalContext().getXMLClassDescriptorResolver().resolve(adjClassName, this._loader);
               if(classDesc1 != null) {
                  return classDesc1.getJavaClass().getName();
               }

               classDesc1 = this.getInternalContext().getXMLClassDescriptorResolver().resolve(type, this._loader);
               if(classDesc1 != null) {
                  return classDesc1.getJavaClass().getName();
               }
            } catch (ResolverException var10) {
               throw new SAXException(var10);
            }
         }

         return null;
      }
   }

   private String getMappedPackage(String namespace) {
      String lookUpKey = namespace != null?namespace:"";
      return (String)this._namespaceToPackage.get(lookUpKey);
   }

   private void processAttributes(AttributeSet atts, XMLClassDescriptor classDesc) throws SAXException {
      if(atts != null && atts.getSize() != 0) {
         UnmarshalState var21 = (UnmarshalState)this._stateInfo.peek();
         Object var22 = var21._object;
         if(classDesc == null) {
            classDesc = var21._classDesc;
            if(classDesc == null) {
               this.processWrapperAttributes(atts);
               return;
            }
         }

         boolean[] var23 = new boolean[atts.getSize()];
         XMLFieldDescriptor[] var24 = classDesc.getAttributeDescriptors();
         XMLFieldDescriptor[] i = var24;
         int namespace = var24.length;

         XMLFieldDescriptor descriptor;
         String ise;
         String err;
         for(int name = 0; name < namespace; ++name) {
            descriptor = i[name];
            ise = descriptor.getXMLName();
            err = descriptor.getNameSpaceURI();
            String pathBuf = descriptor.getLocationPath();
            String targetState = "";
            if(pathBuf != null && pathBuf.length() > 0) {
               targetState = targetState + pathBuf + "/";
            }

            targetState = targetState + ise;
            int tmpPath;
            if(targetState != null && !ise.equals(targetState)) {
               tmpPath = atts.getIndex(ise, err);
               if(tmpPath >= 0) {
                  var23[tmpPath] = true;
               }
            } else {
               tmpPath = atts.getIndex(ise, err);
               String attValue = null;
               if(tmpPath >= 0) {
                  attValue = atts.getValue(tmpPath);
                  var23[tmpPath] = true;
               }

               try {
                  this.processAttribute(ise, err, attValue, descriptor, classDesc, var22);
               } catch (IllegalStateException var20) {
                  String err1 = "unable to add attribute \"" + ise + "\" to \'";
                  err1 = err1 + var21._classDesc.getJavaClass().getName();
                  err1 = err1 + "\' due to the following error: " + var20;
                  throw new SAXException(err1, var20);
               }
            }
         }

         for(int var25 = 0; var25 < var23.length; ++var25) {
            if(!var23[var25]) {
               String var26 = atts.getNamespace(var25);
               String var27 = atts.getName(var25);
               String var29;
               if("http://www.w3.org/2001/XMLSchema-instance".equals(var26)) {
                  if("nil".equals(var27)) {
                     var29 = atts.getValue(var25);
                     var21._nil = "true".equals(var29);
                  }
               } else if(var27.startsWith("xml:")) {
                  if(LOG.isDebugEnabled()) {
                     var29 = "ignoring attribute \'" + var27 + "\' for class: " + var21._classDesc.getJavaClass().getName();
                     LOG.debug(var29);
                  }
               } else {
                  descriptor = classDesc.getFieldDescriptor(var27, var26, NodeType.Attribute);
                  if(descriptor == null) {
                     int var28 = this._stateInfo.size() - 2;
                     err = var21._elementName;
                     StringBuffer var30 = null;

                     while(var28 >= 0) {
                        UnmarshalState var31 = (UnmarshalState)this._stateInfo.elementAt(var28);
                        --var28;
                        if(var31._wrapper) {
                           if(var30 == null) {
                              var30 = new StringBuffer();
                           } else {
                              var30.setLength(0);
                           }

                           var30.append(var31._elementName);
                           var30.append('/');
                           var30.append(err);
                           err = var30.toString();
                        } else {
                           classDesc = var31._classDesc;
                           descriptor = classDesc.getFieldDescriptor(var27, var26, NodeType.Attribute);
                           if(descriptor != null) {
                              String var32 = descriptor.getLocationPath();
                              if(var32 == null) {
                                 var32 = "";
                              }

                              if(err.equals(var32)) {
                                 break;
                              }
                           }

                           if(var30 == null) {
                              var30 = new StringBuffer();
                           } else {
                              var30.setLength(0);
                           }

                           var30.append(var31._elementName);
                           var30.append('/');
                           var30.append(err);
                           err = var30.toString();
                           descriptor = null;
                        }
                     }
                  }

                  if(descriptor == null) {
                     if(this._strictAttributes) {
                        ise = "The attribute \'" + var27 + "\' appears illegally on element \'" + var21._elementName + "\'.";
                        throw new SAXException(ise);
                     }
                  } else {
                     try {
                        this.processAttribute(var27, var26, atts.getValue(var25), descriptor, classDesc, var22);
                     } catch (IllegalStateException var19) {
                        err = "unable to add attribute \"" + var27 + "\" to \'";
                        err = err + var21._classDesc.getJavaClass().getName();
                        err = err + "\' due to the following error: " + var19;
                        throw new SAXException(err, var19);
                     }
                  }
               }
            }
         }

      } else {
         if(classDesc != null) {
            XMLFieldDescriptor[] state = classDesc.getAttributeDescriptors();

            for(int object = 0; object < state.length; ++object) {
               XMLFieldDescriptor processedAtts = state[object];
               if(processedAtts != null && processedAtts.isRequired() && (this.isValidating() || LOG.isDebugEnabled())) {
                  String descriptors = classDesc.getXMLName() + " is missing " + "required attribute: " + processedAtts.getXMLName();
                  if(this._locator != null) {
                     descriptors = descriptors + "\n  - line: " + this._locator.getLineNumber() + " column: " + this._locator.getColumnNumber();
                  }

                  if(this.isValidating()) {
                     throw new SAXException(descriptors);
                  }

                  LOG.debug(descriptors);
               }
            }
         }

      }
   }

   private void processWrapperAttributes(AttributeSet atts) throws SAXException {
      UnmarshalState state = (UnmarshalState)this._stateInfo.peek();

      for(int i = 0; i < atts.getSize(); ++i) {
         String name = atts.getName(i);
         String namespace = atts.getNamespace(i);
         if(!"http://www.w3.org/2001/XMLSchema-instance".equals(namespace)) {
            XMLFieldDescriptor descriptor = null;
            XMLClassDescriptor classDesc = null;
            int pIdx = this._stateInfo.size() - 2;
            String path = state._elementName;
            StringBuffer pathBuf = null;
            UnmarshalState targetState = null;

            while(pIdx >= 0) {
               targetState = (UnmarshalState)this._stateInfo.elementAt(pIdx);
               --pIdx;
               if(targetState._wrapper) {
                  if(pathBuf == null) {
                     pathBuf = new StringBuffer();
                  } else {
                     pathBuf.setLength(0);
                  }

                  pathBuf.append(targetState._elementName);
                  pathBuf.append('/');
                  pathBuf.append(path);
                  path = pathBuf.toString();
               } else {
                  classDesc = targetState._classDesc;
                  XMLFieldDescriptor[] ise = classDesc.getAttributeDescriptors();
                  boolean err = false;

                  for(int a = 0; a < ise.length; ++a) {
                     descriptor = ise[a];
                     if(descriptor != null && descriptor.matches(name)) {
                        String tmpPath = descriptor.getLocationPath();
                        if(tmpPath == null) {
                           tmpPath = "";
                        }

                        if(path.equals(tmpPath)) {
                           err = true;
                           break;
                        }
                     }
                  }

                  if(err) {
                     break;
                  }

                  if(pathBuf == null) {
                     pathBuf = new StringBuffer();
                  } else {
                     pathBuf.setLength(0);
                  }

                  pathBuf.append(targetState._elementName);
                  pathBuf.append('/');
                  pathBuf.append(path);
                  path = pathBuf.toString();
                  descriptor = null;
               }
            }

            if(descriptor != null) {
               try {
                  this.processAttribute(name, namespace, atts.getValue(i), descriptor, classDesc, targetState._object);
               } catch (IllegalStateException var16) {
                  String var17 = "unable to add attribute \"" + name + "\" to \'";
                  var17 = var17 + state._classDesc.getJavaClass().getName();
                  var17 = var17 + "\' due to the following error: " + var16;
                  throw new SAXException(var17, var16);
               }
            }
         }
      }

   }

   private void processAttribute(String attName, String attNamespace, String attValue, XMLFieldDescriptor descriptor, XMLClassDescriptor classDesc, Object parent) throws SAXException {
      FieldHandler handler;
      while(descriptor.isContainer()) {
         handler = descriptor.getHandler();
         Object type = handler.getValue(parent);
         if(type == null) {
            type = handler.newInstance(parent);
            handler.setValue(parent, type);
         }

         ClassDescriptor valueType = ((XMLFieldDescriptorImpl)descriptor).getClassDescriptor();
         descriptor = ((XMLClassDescriptor)valueType).getFieldDescriptor(attName, attNamespace, NodeType.Attribute);
         parent = type;
      }

      if(attValue == null) {
         if(descriptor.isRequired() && this.isValidating()) {
            String handler3 = classDesc.getXMLName() + " is missing " + "required attribute: " + attName;
            if(this._locator != null) {
               handler3 = handler3 + "\n  - line: " + this._locator.getLineNumber() + " column: " + this._locator.getColumnNumber();
            }

            throw new SAXException(handler3);
         }
      } else {
         if(classDesc.getIdentity() == descriptor) {
            try {
               ((IDResolverImpl)this._idResolver).bind(attValue, parent, this.isValidating() && !this.getInternalContext().getLenientIdValidation());
            } catch (ValidationException var14) {
               throw new SAXException("Duplicate ID " + attValue + " encountered.", var14);
            }

            UnmarshalState handler1 = (UnmarshalState)this._stateInfo.peek();
            handler1._key = attValue;
            this.resolveReferences(attValue, parent);
         } else if(descriptor.isReference()) {
            if(descriptor.isMultivalued()) {
               StringTokenizer handler2 = new StringTokenizer(attValue);

               while(handler2.hasMoreTokens()) {
                  this.processIDREF(handler2.nextToken(), descriptor, parent);
               }
            } else {
               this.processIDREF(attValue, descriptor, parent);
            }

            return;
         }

         if(!descriptor.isConstructorArgument()) {
            handler = descriptor.getHandler();
            if(handler != null) {
               Class type1 = descriptor.getFieldType();
               String valueType1 = descriptor.getSchemaType();
               boolean isPrimative = isPrimitive(type1);
               boolean isQName = valueType1 != null && valueType1.equals("QName");
               boolean isByteArray = false;
               if(type1.isArray()) {
                  isByteArray = type1.getComponentType() == Byte.TYPE;
               }

               if(descriptor.isMultivalued()) {
                  StringTokenizer attrValueTokenizer = new StringTokenizer(attValue);

                  while(attrValueTokenizer.hasMoreTokens()) {
                     attValue = attrValueTokenizer.nextToken();
                     this.setAttributeValueOnObject(attValue, descriptor, parent, handler, type1, isPrimative, isQName, isByteArray);
                  }
               } else {
                  this.setAttributeValueOnObject(attValue, descriptor, parent, handler, type1, isPrimative, isQName, isByteArray);
               }

            }
         }
      }
   }

   private void setAttributeValueOnObject(String attValue, XMLFieldDescriptor descriptor, Object parent, FieldHandler handler, Class type, boolean isPrimitive, boolean isQName, boolean isByteArray) throws SAXException {
      Object value = attValue;
      if(isPrimitive) {
         value = this.toPrimitiveObject(type, attValue, descriptor);
      }

      if(isByteArray) {
         if(attValue == null) {
            value = new byte[0];
         } else if("hexBinary".equals(descriptor.getComponentType())) {
            value = HexDecoder.decode(attValue);
         } else {
            value = Base64Decoder.decode(attValue);
         }
      }

      if(isQName) {
         value = this.resolveNamespace(value);
      }

      handler.setValue(parent, value);
   }

   private UnmarshalHandler.Arguments processConstructorArgs(AttributeSet atts, XMLClassDescriptor classDesc) throws SAXException {
      if(classDesc == null) {
         return new UnmarshalHandler.Arguments();
      } else {
         int count = 0;
         XMLFieldDescriptor[] descriptors = classDesc.getAttributeDescriptors();
         XMLFieldDescriptor[] args = descriptors;
         int arr$ = descriptors.length;

         int len$;
         for(len$ = 0; len$ < arr$; ++len$) {
            XMLFieldDescriptor i$ = args[len$];
            if(i$ != null && i$.isConstructorArgument()) {
               ++count;
            }
         }

         UnmarshalHandler.Arguments var16 = new UnmarshalHandler.Arguments();
         if(count == 0) {
            return var16;
         } else {
            var16._values = new Object[count];
            var16._types = new Class[count];
            XMLFieldDescriptor[] var17 = descriptors;
            len$ = descriptors.length;

            for(int var18 = 0; var18 < len$; ++var18) {
               XMLFieldDescriptor descriptor = var17[var18];
               if(descriptor != null && descriptor.isConstructorArgument()) {
                  int argIndex = descriptor.getConstructorArgumentIndex();
                  String name;
                  if(argIndex >= count) {
                     name = "argument index out of bounds: " + argIndex;
                     throw new SAXException(name);
                  }

                  var16._types[argIndex] = descriptor.getFieldType();
                  name = descriptor.getXMLName();
                  String namespace = descriptor.getNameSpaceURI();
                  int index = atts.getIndex(name, namespace);
                  if(index >= 0) {
                     String value = atts.getValue(index);
                     Object var19;
                     if(isPrimitive(var16._types[argIndex])) {
                        var19 = this.toPrimitiveObject(var16._types[argIndex], (String)value, descriptor);
                     } else {
                        var19 = this.convertToEnumObject(descriptor, value);
                     }

                     String valueType = descriptor.getSchemaType();
                     if(valueType != null && valueType.equals("QName")) {
                        var19 = this.resolveNamespace(var19);
                     }

                     var16._values[argIndex] = var19;
                  } else if(isPrimitive(var16._types[argIndex])) {
                     var16._values[argIndex] = this.toPrimitiveObject(var16._types[argIndex], (String)null, descriptor);
                  } else {
                     var16._values[argIndex] = null;
                  }
               }
            }

            return var16;
         }
      }
   }

   private Object convertToEnumObject(XMLFieldDescriptor descriptor, Object value) {
      Class fieldType = descriptor.getFieldType();

      try {
         Method valueOfMethod = fieldType.getMethod("valueOf", new Class[]{String.class});
         if(valueOfMethod != null && Modifier.isStatic(valueOfMethod.getModifiers())) {
            Class e = valueOfMethod.getReturnType();
            if(e.isAssignableFrom(fieldType)) {
               Object enumObject = valueOfMethod.invoke((Object)null, new Object[]{value});
               value = enumObject;
            }
         }
      } catch (SecurityException var7) {
         ;
      } catch (NoSuchMethodException var8) {
         ;
      } catch (IllegalArgumentException var9) {
         ;
      } catch (IllegalAccessException var10) {
         ;
      } catch (InvocationTargetException var11) {
         ;
      }

      return value;
   }

   private boolean processIDREF(String idRef, XMLFieldDescriptor descriptor, Object parent) {
      Object value = this._idResolver.resolve(idRef);
      if(value == null) {
         this.addReference(idRef, parent, descriptor);
      } else {
         FieldHandler handler = descriptor.getHandler();
         if(handler != null) {
            handler.setValue(parent, value);
         }
      }

      return value != null;
   }

   private AttributeSet processAttributeList(AttributeList atts) throws SAXException {
      if(atts == null) {
         return new AttributeSetImpl(0);
      } else {
         int attCount = 0;
         boolean[] validAtts = new boolean[atts.getLength()];

         String namespace;
         for(int attSet = 0; attSet < validAtts.length; ++attSet) {
            String i = atts.getName(attSet);
            if(i.equals("xmlns")) {
               this._namespaces.addNamespace("", atts.getValue(attSet));
            } else if(i.startsWith("xmlns:")) {
               namespace = i.substring(XMLNS_PREFIX_LENGTH);
               this._namespaces.addNamespace(namespace, atts.getValue(attSet));
            } else {
               validAtts[attSet] = true;
               ++attCount;
            }
         }

         AttributeSetImpl var11 = null;
         if(attCount > 0) {
            var11 = new AttributeSetImpl(attCount);

            for(int var12 = 0; var12 < validAtts.length; ++var12) {
               if(validAtts[var12]) {
                  namespace = null;
                  String attName = atts.getName(var12);
                  int idx = attName.indexOf(58);
                  if(idx > 0) {
                     String prefix = attName.substring(0, idx);
                     if(!prefix.equals("xml")) {
                        attName = attName.substring(idx + 1);
                        namespace = this._namespaces.getNamespaceURI(prefix);
                        if(namespace == null) {
                           String error = "The namespace associated with the prefix \'" + prefix + "\' could not be resolved.";
                           throw new SAXException(error);
                        }
                     }
                  }

                  var11.setAttribute(attName, atts.getValue(var12), namespace);
               }
            }
         } else {
            var11 = new AttributeSetImpl(0);
         }

         return var11;
      }
   }

   private void processNamespaces(XMLClassDescriptor classDesc) {
      if(classDesc != null) {
         XMLFieldDescriptor nsDescriptor = classDesc.getFieldDescriptor((String)null, (String)null, NodeType.Namespace);
         if(nsDescriptor != null) {
            UnmarshalState state = (UnmarshalState)this._stateInfo.peek();
            FieldHandler handler = nsDescriptor.getHandler();
            if(handler != null) {
               Enumeration enumeration = this._namespaces.getLocalNamespacePrefixes();

               while(enumeration.hasMoreElements()) {
                  String nsPrefix = (String)enumeration.nextElement();
                  if(nsPrefix == null) {
                     nsPrefix = "";
                  }

                  String nsURI = this._namespaces.getNamespaceURI(nsPrefix);
                  if(nsURI == null) {
                     nsURI = "";
                  }

                  MapItem mapItem = new MapItem(nsPrefix, nsURI);
                  handler.setValue(state._object, mapItem);
               }
            }
         }

      }
   }

   private Object resolveNamespace(Object value) throws SAXException {
      if(value != null && value instanceof String) {
         String result = (String)value;
         int idx = result.indexOf(58);
         String prefix = null;
         if(idx > 0) {
            prefix = result.substring(0, idx);
            if("xml".equals(prefix)) {
               return value;
            }

            result = result.substring(idx + 1);
         }

         String namespace = this._namespaces.getNamespaceURI(prefix);
         if(namespace != null && namespace.length() > 0) {
            result = '{' + namespace + '}' + result;
            return result;
         } else if(namespace == null && prefix != null) {
            throw new SAXException("The namespace associated with the prefix: \'" + prefix + "\' is null.");
         } else {
            return result;
         }
      } else {
         return value;
      }
   }

   private XMLClassDescriptor getClassDescriptor(String className) throws SAXException {
      Class type = null;

      try {
         if(this._loader != null) {
            type = this._loader.loadClass(className);
         } else {
            type = Class.forName(className);
         }
      } catch (ClassNotFoundException var4) {
         return null;
      }

      return this.getClassDescriptor(type);
   }

   private XMLClassDescriptor getClassDescriptor(Class cls) throws SAXException {
      if(cls == null) {
         return null;
      } else if(cls == String.class) {
         return STRING_DESCRIPTOR;
      } else if(cls.isArray()) {
         return null;
      } else if(isPrimitive(cls)) {
         return null;
      } else {
         XMLClassDescriptor classDesc = null;

         try {
            InternalContext rx = this.getInternalContext();
            classDesc = (XMLClassDescriptor)rx.getXMLClassDescriptorResolver().resolve(cls);
         } catch (ResolverException var4) {
            ;
         }

         if(classDesc != null) {
            return new InternalXMLClassDescriptor(this, classDesc);
         } else {
            if(LOG.isDebugEnabled()) {
               LOG.debug("unable to find or create a ClassDescriptor for class: " + cls.getName());
            }

            return classDesc;
         }
      }
   }

   private XMLClassDescriptor getClassDescriptor(String className, ClassLoader loader) throws SAXException {
      XMLClassDescriptor classDesc = null;

      try {
         classDesc = this.getInternalContext().getXMLClassDescriptorResolver().resolve(className, loader);
      } catch (ResolverException var5) {
         throw new SAXException(var5);
      }

      if(classDesc != null) {
         return new InternalXMLClassDescriptor(this, classDesc);
      } else {
         if(LOG.isDebugEnabled()) {
            LOG.debug("unable to find or create a ClassDescriptor for class: " + className);
         }

         return classDesc;
      }
   }

   private XMLClassDescriptor resolveByXMLName(String name, String namespace, ClassLoader loader) throws SAXException {
      try {
         return this.getInternalContext().getXMLClassDescriptorResolver().resolveByXMLName(name, namespace, loader);
      } catch (ResolverException var5) {
         throw new SAXException(var5);
      }
   }

   private String getJavaPackage(Class type) {
      if(type == null) {
         return null;
      } else {
         String pkg = (String)this._javaPackages.get(type);
         if(pkg == null) {
            pkg = type.getName();
            int idx = pkg.lastIndexOf(46);
            if(idx > 0) {
               pkg = pkg.substring(0, idx);
            } else {
               pkg = "";
            }

            this._javaPackages.put(type, pkg);
         }

         return pkg;
      }
   }

   private String className(Class type) {
      return type.isArray()?this.className(type.getComponentType()) + "[]":type.getName();
   }

   private static boolean isWhitespace(StringBuffer sb) {
      int i = 0;

      while(i < sb.length()) {
         char ch = sb.charAt(i);
         switch(ch) {
         case '\t':
         case '\n':
         case '\r':
         case ' ':
            ++i;
            break;
         default:
            return false;
         }
      }

      return true;
   }

   private Class loadClass(String className, ClassLoader loader) throws ClassNotFoundException {
      return loader != null?loader.loadClass(className):(this._loader != null?this._loader.loadClass(className):Class.forName(className));
   }

   private void resolveReferences(String id, Object value) throws SAXException {
      if(id != null && value != null) {
         if(this._resolveTable != null) {
            for(ReferenceInfo refInfo = (ReferenceInfo)this._resolveTable.remove(id); refInfo != null; refInfo = refInfo.getNext()) {
               try {
                  FieldHandler ise = refInfo.getDescriptor().getHandler();
                  if(ise != null) {
                     ise.setValue(refInfo.getTarget(), value);
                  }

                  if(refInfo.getTarget() instanceof MapItem) {
                     this.resolveReferences(refInfo.getTarget().toString(), refInfo.getTarget());
                  }
               } catch (IllegalStateException var6) {
                  String err = "Attempting to resolve an IDREF: " + id + "resulted in the following error: " + var6.toString();
                  throw new SAXException(err, var6);
               }
            }

         }
      }
   }

   private Object toPrimitiveObject(Class type, String value, XMLFieldDescriptor fieldDesc) throws SAXException {
      try {
         return toPrimitiveObject(type, value);
      } catch (Exception var8) {
         String err = "The following error occured while trying to ";
         err = err + "unmarshal field " + fieldDesc.getFieldName();
         UnmarshalState state = (UnmarshalState)this._stateInfo.peek();
         if(state != null && state._object != null) {
            err = err + " of class " + state._object.getClass().getName();
         }

         err = err + ".";
         SAXException saxException = new SAXException(err);
         saxException.initCause(var8);
         throw saxException;
      }
   }

   public static Object toPrimitiveObject(Class type, String value) {
      Object primitive = value;
      if(value != null && type != Character.TYPE && type != Character.class) {
         value = value.trim();
      }

      boolean isNull = value == null || value.length() == 0;
      if(type != Integer.TYPE && type != Integer.class) {
         if(type != Boolean.TYPE && type != Boolean.class) {
            if(type != Double.TYPE && type != Double.class) {
               if(type != Long.TYPE && type != Long.class) {
                  if(type != Character.TYPE && type != Character.class) {
                     if(type != Short.TYPE && type != Short.class) {
                        if(type != Float.TYPE && type != Float.class) {
                           if(type != Byte.TYPE && type != Byte.class) {
                              if(type == BigDecimal.class) {
                                 if(isNull) {
                                    primitive = new BigDecimal(0);
                                 } else {
                                    primitive = new BigDecimal(value);
                                 }
                              } else if(type == BigInteger.class) {
                                 if(isNull) {
                                    primitive = BigInteger.valueOf(0L);
                                 } else {
                                    primitive = new BigInteger(value);
                                 }
                              } else if(type.getSuperclass().getName().equals("java.lang.Enum")) {
                                 if(isNull) {
                                    primitive = null;
                                 } else {
                                    Method e;
                                    try {
                                       e = type.getMethod("fromValue", new Class[]{String.class});
                                       primitive = e.invoke((Object)null, new Object[]{value});
                                       return primitive;
                                    } catch (NoSuchMethodException var9) {
                                       ;
                                    } catch (IllegalArgumentException var10) {
                                       throw new IllegalStateException(var10.toString());
                                    } catch (IllegalAccessException var11) {
                                       throw new IllegalStateException(var11.toString());
                                    } catch (InvocationTargetException var12) {
                                       if(var12.getTargetException() instanceof RuntimeException) {
                                          throw (RuntimeException)var12.getTargetException();
                                       }
                                    }

                                    try {
                                       e = type.getMethod("valueOf", new Class[]{String.class});
                                       primitive = e.invoke((Object)null, new Object[]{value});
                                    } catch (IllegalAccessException var6) {
                                       throw new IllegalStateException(var6.toString());
                                    } catch (InvocationTargetException var7) {
                                       if(var7.getTargetException() instanceof RuntimeException) {
                                          throw (RuntimeException)var7.getTargetException();
                                       }
                                    } catch (NoSuchMethodException var8) {
                                       String err = type.getName() + " does not contain the required method: public static " + type.getName() + " valueOf(String);";
                                       throw new IllegalArgumentException(err);
                                    }
                                 }
                              }
                           } else if(isNull) {
                              primitive = new Byte(0);
                           } else {
                              primitive = new Byte(value);
                           }
                        } else if(isNull) {
                           primitive = new Float(0.0F);
                        } else {
                           primitive = new Float(value);
                        }
                     } else if(isNull) {
                        primitive = new Short(0);
                     } else {
                        primitive = new Short(value);
                     }
                  } else if(!isNull) {
                     primitive = new Character(value.charAt(0));
                  } else {
                     primitive = new Character('\u0000');
                  }
               } else if(isNull) {
                  primitive = new Long(0L);
               } else {
                  primitive = new Long(value);
               }
            } else if(isNull) {
               primitive = new Double(0.0D);
            } else {
               primitive = new Double(value);
            }
         } else if(isNull) {
            primitive = Boolean.FALSE;
         } else if(!value.equals("1") && !value.toLowerCase().equals("true")) {
            if(!value.equals("0") && !value.toLowerCase().equals("false")) {
               throw new IllegalArgumentException(" A value of >" + value + "< cannot be converted to a boolean value.");
            }

            primitive = Boolean.FALSE;
         } else {
            primitive = Boolean.TRUE;
         }
      } else if(isNull) {
         primitive = new Integer(0);
      } else {
         primitive = new Integer(value);
      }

      return primitive;
   }

   public ObjectFactory getObjectFactory() {
      return this._objectFactory;
   }

   public void setObjectFactory(ObjectFactory objectFactory) {
      this._objectFactory = objectFactory;
   }

   public static class ArrayHandler {
      Class _componentType = null;
      ArrayList _items = null;

      ArrayHandler(Class componentType) {
         if(componentType == null) {
            String err = "The argument \'componentType\' may not be null.";
            throw new IllegalArgumentException(err);
         } else {
            this._componentType = componentType;
            this._items = new ArrayList();
         }
      }

      public void addObject(Object obj) {
         if(obj != null) {
            this._items.add(obj);
         }
      }

      public Object getObject() {
         int size = this._items.size();
         Object array = Array.newInstance(this._componentType, size);

         for(int i = 0; i < size; ++i) {
            Array.set(array, i, this._items.get(i));
         }

         return array;
      }

      public Class componentType() {
         return this._componentType;
      }
   }

   class Arguments {
      private Object[] _values = null;
      private Class[] _types = null;

      public int size() {
         return this._values == null?0:this._values.length;
      }
   }

   class ElementInfo {
      private String _qName = null;
      private Attributes _attributes = null;
      private AttributeList _attributeList = null;

      ElementInfo() {
      }

      ElementInfo(String qName, Attributes atts) {
         this._qName = qName;
         this._attributes = atts;
      }

      ElementInfo(String qName, AttributeList atts) {
         this._qName = qName;
         this._attributeList = atts;
      }

      void clear() {
         this._qName = null;
         this._attributes = null;
         this._attributeList = null;
      }
   }
}
Page generated: Oct 19, 2017 2:34:47 PM