private NeutralSchema parseElement(XmlSchemaElement element, XmlSchema schema) {

    QName elementTypeName = element.getSchemaTypeName();

    // Derive Element Schema
    XmlSchemaType elementSchemaType = element.getSchemaType();

    // Element annotations override type annotations.
    if (element.getAnnotation() != null) {
      elementSchemaType.setAnnotation(element.getAnnotation());
    }

    NeutralSchema elementSchema = null;
    if (elementSchemaType != null) {
      if (elementSchemaType.getName() != null) {
        elementSchema = this.parse(elementSchemaType, schema);
      } else {
        elementSchema = this.parse(elementSchemaType, element.getName(), schema);
      }
    } else if (elementTypeName != null) {
      elementSchema = getSchemaFactory().createSchema(elementTypeName);
    }

    if (elementSchema != null) {

      // List Schema
      if (element.getMaxOccurs() > 1) {
        ListSchema listSchema = (ListSchema) getSchemaFactory().createSchema("list");
        listSchema.getList().add(elementSchema);
        listSchema.updateAnnotations();
        elementSchema = listSchema;
      }
    }

    Long min = element.getMinOccurs();
    Long max = element.getMaxOccurs();
    QName type = element.getSchemaTypeName();

    if (min != null) {
      elementSchema.getProperties().put("minCardinality", min);
    }
    if (max != null) {
      elementSchema.getProperties().put("maxCardinality", max);
    }
    if (type != null) {
      elementSchema.getProperties().put("elementType", type.toString());
    }

    return elementSchema;
  }
 private static boolean schemasEqual(NeutralSchema ns1, NeutralSchema ns2) {
   if (ns1.getValidatorClass().equals(ns2.getValidatorClass())
       && ns1.getVersion().equals(ns2.getVersion())
       && ns1.getFields().size() == ns2.getFields().size()) {
     for (Entry<String, NeutralSchema> entry : ns1.getFields().entrySet()) {
       if (!ns2.getFields().containsKey(entry.getKey())) {
         return false;
       }
       if (!schemasEqual(entry.getValue(), ns2.getFields().get(entry.getKey()))) {
         return false;
       }
     }
     for (Entry<String, Object> entry : ns1.getProperties().entrySet()) {
       if (!ns2.getProperties().containsKey(entry.getKey())) {
         return false;
       }
       if (!entry
           .getValue()
           .getClass()
           .equals(ns2.getProperties().get(entry.getKey()).getClass())) {
         return false;
       }
       if (entry.getValue() instanceof List) {
         List<?> list1 = (List<?>) entry.getValue();
         List<?> list2 = (List<?>) ns2.getProperties().get(entry.getKey());
         if (!list1.containsAll(list2)) {
           return false;
         }
       } else {
         if (!entry.getValue().equals(ns2.getProperties().get(entry.getKey()))) {
           return false;
         }
       }
     }
     return true;
   } else {
     return false;
   }
 }
  private NeutralSchema recursiveParseSimpleType(
      XmlSchemaSimpleType schemaSimpleType, XmlSchema schema) {
    NeutralSchema simpleSchema = null;

    String simpleTypeName = schemaSimpleType.getName();

    if (NeutralSchemaType.isPrimitive(schemaSimpleType.getQName())) {
      simpleSchema = getSchemaFactory().createSchema(schemaSimpleType.getQName());

    } else if (NeutralSchemaType.exists(schemaSimpleType.getBaseSchemaTypeName())) {

      if (NeutralSchemaType.isPrimitive(schemaSimpleType.getBaseSchemaTypeName())) {
        simpleSchema = getSchemaFactory().createSchema(schemaSimpleType.getBaseSchemaTypeName());

      } else {
        XmlSchemaSimpleType simpleBaseType =
            getSimpleBaseType(schemaSimpleType.getBaseSchemaTypeName(), schema);
        if (simpleBaseType != null) {

          if (simpleTypeName == null) {
            simpleTypeName = simpleBaseType.getName();
          }
          simpleSchema = getSchemaFactory().createSchema(simpleTypeName);
        }
      }

    } else if (schemaSimpleType.getContent() != null
        && schemaSimpleType.getContent() instanceof XmlSchemaSimpleTypeList) {

      ListSchema listSchema = (ListSchema) getSchemaFactory().createSchema("list");

      XmlSchemaSimpleTypeList content = (XmlSchemaSimpleTypeList) schemaSimpleType.getContent();
      NeutralSchema listContentSchema = null;

      if (content.getItemType() != null) {
        listContentSchema = parseSimpleType(content.getItemType(), schema, null);

      } else {
        QName itemTypeName = content.getItemTypeName();
        listContentSchema = getSchemaFactory().createSchema(itemTypeName.getLocalPart());
      }
      listSchema.getList().add(listContentSchema);
      listSchema.updateAnnotations();
      return listSchema;

    } else if (getSimpleContentTypeName(schemaSimpleType) != null) {

      if (NeutralSchemaType.isPrimitive(getSimpleContentTypeName(schemaSimpleType))) {
        simpleSchema = getSchemaFactory().createSchema(getSimpleContentTypeName(schemaSimpleType));

      } else {

        XmlSchemaSimpleType simpleBaseType =
            getSimpleBaseType(getSimpleContentTypeName(schemaSimpleType), schema);
        simpleSchema = recursiveParseSimpleType(simpleBaseType, schema);
      }
    }

    if (simpleSchema != null && schemaSimpleType.getContent() != null) {

      if (schemaSimpleType.getContent() instanceof XmlSchemaSimpleTypeRestriction) {

        XmlSchemaSimpleTypeRestriction simpleRestrictedContent =
            (XmlSchemaSimpleTypeRestriction) schemaSimpleType.getContent();
        XmlSchemaObjectCollection facets = simpleRestrictedContent.getFacets();
        List<String> tokens = new ArrayList<String>();
        for (int i = 0; i < facets.getCount(); i++) {
          XmlSchemaObject facetObject = facets.getItem(i);

          if (facetObject instanceof XmlSchemaEnumerationFacet) {
            XmlSchemaEnumerationFacet enumerationFacet = (XmlSchemaEnumerationFacet) facetObject;
            tokens.add(enumerationFacet.getValue().toString());
          } else if (facetObject instanceof XmlSchemaFacet) {
            XmlSchemaFacet facet = (XmlSchemaFacet) facetObject;
            String facetPropertyName = NeutralSchemaType.lookupPropertyName(facet);
            simpleSchema.getProperties().put(facetPropertyName, facet.getValue().toString());
          }
        }

        if (tokens.size() > 0) {
          // Token Schema
          Collections.sort(tokens); // sort so we can binary search
          simpleSchema.getProperties().put(TokenSchema.TOKENS, tokens);
        }
      }
    }

    parseAnnotations(simpleSchema, schemaSimpleType);

    if ((simpleSchema != null) && (simpleTypeName != null)) {
      simpleSchema.setType(simpleTypeName);
    }

    return simpleSchema;
  }