org.apache.ws.commons.schema.XmlSchemaSimpleTypeRestriction Java Examples

private static final QName getSimpleTypeName(final XmlSchemaSimpleType simpleType) {
    final QName typeName = simpleType.getQName();
    if (null == typeName) {
        // The type is anonymous.
        final XmlSchemaSimpleTypeContent content = simpleType.getContent();
        if (content instanceof XmlSchemaSimpleTypeRestriction) {
            final XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) content;
            return restriction.getBaseTypeName();
        } else if (content instanceof XmlSchemaSimpleTypeList) {
            final XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList) content;
            return list.getItemTypeName();
        } else {
            throw new AssertionError(content);
        }
    } else {
        return typeName;
    }
}
 

/**
 * Create a simple type for an alphanumeric type.
 * <p/>
 * COBOL alphanumeric fields are fixed length so we create a facet to
 * enforce that constraint. A pattern derived from the picture clause can
 * also be used as a facet. If the item has children conditions, we add
 * enumeration facets
 * 
 * @param xsdDataItem COBOL data item decorated with XSD attributes
 * @param xsdTypeName the XML schema built-in type name to use as a
 *            restriction
 * @return an XML schema simple type
 */
protected XmlSchemaSimpleType createAlphaXmlSchemaSimpleType(
        final XsdDataItem xsdDataItem, final String xsdTypeName) {

    XmlSchemaSimpleTypeRestriction restriction = createRestriction(xsdTypeName);
    if (xsdDataItem.getLength() > -1) {
        restriction.getFacets().add(
                createMaxLengthFacet(xsdDataItem.getLength()));
    }
    if (xsdDataItem.getPattern() != null) {
        restriction.getFacets().add(
                createPatternFacet(xsdDataItem.getPattern()));
    }
    addEnumerationFacets(xsdDataItem, restriction);
    return createXmlSchemaSimpleType(restriction);
}
 

/**
 * Retrieve the string values for an enumeration.
 * @param type
 */
public static List<String> enumeratorValues(XmlSchemaSimpleType type) {
    XmlSchemaSimpleTypeContent content = type.getContent();
    XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) content;
    List<XmlSchemaFacet> facets = restriction.getFacets();
    List<String> values = new ArrayList<>();
    for (XmlSchemaFacet facet : facets) {
        XmlSchemaEnumerationFacet enumFacet = (XmlSchemaEnumerationFacet) facet;
        values.add(enumFacet.getValue().toString());
    }
    return values;
}
 

/**
 * Return true if a simple type is a straightforward XML Schema representation of an enumeration.
 * If we discover schemas that are 'enum-like' with more complex structures, we might
 * make this deal with them.
 * @param type Simple type, possible an enumeration.
 * @return true for an enumeration.
 */
public static boolean isEumeration(XmlSchemaSimpleType type) {
    XmlSchemaSimpleTypeContent content = type.getContent();
    if (!(content instanceof XmlSchemaSimpleTypeRestriction)) {
        return false;
    }
    XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) content;
    List<XmlSchemaFacet> facets = restriction.getFacets();
    for (XmlSchemaFacet facet : facets) {
        if (!(facet instanceof XmlSchemaEnumerationFacet)) {
            return false;
        }
    }
    return true;
}
 

@Override
public void writeSchema(XmlSchema root) {

    XmlSchemaSimpleType simple = new XmlSchemaSimpleType(root, true);
    simple.setName(getSchemaType().getLocalPart());
    XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
    restriction.setBaseTypeName(Constants.XSD_STRING);
    simple.setContent(restriction);

    Object[] constants = getTypeClass().getEnumConstants();

    List<XmlSchemaFacet> facets = restriction.getFacets();
    for (Object constant : constants) {
        XmlSchemaEnumerationFacet f = new XmlSchemaEnumerationFacet();
        f.setValue(getValue(constant));
        facets.add(f);
    }
}
 

private Enum createCorbaEnum(XmlSchemaSimpleTypeRestriction restrictionType, QName name,
                             QName schematypeName) {
    Enum corbaEnum = new Enum();
    corbaEnum.setType(schematypeName);
    corbaEnum.setName(name.getLocalPart());
    corbaEnum.setQName(name);

    corbaEnum.setRepositoryID(REPO_STRING + name.getLocalPart().replace('.', '/') + IDL_VERSION);

    for (XmlSchemaFacet f : restrictionType.getFacets()) {
        XmlSchemaEnumerationFacet val = (XmlSchemaEnumerationFacet)f;
        Enumerator enumerator = new Enumerator();
        enumerator.setValue(val.getValue().toString());
        corbaEnum.getEnumerator().add(enumerator);
    }
    return corbaEnum;
}
 

/**
 * Create an XML schema restriction.
 * 
 * @param xsdTypeName the XML schema built-in type name to use as a
 *            restriction
 * @return an XML schema restriction
 */
protected XmlSchemaSimpleTypeRestriction createRestriction(
        final String xsdTypeName) {
    XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
    restriction.setBaseTypeName(new QName(
            XMLConstants.W3C_XML_SCHEMA_NS_URI, xsdTypeName));
    return restriction;
}
 

private boolean isEnumeration(XmlSchemaSimpleTypeRestriction restriction) {

        if ((restriction == null) || (restriction.getFacets().isEmpty())
            || (restriction.getBaseTypeName() == null)) {
            return false;
        }


        for (XmlSchemaFacet facet : restriction.getFacets()) {
            if (facet instanceof XmlSchemaEnumerationFacet) {
                return true;
            }
        }
        return false;
    }
 

/**
 * Create an XML schema simple type from a restriction.
 * 
 * @param restriction the XML schema restriction
 * @return the XML schema simple type
 */
protected XmlSchemaSimpleType createXmlSchemaSimpleType(
        final XmlSchemaSimpleTypeRestriction restriction) {
    XmlSchemaSimpleType xmlSchemaSimpleType = new XmlSchemaSimpleType(
            getXsd(), false);
    xmlSchemaSimpleType.setContent(restriction);
    return xmlSchemaSimpleType;
}
 

@Override
public void writeSchema(XmlSchema root) {
    // this mapping gets used with xs:string, and we might get called.
    if (root.getTargetNamespace().equals(XMLConstants.W3C_XML_SCHEMA_NS_URI)) {
        return;
    }
    XmlSchemaSimpleType type = new XmlSchemaSimpleType(root, true);
    type.setName(getSchemaType().getLocalPart());
    XmlSchemaSimpleContentExtension ext = new XmlSchemaSimpleContentExtension();
    ext.setBaseTypeName(Constants.XSD_STRING);
    XmlSchemaSimpleTypeRestriction content = new XmlSchemaSimpleTypeRestriction();
    content.setBaseTypeName(Constants.XSD_STRING);
    type.setContent(content);
}
 

public void writeSchema(XmlSchema root) {
    XmlSchemaSimpleType xst = new XmlSchemaSimpleType(root, true);
    xst.setName("class");

    XmlSchemaSimpleTypeRestriction content = new XmlSchemaSimpleTypeRestriction();
    content.setBaseTypeName(Constants.XSD_STRING);
    xst.setContent(content);
}
 

private void createImportedAttributeType(XmlSchema attributeTypeSchema) {
    XmlSchemaSimpleType attributeImportedType = new XmlSchemaSimpleType(attributeTypeSchema, true);
    attributeImportedType.setName("importedAttributeType");
    XmlSchemaSimpleTypeRestriction simpleContent = new XmlSchemaSimpleTypeRestriction();
    attributeImportedType.setContent(simpleContent);
    simpleContent.setBaseTypeName(new QName(XMLConstants.W3C_XML_SCHEMA_NS_URI, "string"));
}
 

private QName getSimpleContentTypeName(XmlSchemaSimpleType schemaSimpleType) {
    QName simpleContentTypeName = null;
    if (schemaSimpleType.getContent() != null
            && schemaSimpleType.getContent() instanceof XmlSchemaSimpleTypeRestriction) {
        XmlSchemaSimpleTypeRestriction simpleContent = (XmlSchemaSimpleTypeRestriction) schemaSimpleType
                .getContent();
        simpleContentTypeName = simpleContent.getBaseTypeName();
    } else {
        throw new RuntimeException("Unsupported simple content model: "
                + schemaSimpleType.getContent().getClass().getCanonicalName());
    }
    return simpleContentTypeName;
}
 

/**
 * Retrieve the properties of a primitive type.
 * 
 * @param xsdSimpleType the XML schema primitive type
 * @param cobolAnnotations the associated COBOL annotations
 * @return a set of properties
 */
private Map < String, Object > getProps(XmlSchemaSimpleType xsdSimpleType,
        final CobolAnnotations cobolAnnotations) {
    XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) xsdSimpleType
            .getContent();
    if (restriction != null && restriction.getBaseTypeName() != null) {
        QName xsdTypeName = restriction.getBaseTypeName();
        List < XmlSchemaFacet > facets = restriction.getFacets();
        if (xsdTypeName.equals(Constants.XSD_STRING)) {
            return getCobolAlphanumType(facets);
        } else if (xsdTypeName.equals(Constants.XSD_HEXBIN)) {
            return getCobolOctetStreamType(facets);
        } else if (xsdTypeName.equals(Constants.XSD_INT)) {
            return getCobolDecimalType(cobolAnnotations, Integer.class);
        } else if (xsdTypeName.equals(Constants.XSD_LONG)) {
            return getCobolDecimalType(cobolAnnotations, Long.class);
        } else if (xsdTypeName.equals(Constants.XSD_SHORT)) {
            return getCobolDecimalType(cobolAnnotations, Short.class);
        } else if (xsdTypeName.equals(Constants.XSD_DECIMAL)) {
            return getCobolDecimalType(cobolAnnotations, BigDecimal.class);
        } else if (xsdTypeName.equals(Constants.XSD_FLOAT)) {
            return getCobolDecimalType(cobolAnnotations, Float.class);
        } else if (xsdTypeName.equals(Constants.XSD_DOUBLE)) {
            return getCobolDecimalType(cobolAnnotations, Double.class);
        } else if (xsdTypeName.equals(Constants.XSD_UNSIGNEDINT)) {
            return getCobolDecimalType(cobolAnnotations, Long.class);
        } else if (xsdTypeName.equals(Constants.XSD_UNSIGNEDSHORT)) {
            return getCobolDecimalType(cobolAnnotations, Integer.class);
        } else if (xsdTypeName.equals(Constants.XSD_UNSIGNEDLONG)) {
            return getCobolDecimalType(cobolAnnotations, BigInteger.class);
        } else if (xsdTypeName.equals(Constants.XSD_INTEGER)) {
            return getCobolDecimalType(cobolAnnotations, BigInteger.class);
        } else {
            throw new Xsd2ConverterException("Unsupported xsd type "
                    + xsdTypeName);
        }

    } else {
        throw new Xsd2ConverterException("Simple type without restriction "
                + xsdSimpleType.getQName());
    }

}
 

public void visit(AST enumNode) {
    // <enum_type> ::= "enum" <identifier> "{" <enumerator> {"," <enumerator>}* "}"
    // <enumerator> ::= <identifier>


    AST enumNameNode = enumNode.getFirstChild();
    Scope enumNameScope = new Scope(getScope(), enumNameNode);

    // xmlschema:enum
    XmlSchemaSimpleType enumSchemaSimpleType = new XmlSchemaSimpleType(schema, true);
    enumSchemaSimpleType.setName(mapper.mapToQName(enumNameScope));

    XmlSchemaSimpleTypeRestriction enumSchemaSimpleTypeRestriction = new XmlSchemaSimpleTypeRestriction();
    enumSchemaSimpleTypeRestriction.setBaseTypeName(Constants.XSD_STRING);

    //XmlSchemaSimpleTypeContent xmlSchemaSimpleTypeContent = enumSchemaSimpleTypeRestriction;
    enumSchemaSimpleType.setContent(enumSchemaSimpleTypeRestriction);


    // corba:enum
    Enum corbaEnum = new Enum();
    corbaEnum.setQName(new QName(typeMap.getTargetNamespace(), enumNameScope.toString()));
    corbaEnum.setRepositoryID(enumNameScope.toIDLRepositoryID());
    corbaEnum.setType(enumSchemaSimpleType.getQName());


    AST node = enumNameNode.getNextSibling();
    while (node != null) {
        // xmlschema:enumeration
        XmlSchemaEnumerationFacet enumeration = new XmlSchemaEnumerationFacet();
        enumeration.setValue(node.toString());
        enumSchemaSimpleTypeRestriction.getFacets().add(enumeration);

        // corba:enumerator
        Enumerator enumerator = new Enumerator();
        enumerator.setValue(node.toString());
        corbaEnum.getEnumerator().add(enumerator);

        node = node.getNextSibling();
    }

    // add corbaType
    typeMap.getStructOrExceptionOrUnion().add(corbaEnum);

    // REVISIT: are there assignments needed?
    setSchemaType(enumSchemaSimpleType);
    setCorbaType(corbaEnum);
}
 

private void visitAnonBoundedString() {
    // xmlschema:bounded anon string
    XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(schema, true);
    simpleType.setName(stringScopedName.toString());
    XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
    restriction.setBaseTypeName(Constants.XSD_STRING);
    XmlSchemaMaxLengthFacet maxLengthFacet = new XmlSchemaMaxLengthFacet();
    maxLengthFacet.setValue(boundNode.toString());
    restriction.getFacets().add(maxLengthFacet);
    simpleType.setContent(restriction);

    setSchemaType(simpleType);

    CorbaType anon = null;
    if (stringNode.getType() == IDLTokenTypes.LITERAL_string) {
        // corba:anonstring
        Anonstring anonstring = new Anonstring();
        anonstring.setQName(new QName(typeMap.getTargetNamespace(), stringScopedName.toString()));
        anonstring.setBound(Long.parseLong(boundNode.toString()));
        anonstring.setType(simpleType.getQName());

        anon = anonstring;

    } else if (stringNode.getType() == IDLTokenTypes.LITERAL_wstring) {
        // corba:anonwstring
        Anonwstring anonwstring = new Anonwstring();
        anonwstring.setQName(new QName(typeMap.getTargetNamespace(), stringScopedName.toString()));
        anonwstring.setBound(Long.parseLong(boundNode.toString()));
        anonwstring.setType(simpleType.getQName());

        anon = anonwstring;

    } else {
        // should never get here
        throw new RuntimeException("StringVisitor attempted to visit an invalid node");
    }


    // add corba:anonstring
    typeMap.getStructOrExceptionOrUnion().add(anon);
    setCorbaType(anon);
}
 

private void visitBoundedString() {
    // xmlschema:bounded string
    XmlSchemaSimpleType simpleType = new XmlSchemaSimpleType(schema, true);
    simpleType.setName(stringScopedName.toString());
    XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction();
    restriction.setBaseTypeName(Constants.XSD_STRING);
    XmlSchemaMaxLengthFacet maxLengthFacet = new XmlSchemaMaxLengthFacet();
    maxLengthFacet.setValue(boundNode.toString());
    restriction.getFacets().add(maxLengthFacet);
    simpleType.setContent(restriction);

    setSchemaType(simpleType);

    Scope anonstringScopedName = new Scope(getScope(), "_Anon1_" + stringScopedName.tail());
    String anonstringName = anonstringScopedName.toString();
    CorbaType anon = null;
    if (stringNode.getType() == IDLTokenTypes.LITERAL_string) {
        // corba:anonstring
        Anonstring anonstring = new Anonstring();
        anonstring.setQName(new QName(typeMap.getTargetNamespace(), anonstringName));
        anonstring.setBound(Long.parseLong(boundNode.toString()));
        anonstring.setType(simpleType.getQName());

        anon = anonstring;

    } else if (stringNode.getType() == IDLTokenTypes.LITERAL_wstring) {
        // corba:anonwstring
        Anonwstring anonwstring = new Anonwstring();
        anonwstring.setQName(new QName(typeMap.getTargetNamespace(), anonstringName));
        anonwstring.setBound(Long.valueOf(boundNode.toString()));
        anonwstring.setType(simpleType.getQName());

        anon = anonwstring;

    } else {
        // should never get here
        throw new RuntimeException("StringVisitor attempted to visit an invalid node");
    }

    // add corba:anonstring
    typeMap.getStructOrExceptionOrUnion().add(anon);

    // corba:alias
    Alias alias = new Alias();
    alias.setQName(new QName(typeMap.getTargetNamespace(), stringScopedName.toString()));
    alias.setBasetype(anon.getQName());
    alias.setType(simpleType.getQName());
    alias.setRepositoryID(stringScopedName.toIDLRepositoryID());

    // add corba:alias
    setCorbaType(alias);
}
 

private CorbaType processSimpleRestrictionType(XmlSchemaSimpleType stype,
                                                   QName name, QName schematypeName,
                                                   boolean anonymous)
    throws Exception {
    CorbaType corbaTypeImpl = null;

    // checks if enumeration
    XmlSchemaSimpleTypeRestriction restrictionType = (XmlSchemaSimpleTypeRestriction)stype
        .getContent();

    QName baseName = checkPrefix(restrictionType.getBaseTypeName());

    String maxLength = null;
    String length = null;

    for (XmlSchemaFacet val : restrictionType.getFacets()) {
        if (val instanceof XmlSchemaMaxLengthFacet) {
            maxLength = val.getValue().toString();
        }
        if (val instanceof XmlSchemaLengthFacet) {
            length = val.getValue().toString();
        }
    }

    if (isEnumeration(restrictionType)) {
        corbaTypeImpl = createCorbaEnum(restrictionType, name, schematypeName);
    } else {
        if (restrictionType.getBaseType() != null) {
            corbaTypeImpl = convertSchemaToCorbaType(restrictionType.getBaseType(), schematypeName,
                                                     stype, null, false);
        } else {
            corbaTypeImpl = processPrimitiveType(baseName);
            if (corbaTypeImpl == null) {
                XmlSchemaType schematype = findSchemaType(baseName);
                corbaTypeImpl = convertSchemaToCorbaType(schematype, schematypeName,
                                                         schematype, null, false);
            }
        }

        if (corbaTypeImpl != null) {
            if (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_STRING)
                || (baseName.equals(W3CConstants.NT_SCHEMA_STRING))) {
                corbaTypeImpl =
                    WSDLTypes.processStringType(corbaTypeImpl, name, maxLength, length);
            } else if (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_DECIMAL)
                || (baseName.equals(W3CConstants.NT_SCHEMA_DECIMAL))) {
                corbaTypeImpl = WSDLTypes.processDecimalType(restrictionType, name,
                                                         corbaTypeImpl, anonymous);
            } else if ((corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_BASE64))
                || (baseName.equals(W3CConstants.NT_SCHEMA_BASE64))
                || (corbaTypeImpl.getType().equals(W3CConstants.NT_SCHEMA_HBIN))) {
                corbaTypeImpl = WSDLTypes.processBase64Type(corbaTypeImpl,
                                                            name, maxLength, length);
            }
        }
    }

    return corbaTypeImpl;
}
 

/**
 * If simple type has conditions attached to it, emit enumeration facets.
 * 
 * @param xsdDataItem COBOL data item decorated with XSD attributes
 * @param restriction the current set of constraints
 */
protected void addEnumerationFacets(final XsdDataItem xsdDataItem,
        final XmlSchemaSimpleTypeRestriction restriction) {
    if (getConfig().mapConditionsToFacets()) {
        boolean hasValueThru = false;
        for (XsdDataItem child : xsdDataItem.getChildren()) {
            if (child.getDataEntryType() == DataEntryType.CONDITION) {
                for (String conditionValue : child.getConditionLiterals()) {
                    restriction.getFacets().add(
                            createEnumerationFacet(ValueUtil
                                    .resolveFigurative(conditionValue,
                                            xsdDataItem
                                                    .getMaxStorageLength(),
                                            getConfig().quoteIsQuote())));
                }
                for (Range conditionRange : child.getConditionRanges()) {
                    if (hasValueThru) {
                        _log.warn(xsdDataItem.getCobolName()
                                + " has several VALUE THRU statements."
                                + " Cannot translate to XSD."
                                + " Only the first one will be converted."
                                + " Ignoring: " + conditionRange.toString());
                        break;
                    }
                    restriction.getFacets().add(
                            createMinInclusiveFacet(ValueUtil
                                    .resolveFigurative(conditionRange
                                            .getFrom(), xsdDataItem
                                            .getMaxStorageLength(),
                                            getConfig().quoteIsQuote())));
                    restriction.getFacets().add(
                            createMaxInclusiveFacet(ValueUtil
                                    .resolveFigurative(conditionRange
                                            .getTo(), xsdDataItem
                                            .getMaxStorageLength(),
                                            getConfig().quoteIsQuote())));
                    hasValueThru = true;
                }

            }
        }
    }
}
 

/**
 * Create a simple type for an numeric type.
 * <p/>
 * Numeric elements might have totaDigits, fractionDigits, minInclusive or
 * maxInclusive facets.
 * 
 * @param xsdDataItem COBOL data item decorated with XSD attributes
 * @param xsdTypeName the XML schema built-in type name to use as a
 *            restriction
 * @return an XML schema simple type
 */
protected XmlSchemaSimpleType createNumericXmlSchemaSimpleType(
        final XsdDataItem xsdDataItem, final String xsdTypeName) {

    XmlSchemaSimpleTypeRestriction restriction = createRestriction(xsdTypeName);

    /*
     * COBOL native binary are special because even though they have a
     * totalDigits attribute, it is not used enforce a restriction.
     */
    if (xsdDataItem.getCobolType() != CobolTypes.NATIVE_BINARY_ITEM
            && xsdDataItem.getTotalDigits() > -1) {

        /*
         * Due to a bug in JAXB (see JAXB issue 715), unsignedLong may end
         * up being mapped to BigInteger instead of Long when totalDigits is
         * used instead of maxInclusive. So for now, we keep maxInclusive.
         */
        if (xsdDataItem.getXsdType() == XsdType.ULONG) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < xsdDataItem.getTotalDigits(); i++) {
                sb.append("9");
            }
            restriction.getFacets().add(
                    createMaxInclusiveFacet(sb.toString()));
        } else {
            restriction.getFacets().add(
                    createTotalDigitsFacet(xsdDataItem.getTotalDigits()));
        }
    }

    /* fractionDigits is a fixed facet for most numerics so be careful */
    if (xsdDataItem.getFractionDigits() > 0) {
        restriction.getFacets().add(
                createFractionDigitsFacet(xsdDataItem.getFractionDigits()));
    }

    /*
     * For xsd:decimal and xsd:integer, we further constrain if the numeric
     * needs to be positive (unsigned).
     */
    if ((xsdDataItem.getXsdType() == XsdType.INTEGER || xsdDataItem
            .getXsdType() == XsdType.DECIMAL) && !xsdDataItem.isSigned()) {
        restriction.getFacets().add(createMinInclusiveFacet("0"));
    }
    addEnumerationFacets(xsdDataItem, restriction);
    return createXmlSchemaSimpleType(restriction);
}
 

public static XmlTypeInfo createXmlTypeInfo(QName qname, XmlSchemaType type) {
    if (qname == null) throw new NullPointerException("qname is null");
    if (type == null) throw new NullPointerException("type is null");

    XmlTypeInfo typeInfo = new XmlTypeInfo();
    typeInfo.qname = qname;
    typeInfo.anonymous = qname.getLocalPart().indexOf('>') >= 0;

    if (type instanceof XmlSchemaSimpleType) {
        XmlSchemaSimpleType simpleType = (XmlSchemaSimpleType) type;
        XmlSchemaSimpleTypeContent content = simpleType.getContent();
        if (content instanceof XmlSchemaSimpleTypeList) {
            XmlSchemaSimpleTypeList list = (XmlSchemaSimpleTypeList) content;
            typeInfo.simpleBaseType = list.getItemType().getQName();

            // this is a list
            typeInfo.listType = true;
        } else if (content instanceof XmlSchemaSimpleTypeRestriction) {
            XmlSchemaSimpleTypeRestriction restriction = (XmlSchemaSimpleTypeRestriction) content;
            typeInfo.simpleBaseType = restriction.getBaseTypeName();

            // is this an enumeration?
            for (Iterator iterator = restriction.getFacets().getIterator(); iterator.hasNext(); ) {
                if (iterator.next() instanceof XmlSchemaEnumerationFacet) {
                    typeInfo.enumType = true;
                    break;
                }

            }
        }
    } else if (type instanceof XmlSchemaComplexType) {
        XmlSchemaComplexType complexType = (XmlSchemaComplexType) type;

        // SOAP array component type
        typeInfo.arrayComponentType = extractSoapArrayComponentType(complexType);

        // process attributes (skip soap arrays which have non-mappable attributes)
        if (!isSoapArray(complexType)) {
            XmlSchemaObjectCollection attributes = complexType.getAttributes();
            for (Iterator iterator = attributes.getIterator(); iterator.hasNext(); ) {
                Object item = iterator.next();
                if (item instanceof XmlSchemaAttribute) {
                    XmlSchemaAttribute attribute = (XmlSchemaAttribute) item;
                    Object old = typeInfo.attributes.put(attribute.getQName().getLocalPart(), attribute.getSchemaTypeName());
                    if (old != null) {
                        throw new IllegalArgumentException("Complain to your expert group member, spec does not support attributes with the same local name and differing namespaces: original: " + old + ", duplicate local name: " + attribute);
                    }
                }
            }
        }
    } else {
        LOG.warn("Unknown schema type class " + typeInfo.getClass().getName());
    }

    return typeInfo;
}
 

private void handleSimpleTypeRestriction(XmlSchemaSimpleTypeRestriction target,
                                         XmlSchemaSimpleTypeRestriction source) throws ParserException {
    handleTypeNameAndType(source.getBaseTypeName(), source.getBaseType(),
            target::setBaseTypeName, target::setBaseType);
}