import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private Map<QName, List<QName>> getComplexTypeToElementName(ClassOutline classOutline) {
    Map<QName, List<QName>> complexTypeToElementName = new HashMap<QName, List<QName>>();

    XSSchemaSet schemaSet = classOutline.target.getSchemaComponent().getRoot();
    for (XSSchema schema : schemaSet.getSchemas()) {
        Map<String, XSElementDecl> elemDecls = schema.getElementDecls();
        for (Entry<String, XSElementDecl> entry : elemDecls.entrySet()) {
            XSElementDecl decl = entry.getValue();
            XSType xsType = decl.getType();

            if (xsType.getName() == null) {
                continue;
            }
            QName type = new QName(xsType.getTargetNamespace(), xsType.getName());
            List<QName> qnames = complexTypeToElementName.get(type);

            if (qnames == null) {
                qnames = new ArrayList<QName>();
                complexTypeToElementName.put(type, qnames);
            }
            qnames.add(new QName(decl.getTargetNamespace(), decl.getName()));
        }
    }

    return complexTypeToElementName;
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
/**
 * Implements
 * <code>Validation Rule: Schema-Validity Assessment (Element) 1.2.1.2.4</code> 
 */
private static boolean isSubstitutable( XSType _base, XSType derived ) {
    // too ugly to the point that it's almost unbearable.
    // I mean, it's not even transitive. Thus we end up calling this method
    // for each candidate
    if( _base.isComplexType() ) {
        XSComplexType base = _base.asComplexType();
        
        for( ; base!=derived; derived=derived.getBaseType() ) {
            if( base.isSubstitutionProhibited( derived.getDerivationMethod() ) )
                return false;    // Type Derivation OK (Complex)-1
        }
        return true;
    } else {
        // simple type don't have any @block
        return true;
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
/**
 * Creates node for element declaration with additional attributes.
 *
 * @param decl      Element declaration.
 * @param extraAtts Additional attributes.
 */
private void elementDecl(XSElementDecl decl, String extraAtts) {
    XSType type = decl.getType();

    // TODO: various other attributes

    String str = MessageFormat.format("Element name=\"{0}\"{1}{2}",
            new Object[]{
                decl.getName(),
                type.isLocal() ? "" : " type=\"{"
            + type.getTargetNamespace() + "}"
            + type.getName() + "\"", extraAtts});

    SchemaTreeNode newNode = new SchemaTreeNode(str, decl.getLocator());
    this.currNode.add(newNode);
    this.currNode = newNode;

    if (type.isLocal()) {
        if (type.isLocal()) {
            type.visit(this);
        }
    }

    this.currNode = (SchemaTreeNode) this.currNode.getParent();
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private void elementDecl( XSElementDecl decl, String extraAtts ) {
    XSType type = decl.getType();
    
    // TODO: various other attributes 
    
    println(MessageFormat.format("<element name=\"{0}\"{1}{2}{3}>",
        new Object[]{
            decl.getName(),
            type.isLocal()?"":" type=\"{"+
                type.getTargetNamespace()+'}'+
                type.getName()+'\"',
            extraAtts,
            type.isLocal()?"":"/"
        }));

    if(type.isLocal()) {
        indent++;

        if(type.isLocal())  type.visit(this);

        indent--;
        println("</element>");
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public XSAttributeUse getAttributeUse( String nsURI, String localName ) {
    UName name = new UName(nsURI,localName);
    
    if(prohibitedAtts.contains(name))       return null;
    
    XSAttributeUse o = attributes.get(name);
    
    
    if(o==null) {
        Iterator<XSAttGroupDecl> itr = iterateAttGroups();
        while(itr.hasNext() && o==null)
            o = itr.next().getAttributeUse(nsURI,localName);
    }
    
    if(o==null) {
        XSType base = getBaseType();
        if(base.asComplexType()!=null)
            o = base.asComplexType().getAttributeUse(nsURI,localName);
    }
    
    return o;
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
static int XsTypeToMetadataType(XSType xsType) {
    String name = "";
    if (xsType != null) {
        name = xsType.getName();
    }
    if ("byte".equalsIgnoreCase(name)) {
        return ProductData.TYPE_UINT8;
    } else if ("integer".equalsIgnoreCase(name)) {
        return ProductData.TYPE_INT32;
    } else if ("double".equalsIgnoreCase(name) ||
            "real".equalsIgnoreCase(name) ||
            "float".equalsIgnoreCase(name)) {
        return ProductData.TYPE_FLOAT32;
    } else if ("date".equals(name) ||
            "dateTime".equals(name)) {
        return ProductData.TYPE_UTC;
    } else {
        return ProductData.TYPE_ASCII;
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private static int XsTypeToMetadataType(XSType xsType) {
    String name = "";
    if (xsType != null) {
        name = xsType.getName();
    }
    if ("byte".equalsIgnoreCase(name)) {
        return ProductData.TYPE_UINT8;
    } else if ("integer".equalsIgnoreCase(name)) {
        return ProductData.TYPE_INT32;
    } else if ("double".equalsIgnoreCase(name) ||
            "real".equalsIgnoreCase(name)) {
        return ProductData.TYPE_FLOAT32;
    } else if ("date".equals(name) ||
            "dateTime".equals(name)) {
        return ProductData.TYPE_UTC;
    } else {
        return ProductData.TYPE_ASCII;
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public ContentPriorityIF getConstraints(SchemaElementIF element)
{
  XSType type = element.getXSType(schemaSet);

  if (tagToConstraints.containsKey(type))
  {
    return tagToConstraints.get(type);
  }
  else
  {
    XSDConstraintsMiner constraintsMiner = new XSDConstraintsMiner();
    type.visit(constraintsMiner);
    ContentPriorityIF contentPriority = constraintsMiner.getContentPriority();
    return contentPriority;
  }

}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private boolean isDerivedFromComplexType(XSSchema schema, String localPart) {
	XSType base = schema.getType(localPart);
	if (base != null) {
		if (base.isSimpleType()) {
			typeFlag.add(TypeFlag.NO_ABSTRACT_GML);
			typeFlag.add(TypeFlag.NO_FEATURE);
			typeFlag.add(TypeFlag.NO_FEATURE_COLLECTION);
			typeFlag.add(TypeFlag.NO_CITY_OBJECT);
			typeFlag.add(TypeFlag.NO_GEOMETRY);
			typeFlag.add(TypeFlag.NO_FEATURE_PROPERTY);
			typeFlag.add(TypeFlag.NO_GEOMETRY_PROPERTY);

			return false;
		} else
			return element.getType().isDerivedFrom(base);
	} 

	return false;
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
/**
 * Retrieves allowed values for a restricted type
 * 
 * @param inputName
 *            SOAP input
 * @return allowed values for the input or an empty list if the type of the
 *         input is not a string restriction
 */
public List<String> getPossibleValues(String inputName) {
	List<String> values = new ArrayList<String>();

	XSElementDecl element = schemaElements.get(inputName);
	if (element == null)
		return values;

	XSType type = element.getType();
	if (type == null || !(type instanceof XSRestrictionSimpleType))
		return values;

	XSRestrictionSimpleType res = (XSRestrictionSimpleType) type;

	String baseType = res.getBaseType().getName();
	// allow only xsd:string "enumerations"
	if (!baseType.equals("string"))
		return values;

	for (XSFacet facet : res.getDeclaredFacets()) {
		String value = facet.getValue().toString();
		values.add(value);
	}

	return values;
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public static boolean hasAnnotation(XSType xsType, QName annotationElementName) {
	if (xsType.getName() == null) {
		return false;
	}
	Element annotationElement = getAnnotationElement(xsType.getAnnotation(), annotationElementName);
	if (annotationElement != null) {
		return true;
	}
	if (xsType.getBaseType() != null && !xsType.getBaseType().equals(xsType)) {
		return hasAnnotation(xsType.getBaseType(), annotationElementName);
	}
	return false;
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private static void _valueToDocument( Value value, Element element, Document doc, XSType type )
{
	if ( type.isSimpleType() ) {
		element.appendChild( doc.createTextNode( value.strValue() ) );
	} else if ( type.isComplexType() ) {
		String name;
		Value currValue;
		XSComplexType complexType = type.asComplexType();

		// Iterate over attributes
		Collection< ? extends XSAttributeUse > attributeUses = complexType.getAttributeUses();
		for( XSAttributeUse attrUse : attributeUses ) {
			name = attrUse.getDecl().getName();
			if ( (currValue=getAttributeOrNull( value, name )) != null ) {
				element.setAttribute( name, currValue.strValue() );
			}
		}

		XSContentType contentType = complexType.getContentType();
		XSParticle particle = contentType.asParticle();
		if ( contentType.asSimpleType() != null ) {
			element.appendChild( doc.createTextNode( value.strValue() ) );
		} else if ( particle != null ) {
			XSTerm term = particle.getTerm();
			XSModelGroupDecl modelGroupDecl;
			XSModelGroup modelGroup = null;
			if ( (modelGroupDecl=term.asModelGroupDecl()) != null ) {
				modelGroup = modelGroupDecl.getModelGroup();
			} else if ( term.isModelGroup() ) {
				modelGroup = term.asModelGroup();
			}
			if ( modelGroup != null ) {
				_valueToDocument( value, element, doc, modelGroup );
			}
		}
	}
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private TypeDefinition createSimpleType( XSType type, XSElementDecl element, Range range )
{
	checkType( type );
	TypeInlineDefinition right = new TypeInlineDefinition( parsingContext, element.getName().replace("-","_"), XsdUtils.xsdToNativeType( type.getName() ), range );
	if ( element.isNillable() ) {
		TypeInlineDefinition left = new TypeInlineDefinition( parsingContext, element.getName().replace("-","_"), NativeType.VOID, range );
		return new TypeChoiceDefinition( parsingContext, element.getName().replace("-","_"), range, left, right );
	} else {
		return right;
	}



}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
/**
 * Checks whether a native type for a given simple type is defined.
 */
private void checkForNativeType( XSType type, String msg )
	throws ConversionException
{
	if ( XsdUtils.xsdToNativeType( type.getName() ) == null ) {
		if ( !strict() ) {
			log( Level.WARNING, msg + " Name: " + type.getName() );
		} else {
			throw new ConversionException( ERROR_SIMPLE_TYPE + msg + " Name: " + type.getName() );
		}
	}
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public boolean contains(XSType type) {
    if( typeSet.contains(type) ) {
        return true;
    } else {
        XSType baseType = type.getBaseType();
        if( baseType == null ) {
            return false;
        } else {
            // climb the super type hierarchy
            return contains(baseType);
        }
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public Iterator<XSType> iterateTypes() {
    return new Iterators.Map<XSType,XSSchema>(iterateSchema()) {
        protected Iterator<XSType> apply(XSSchema u) {
            return u.iterateTypes();
        }
    };
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public boolean isDerivedFrom(XSType t) {
    XSType x = this;
    while(true) {
        if(t==x)
            return true;
        XSType s = x.getBaseType();
        if(s==x)
            return false;
        x = s;
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private static XSType[] listDirectSubstitutables( XSType _this ) {
    ArrayList r = new ArrayList();
    
    // TODO: handle @block
    Iterator itr = ((SchemaImpl)_this.getOwnerSchema()).parent.iterateTypes();
    while( itr.hasNext() ) {
        XSType t = (XSType)itr.next();
        if( t.getBaseType()==_this )
            r.add(t);
    }
    return (XSType[]) r.toArray(new XSType[r.size()]);
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
private static void buildSubstitutables( XSType head, XSType _this, Set substitutables ) {
    if(!isSubstitutable(head,_this))
        return;    // no derived type of _this can substitute head.
    
    if(substitutables.add(_this)) {
        XSType[] child = listDirectSubstitutables(_this);
        for( int i=0; i<child.length; i++ )
            buildSubstitutables( head, child[i], substitutables );
    }
}
 

import com.sun.xml.xsom.XSType; //导入依赖的package包/类
public void updateSubstitutabilityMap() {
    ElementDecl parent = this;
    XSType type = this.getType(); 

    boolean rused = false;
    boolean eused = false;
    
    while( (parent=(ElementDecl)parent.getSubstAffiliation())!=null ) {
        
        if(parent.isSubstitutionDisallowed(XSType.SUBSTITUTION))
            continue;
        
        boolean rd = parent.isSubstitutionDisallowed(XSType.RESTRICTION);
        boolean ed = parent.isSubstitutionDisallowed(XSType.EXTENSION);

        if( (rd && rused) || ( ed && eused ) )   continue;
        
        XSType parentType = parent.getType();
        while(type!=parentType) {
            if(type.getDerivationMethod()==XSType.RESTRICTION)  rused = true;
            else                                                eused = true;
            
            type = type.getBaseType();
            if(type==null)  // parentType and type doesn't share the common base type. a bug in the schema.
                break;
            
            if( type.isComplexType() ) {
                rd |= type.asComplexType().isSubstitutionProhibited(XSType.RESTRICTION);
                ed |= type.asComplexType().isSubstitutionProhibited(XSType.EXTENSION);
            }
        }
        
        if( (rd && rused) || ( ed && eused ) )   continue;
        
        // this element can substitute "parent"
        parent.addSubstitutable(this);
    }
}