import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
public static boolean checkComplexType(XSTypeDefinition td) {
    if (td.getTypeCategory() != XSTypeDefinition.COMPLEX_TYPE) {
        return false;
    }
    XSComplexTypeDefinition ctd = (XSComplexTypeDefinition) td;
    if (ctd.getContentType() == XSComplexTypeDefinition.CONTENTTYPE_ELEMENT) {
        return true;
    }
    if ((td instanceof XSComplexTypeDecl) && ((XSComplexTypeDecl) td).getAbstract()) {
        return true;
    }
    if (TEXT_ELEMENTS_ARE_COMPLEX) {
        return true;
    }
    if (ctd.getAttributeUses() != null) {
        for (int i = 0; i < ctd.getAttributeUses().getLength(); i++) {
            XSSimpleTypeDefinition xsstd = ((XSAttributeUse) ctd.getAttributeUses().item(i)).getAttrDeclaration()
                                                                                            .getTypeDefinition();
            if ("ID".equals(xsstd.getName())) {
                continue;
            }
            return true;
        }
    }
    return false;
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private static boolean checkBooleanType(XSTypeDefinition td) {
    if (td.getTypeCategory() != XSTypeDefinition.SIMPLE_TYPE) {
        return false;
    }
    final XSSimpleTypeDefinition st = ((XSSimpleTypeDefinition) td);
    final XSObjectList facets = st.getFacets();
    for (int i = 0; i < facets.getLength(); i++) {
        final XSFacet facet = (XSFacet) facets.item(i);
        if (facet.getFacetKind() == XSSimpleTypeDefinition.FACET_LENGTH) {
            if ("0".equals(facet.getLexicalFacetValue())) {
                return true;
            }
        }
    }
    return false;
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private static String getSimpleTypesString(XSTypeDefinition et) {
    StringBuffer typesHierarchy = new StringBuffer();
    while (et != null && !"anySimpleType".equals(et.getName()) && !"anyType".equals(et.getName()) && et.getNamespace() != null) {
        typesHierarchy.append(et.getNamespace().substring(et.getNamespace().lastIndexOf("/") + 1))
                      .append(":")
                      .append(et.getName())
                      .append(";");
        if (et instanceof XSSimpleType) {
            XSSimpleType simpleType = (XSSimpleType) et;
            if (simpleType.getVariety() == XSSimpleTypeDefinition.VARIETY_LIST
                || simpleType.getVariety() == XSSimpleTypeDefinition.VARIETY_UNION) {
                XSObjectList list = simpleType.getMemberTypes();
                if (list.getLength() > 0) {
                    typesHierarchy.append("{");
                    for (int i = 0; i < list.getLength(); i++) {
                        typesHierarchy.append(getSimpleTypesString((XSTypeDefinition) list.item(i)));
                    }
                    typesHierarchy.append("}");
                }
            }
        }
        et = et.getBaseType();
    }
    return typesHierarchy.toString();
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
/**
 * Copy PSVI properties from another psvi item.
 * 
 * @param elem  the source of element PSVI items
 */
public void setPSVI(ElementPSVI elem) {
    this.fDeclaration = elem.getElementDeclaration();
    this.fNotation = elem.getNotation();
    this.fValidationContext = elem.getValidationContext();
    this.fTypeDecl = elem.getTypeDefinition();
    this.fSchemaInformation = elem.getSchemaInformation();
    this.fValidity = elem.getValidity();
    this.fValidationAttempted = elem.getValidationAttempted();
    this.fErrorCodes = elem.getErrorCodes();
    this.fErrorMessages = elem.getErrorMessages();
    if (fTypeDecl instanceof XSSimpleTypeDefinition ||
            fTypeDecl instanceof XSComplexTypeDefinition &&
            ((XSComplexTypeDefinition)fTypeDecl).getContentType() == XSComplexTypeDefinition.CONTENTTYPE_SIMPLE) {
        this.fValue.copyFrom(elem.getSchemaValue());
    }
    else {
        this.fValue.reset();
    }
    this.fSpecified = elem.getIsSchemaSpecified();
    this.fNil = elem.getNil();
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
/**
 * Checks if a type is derived from another by list. See:
 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom
 * 
 * @param ancestorNS
 *            The namspace of the ancestor type declaration
 * @param ancestorName
 *            The name of the ancestor type declaration
 * @param type
 *            The reference type definition
 * 
 * @return boolean True if the type is derived by list for the reference type
 */    
private boolean isDerivedByList (String ancestorNS, String ancestorName, XSTypeDefinition type) {
    // If the variety is union
    if (type !=null && ((XSSimpleTypeDefinition)type).getVariety() == VARIETY_LIST) {

        // get the {item type}
        XSTypeDefinition itemType = ((XSSimpleTypeDefinition)type).getItemType();

        // T2 is the {item type definition}
        if (itemType != null) {

            // T2 is derived from the other type definition by DERIVATION_RESTRICTION
            if (isDerivedByRestriction(ancestorNS, ancestorName, itemType)) {
                return true;
            } 
        }
    }
    return false;
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
/**
 * Checks if a type is derived from another by union.  See:
 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#TypeInfo-isDerivedFrom
 * 
 * @param ancestorNS
 *            The namspace of the ancestor type declaration
 * @param ancestorName
 *            The name of the ancestor type declaration
 * @param type
 *            The reference type definition
 * 
 * @return boolean True if the type is derived by union for the reference type
 */    
private boolean isDerivedByUnion (String ancestorNS, String ancestorName, XSTypeDefinition type) {

    // If the variety is union
    if (type !=null && ((XSSimpleTypeDefinition)type).getVariety() == VARIETY_UNION) {

        // get member types
        XSObjectList memberTypes = ((XSSimpleTypeDefinition)type).getMemberTypes();

        for (int i = 0; i < memberTypes.getLength(); i++) {
            // One of the {member type definitions} is T2.
            if (memberTypes.item(i) != null) {
                // T2 is derived from the other type definition by DERIVATION_RESTRICTION
                if (isDerivedByRestriction(ancestorNS, ancestorName,(XSSimpleTypeDefinition)memberTypes.item(i))) {
                    return true;
                } 
            }
        }   
    }
    return false;
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private void expandRelatedSimpleTypeComponents(XSSimpleTypeDefinition type, Vector componentList, String namespace, Hashtable dependencies) {
    final XSTypeDefinition baseType = type.getBaseType();
    if (baseType != null) {
        addRelatedType(baseType, componentList, namespace, dependencies);
    }

    final XSTypeDefinition itemType = type.getItemType();
    if (itemType != null) {
        addRelatedType(itemType, componentList, namespace, dependencies);
    }
    
    final XSTypeDefinition primitiveType = type.getPrimitiveType();
    if (primitiveType != null) {
        addRelatedType(primitiveType, componentList, namespace, dependencies);
    }

    final XSObjectList memberTypes = type.getMemberTypes();
    if (memberTypes.size() > 0) {
        for (int i=0; i<memberTypes.size(); i++) {
            addRelatedType((XSTypeDefinition)memberTypes.item(i), componentList, namespace, dependencies);
        }
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
public void processEnumType(
    XSTypeDefinition def,
    Map<String, TypeDesc> jtMap,
    Map<String, NamespaceDesc> nsdMap
) throws Exception {
    boolean complexType = def instanceof XSComplexTypeDefinition;
    if (!nsdMap.containsKey(def.getNamespace())) {
        Util.log("Namespace desc not found for: " + def);
    }
    final String typeName = toJavaTypeName(def, nsdMap);
    final TypeDesc td = new TypeDesc(def.getName(), def.getNamespace(), typeName, TypeDesc.TypeEnum.ENUM);
    final XSComplexTypeDefinition ct = complexType ? (XSComplexTypeDefinition) def : null;
    final XSSimpleTypeDefinition st = (XSSimpleTypeDefinition) (complexType
                                                                    ? ((XSComplexTypeDefinition) def).getSimpleType()
                                                                    : def);
    for (int i = 0; i < st.getLexicalEnumeration().getLength(); i++) {
        final String s = st.getLexicalEnumeration().item(i);
        td.fdMap.put(s, new FieldDesc(Util.computeEnumConstantName(s, td.name), s));
    }

    final XSObjectList anns = complexType ? ct.getAnnotations() : st.getAnnotations();

    td.documentation = parseAnnotationString(
        "Enumeration " + def.getNamespace() + ":" + def.getName() + " documentation",
        anns != null && anns.getLength() > 0
            ? ((XSAnnotation) anns.item(0)).getAnnotationString()
            : null
    );
    jtMap.put(model.toJavaQualifiedTypeName(def, nsdMap, true), td);
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
public static Datatype getSimpleDatatypeFor(String schemaAsString,
		String typeName, String typeURI) throws EXIException {
	XSDGrammarsBuilder xsdGB = XSDGrammarsBuilder.newInstance();
	ByteArrayInputStream bais = new ByteArrayInputStream(
			schemaAsString.getBytes());
	xsdGB.loadGrammars(bais);
	xsdGB.toGrammars();

	XSModel xsModel = xsdGB.getXSModel();

	XSTypeDefinition td = xsModel.getTypeDefinition(typeName, typeURI);

	assertTrue("SimpleType expected",
			td.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE);

	Datatype dt = xsdGB.getDatatype((XSSimpleTypeDefinition) td);

	return dt;
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private void manageSimpleTypeElement(IXSDNode currentNode, XSParticleDecl fatherParticle, XSElementDecl currentElementDeclaration) {
    XSSimpleTypeDefinition simpleTypeDefinition = (XSSimpleTypeDefinition) currentElementDeclaration.getTypeDefinition();
    if (logger.isDebugEnabled()) logger.debug("Found a simple type: " + currentElementDeclaration.getName() + " with type: " + simpleTypeDefinition.getBuiltInKind());
    SimpleType simpleType = new SimpleType(getLeafType(simpleTypeDefinition.getBuiltInKind()));
    currentNode.addChild(simpleType);
    setCardinality(currentNode, fatherParticle);
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private void processAttribute(Path parent, String path, XSAttributeUse xsAttribute) throws BagriException {
  	
   path += "/@" + xsAttribute.getAttrDeclaration().getName();
   XSSimpleTypeDefinition std = xsAttribute.getAttrDeclaration().getTypeDefinition();
   Occurrence occurrence = Occurrence.getOccurrence(
   		xsAttribute.getRequired() ? 1 : 0,
   		std.getVariety() == XSSimpleTypeDefinition.VARIETY_LIST ? -1 : 1);
Path xp = modelMgr.translatePath(parent.getRoot(), path, NodeKind.attribute, parent.getPathId(), getBaseType(std), occurrence);
logger.trace("processAttribute; attribute: {}; type: {}; got XDMPath: {}", path, std, xp); 
  }
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
/**
 * If variety is <code>atomic</code> the primitive type definition (a
 * built-in primitive datatype definition or the simple ur-type
 * definition) is available, otherwise <code>null</code>.
 */
public XSSimpleTypeDefinition getPrimitiveType() {
    if (fVariety == VARIETY_ATOMIC && fValidationDV != DV_ANYSIMPLETYPE) {
        XSSimpleTypeDecl pri = this;
        // recursively get base, until we reach anySimpleType
        while (pri.fBase != fAnySimpleType)
            pri = pri.fBase;
        return pri;
    }
    else {
        // REVISIT: error situation. runtime exception?
        return null;
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
/**
 * If variety is <code>list</code> the item type definition (an atomic or
 * union simple type definition) is available, otherwise
 * <code>null</code>.
 */
public XSSimpleTypeDefinition getItemType() {
    if (fVariety == VARIETY_LIST) {
        return fItemType;
    }
    else {
        // REVISIT: error situation. runtime exception?
        return null;
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private void expandRelatedTypeComponents(XSTypeDefinition type, Vector componentList, String namespace, Hashtable dependencies) {
    if (type instanceof XSComplexTypeDecl) {
        expandRelatedComplexTypeComponents((XSComplexTypeDecl) type, componentList, namespace, dependencies);
    }
    else if (type instanceof XSSimpleTypeDecl) {
        expandRelatedSimpleTypeComponents((XSSimpleTypeDefinition) type, componentList, namespace, dependencies);
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private void processPSVITypeDefinition(XSTypeDefinition type) {
    if (type == null)
        return;
    if (type.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
        processPSVIComplexTypeDefinition((XSComplexTypeDefinition)type);
    }
    else if (type.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) {
        processPSVISimpleTypeDefinition((XSSimpleTypeDefinition)type);
    }
    else {
        throw new IllegalArgumentException(
            "Unknown type definition value: " + type.getType());
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private void processPSVIComplexTypeDefinition(XSComplexTypeDefinition type) {
    if (type == null)
        return;
    sendIndentedElementWithID("psv:complexTypeDefinition", type);
    sendElementEvent("psv:name", type.getName());
    sendElementEvent("psv:targetNamespace", type.getNamespace());
    processPSVITypeDefinitionOrRef(
        "psv:baseTypeDefinition",
        type.getBaseType());
    sendElementEvent(
        "psv:derivationMethod",
        this.translateDerivation(type.getDerivationMethod()));
    sendElementEvent("psv:final", this.translateBlockOrFinal(type.getFinal()));
    sendElementEvent("psv:abstract", String.valueOf(type.getAbstract()));
    processPSVIAttributeUses(type.getAttributeUses());
    processPSVIAttributeWildcard(type.getAttributeWildcard());
    sendIndentedElement("psv:contentType");
    sendElementEvent(
        "psv:variety",
        this.translateContentType(type.getContentType()));
    XSSimpleTypeDefinition simpleType = type.getSimpleType();
    if(simpleType == null || (!simpleType.getAnonymous() || fDefined.contains(this.getID(simpleType)))) {
        processPSVIElementRef("psv:simpleTypeDefinition", simpleType);
    }
    else {
        processPSVISimpleTypeDefinition(simpleType);
    }
    processPSVIParticle(type.getParticle());
    sendUnIndentedElement("psv:contentType");
    sendElementEvent(
        "psv:prohibitedSubstitutions",
        this.translateBlockOrFinal(type.getProhibitedSubstitutions()));
    processPSVIAnnotations(type.getAnnotations());
    sendUnIndentedElement("psv:complexTypeDefinition");
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private String translateFacetKind(short kind) {
    switch (kind) {
        case XSSimpleTypeDefinition.FACET_WHITESPACE :
            return SchemaSymbols.ELT_WHITESPACE;
        case XSSimpleTypeDefinition.FACET_LENGTH :
            return SchemaSymbols.ELT_LENGTH;
        case XSSimpleTypeDefinition.FACET_MINLENGTH :
            return SchemaSymbols.ELT_MINLENGTH;
        case XSSimpleTypeDefinition.FACET_MAXLENGTH :
            return SchemaSymbols.ELT_MAXLENGTH;
        case XSSimpleTypeDefinition.FACET_TOTALDIGITS :
            return SchemaSymbols.ELT_TOTALDIGITS;
        case XSSimpleTypeDefinition.FACET_FRACTIONDIGITS :
            return SchemaSymbols.ELT_FRACTIONDIGITS;
        case XSSimpleTypeDefinition.FACET_PATTERN :
            return SchemaSymbols.ELT_PATTERN;
        case XSSimpleTypeDefinition.FACET_ENUMERATION :
            return SchemaSymbols.ELT_ENUMERATION;
        case XSSimpleTypeDefinition.FACET_MAXINCLUSIVE :
            return SchemaSymbols.ELT_MAXINCLUSIVE;
        case XSSimpleTypeDefinition.FACET_MAXEXCLUSIVE :
            return SchemaSymbols.ELT_MAXEXCLUSIVE;
        case XSSimpleTypeDefinition.FACET_MINEXCLUSIVE :
            return SchemaSymbols.ELT_MINEXCLUSIVE;
        case XSSimpleTypeDefinition.FACET_MININCLUSIVE :
            return SchemaSymbols.ELT_MININCLUSIVE;
        default :
            return "unknown";
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private String translateVariety(short var) {
    switch (var) {
        case XSSimpleTypeDefinition.VARIETY_LIST :
            return "list";
        case XSSimpleTypeDefinition.VARIETY_UNION :
            return "union";
        case XSSimpleTypeDefinition.VARIETY_ATOMIC :
            return "atomic";
        case XSSimpleTypeDefinition.VARIETY_ABSENT :
            return null;
        default :
            return "unknown";
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
private String translateOrdered(short ordered) {
    switch (ordered) {
        case XSSimpleTypeDefinition.ORDERED_FALSE :
            return "false";
        case XSSimpleTypeDefinition.ORDERED_PARTIAL :
            return "partial";
        case XSSimpleTypeDefinition.ORDERED_TOTAL :
            return "total";
        default :
            return "unknown";
    }
}
 

import org.apache.xerces.xs.XSSimpleTypeDefinition; //导入依赖的package包/类
@Override
public void setAttribute(String name, String value, XSSimpleTypeDefinition attTypeDefinition) {
	JsonElementContainer attributeContainer = new JsonElementContainer(attributePrefix+name, false, false, false, attributePrefix);
	if (attTypeDefinition.getNumeric()) {
		attributeContainer.setNumber(true);
	}
	attributeContainer.setContent(value);
	addContent(attributeContainer);
}