import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * Introduced in DOM Level 2. <p>
 * Checks if a type is derived from another by restriction. See:
 * http://www.w3.org/TR/DOM-Level-3-Core/core.html#TypeInfo-isDerivedFrom
 * 
 * @param typeNamespaceArg 
 *        The namspace of the ancestor type declaration
 * @param typeNameArg
 *        The name of the ancestor type declaration
 * @param derivationMethod
 *        The derivation method
 * 
 * @return boolean True if the type is derived by restriciton for the
 *         reference type
 */
public boolean isDerivedFrom(String typeNamespaceArg, String typeNameArg, 
        int derivationMethod) {
    if(needsSyncData()) {
        synchronizeData();
    }
    if (type != null) {
        if (type instanceof XSSimpleTypeDecl) {
            return ((XSSimpleTypeDecl) type).isDOMDerivedFrom(
                    typeNamespaceArg, typeNameArg, derivationMethod);
        } else if (type instanceof XSComplexTypeDecl) {
            return ((XSComplexTypeDecl) type).isDOMDerivedFrom(
                    typeNamespaceArg, typeNameArg, derivationMethod);
        }
    }
    return false;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
@Override
public String toString()
{
	StringBuffer rtBuffer=new StringBuffer();
	if (getCoreObject()==null)
		return null;
	if (getCoreObject().getNamespace()!=null)
		rtBuffer.append(getCoreObject().getNamespace()+":");
	rtBuffer.append(getCoreObject().getName());
	if (getCoreObject() instanceof XSElementDecl)
		rtBuffer.append(" (Element)");
	else if (getCoreObject() instanceof XSComplexTypeDecl)
		rtBuffer.append(" (Complex Type)");
	else if (getCoreObject() instanceof XSSimpleTypeDecl)
		rtBuffer.append(" (Smple Type)");
	else
		rtBuffer.append(" (Unknown)");
	

	return rtBuffer.toString();
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * @see org.w3c.dom.TypeInfo#getTypeName()
 */
public String getTypeName() {
    if (type !=null){
        if (type instanceof XSSimpleTypeDecl) {
            return ((XSSimpleTypeDecl) type).getTypeName();
        } else if (type instanceof XSComplexTypeDecl) {
            return ((XSComplexTypeDecl) type).getTypeName();
        }
    }
    return null;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * @see org.w3c.dom.TypeInfo#getTypeName()
 */
public String getTypeName() {
    if (type !=null){
        if (type instanceof XSSimpleTypeDecl){
            return ((XSSimpleTypeDecl)type).getName();
        }
        return (String)type;
    }
    return null;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * @see org.w3c.dom.TypeInfo#getTypeNamespace()
 */
public String getTypeNamespace() {
    if (type !=null) {
        if (type instanceof XSSimpleTypeDecl){
            return ((XSSimpleTypeDecl)type).getNamespace();
        }
        return DTD_URI;
    }
    return null;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
public final XSSimpleTypeDecl getSimpleTypeDecl(){
    int     chunk       = fSTDeclIndex >> CHUNK_SHIFT;
    int     index       = fSTDeclIndex &  CHUNK_MASK;
    ensureSTDeclCapacity(chunk);
    if (fSTDecl[chunk][index] == null) {
        fSTDecl[chunk][index] = dvFactory.newXSSimpleTypeDecl();
    } else {
        fSTDecl[chunk][index].reset();
    }
    fSTDeclIndex++;
    return fSTDecl[chunk][index];

}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
private boolean ensureSTDeclCapacity(int chunk) {
    if (chunk >= fSTDecl.length) {
        fSTDecl = resize(fSTDecl, fSTDecl.length * 2);
    } else if (fSTDecl[chunk] != null) {
        return false;
    }

    fSTDecl[chunk] = new XSSimpleTypeDecl[CHUNK_SIZE];
    return true;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
XSSimpleType traverseLocal(Element elmNode,
        XSDocumentInfo schemaDoc,
        SchemaGrammar grammar) {
    
    // General Attribute Checking
    Object[] attrValues = fAttrChecker.checkAttributes(elmNode, false, schemaDoc);
    String name = genAnonTypeName(elmNode);
    XSSimpleType type = getSimpleType (name, elmNode, attrValues, schemaDoc, grammar);
    if (type instanceof XSSimpleTypeDecl) {
        ((XSSimpleTypeDecl)type).setAnonymous(true);
    }
    fAttrChecker.returnAttrArray(attrValues, schemaDoc);
    
    return type;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的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.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * register one global type
 */
public void addGlobalTypeDecl(XSTypeDefinition decl) {
    fGlobalTypeDecls.put(decl.getName(), decl);
    if (decl instanceof XSComplexTypeDecl) {
        ((XSComplexTypeDecl) decl).setNamespaceItem(this);
    }
    else if (decl instanceof XSSimpleTypeDecl) {
        ((XSSimpleTypeDecl) decl).setNamespaceItem(this);
    }
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * register one global simple type
 */
public void addGlobalSimpleTypeDecl(XSSimpleType decl) {
    fGlobalTypeDecls.put(decl.getName(), decl);
    if (decl instanceof XSSimpleTypeDecl) {
        ((XSSimpleTypeDecl) decl).setNamespaceItem(this);
    }
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
public int compareTo(Object arg0) {
	// TODO Auto-generated method stub
	XSObject toCompareObj=((CellRenderXSObject)arg0).getCoreObject();
	if (getCoreObject()==null|toCompareObj==null)
		return 0;
	if (getCoreObject() instanceof XSElementDecl)
	{
		if (toCompareObj instanceof XSElementDecl)
			return this.toString().compareTo(arg0.toString());
		else
			return -1;
		
	}
	else if (getCoreObject() instanceof XSComplexTypeDecl)
	{
		if (toCompareObj instanceof XSElementDecl)
			return 1;
		else if (toCompareObj instanceof XSComplexTypeDecl)
			return this.toString().compareTo(arg0.toString());
		else
			return -1;
	}
	else if (getCoreObject() instanceof XSSimpleTypeDecl)
	{
		if (toCompareObj instanceof XSSimpleTypeDecl)
			return this.toString().compareTo(arg0.toString());
		else
			return 1;
	}
	else
		return this.toString().compareTo(arg0.toString());
//	return 0;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
private static XSSimpleTypeDecl[][] resize(XSSimpleTypeDecl array[][], int newsize) {
    XSSimpleTypeDecl newarray[][] = new XSSimpleTypeDecl[newsize][];
    System.arraycopy(array, 0, newarray, 0, array.length);
    return newarray;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * Checks if a type is derived from another by restriction. 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 derivationMethod
 *            A short indication the method of derivation *
 * @param type
 *            The reference type definition
 * 
 * @return boolean True if the type is derived by restriciton for the
 *         reference type
 */
private boolean isDerivedByRestriction(String ancestorNS,
        String ancestorName, int derivationMethod, XSTypeDefinition type) {
    
    XSTypeDefinition oldType = null;
    while (type != null && type != oldType) {
        
        // ancestor is anySimpleType, return false
        if (ancestorNS != null
                && ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
                && ancestorName.equals(SchemaSymbols.ATTVAL_ANYSIMPLETYPE)) {
            return false;
        }
        
        // if the name and namespace of this type is the same as the
        // ancestor return true
        if ((ancestorName.equals(type.getName()))
                && (ancestorNS != null && ancestorNS.equals(type.getNamespace())) 
                        || ((type.getNamespace() == null && ancestorNS == null))) {
            
            return true;
        }
        
        // If the base type is a complexType with simpleContent
        if (type instanceof XSSimpleTypeDecl) {
            if (ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
                    && ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)) {
                ancestorName = SchemaSymbols.ATTVAL_ANYSIMPLETYPE;
            }
            return ((XSSimpleTypeDecl) type).isDOMDerivedFrom(ancestorNS,
                    ancestorName, derivationMethod);
        } else {
            // If the base type is a complex type
            // Every derivation step till the base type should be
            // restriction. If not return false
            if (((XSComplexTypeDecl) type).getDerivationMethod() != XSConstants.DERIVATION_RESTRICTION) {
                return false;
            }
        }
        oldType = type;
        type = type.getBaseType();
        
    }
    
    return false;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * Checks if a type is derived from another by extension. 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 derivationMethod
 *            A short indication the method of derivation
 * @param type
 *            The reference type definition
 * 
 * @return boolean True if the type is derived by extension for the
 *         reference type
 */
private boolean isDerivedByExtension(String ancestorNS,
        String ancestorName, int derivationMethod, XSTypeDefinition type) {
    
    boolean extension = false;
    XSTypeDefinition oldType = null;
    while (type != null && type != oldType) {
        // If ancestor is anySimpleType return false.
        if (ancestorNS != null
                && ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
                && ancestorName.equals(SchemaSymbols.ATTVAL_ANYSIMPLETYPE)
                && SchemaSymbols.URI_SCHEMAFORSCHEMA.equals(type.getNamespace())
                        && SchemaSymbols.ATTVAL_ANYTYPE.equals(type.getName())) {
            break;
        }
        
        if ((ancestorName.equals(type.getName()))
                && ((ancestorNS == null && type.getNamespace() == null) 
                    || (ancestorNS != null && ancestorNS.equals(type.getNamespace())))) {
            // returns true if atleast one derivation step was extension
            return extension;
        }
        
        // If the base type is a complexType with simpleContent
        if (type instanceof XSSimpleTypeDecl) {
            if (ancestorNS.equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)
                    && ancestorName.equals(SchemaSymbols.ATTVAL_ANYTYPE)) {
                ancestorName = SchemaSymbols.ATTVAL_ANYSIMPLETYPE;
            }
            
            // derivationMethod extension will always return false for a
            // simpleType,
            // we treat it like a restriction
            if ((derivationMethod & DERIVATION_EXTENSION) != 0) {
                return extension
                & ((XSSimpleTypeDecl) type).isDOMDerivedFrom(
                        ancestorNS, ancestorName,
                        (derivationMethod & DERIVATION_RESTRICTION));
            } else {
                return extension
                & ((XSSimpleTypeDecl) type).isDOMDerivedFrom(
                        ancestorNS, ancestorName, derivationMethod);
            }
            
        } else {
            // If the base type is a complex type
            // At least one derivation step upto the ancestor type should be
            // extension.
            if (((XSComplexTypeDecl) type).getDerivationMethod() == XSConstants.DERIVATION_EXTENSION) {
                extension = extension | true;
            }
        }
        oldType = type;
        type = type.getBaseType();
    }
    
    return false;
}
 

import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl; //导入依赖的package包/类
/**
 * Introduced in DOM Level 3. <p>
 * Checks if a type is derived from another by restriction. See:
 * http://www.w3.org/TR/DOM-Level-3-Core/core.html#TypeInfo-isDerivedFrom
 * 
 * @param typeNamespaceArg 
 *        The namspace of the ancestor type declaration
 * @param typeNameArg
 *        The name of the ancestor type declaration
 * @param derivationMethod
 *        The derivation method
 * 
 * @return boolean True if the type is derived by restriciton for the
 *         reference type
 */
public boolean isDerivedFrom(String typeNamespaceArg, 
                             String typeNameArg, 
                             int derivationMethod) {
    if (type != null) {
        if (type instanceof XSSimpleTypeDecl) {
            return ((XSSimpleTypeDecl) type).isDOMDerivedFrom(
                    typeNamespaceArg, typeNameArg, derivationMethod);
        }    
    } 
    return false;
}