Java XSConstants.SCOPE_GLOBAL属性代码示例

private void analyzeElement(IXSDNode currentNode, XSParticleDecl fatherParticle, XSElementDecl elementDeclaration) {
    if (logger.isDebugEnabled()) logger.debug("analyzeElement: " + elementDeclaration.getName());
    String elementName = elementDeclaration.getName();
    IXSDNode element = null;
    if (elementDeclaration.getScope() == XSConstants.SCOPE_GLOBAL) {
        if (logger.isDebugEnabled()) logger.debug(elementName + " has GLOBAL SCOPE");
        element = globalElements.get(elementName);
        if (element == null) {
            element = createNewElement(elementDeclaration);
            globalElements.put(elementName, element);
            analyzeType(element, fatherParticle, elementDeclaration);
        } else {
            element.setNested(true);
            element = element.clone();
            setCardinality(element, fatherParticle);
        }
    } else {
        element = createNewElement(elementDeclaration);
        analyzeType(element, fatherParticle, elementDeclaration);
    }
    if (currentNode != null) {
        currentNode.addChild(element);
    }
}
 

public XSElementDecl getMatchingElemDecl(QName element, XSElementDecl exemplar) {
    if (element.localpart == exemplar.fName &&
        element.uri == exemplar.fTargetNamespace) {
        return exemplar;
    }

    // if the exemplar is not a global element decl, then it's not possible
    // to be substituted by another element.
    if (exemplar.fScope != XSConstants.SCOPE_GLOBAL) {
        return null;
    }

    // if the decl blocks substitution, return false
    if ((exemplar.fBlock & XSConstants.DERIVATION_SUBSTITUTION) != 0) {
        return null;
    }

    // get the decl for the element
    XSElementDecl eDecl = fXSElementDeclHelper.getGlobalElementDecl(element);
    if (eDecl == null) {
        return null;
    }

    // and check by using substitutionGroup information
    if (substitutionGroupOK(eDecl, exemplar, exemplar.fBlock)) {
        return eDecl;
    }

    return null;
}
 

private void addRelatedElement(XSElementDeclaration decl, Vector componentList, String namespace, Hashtable dependencies) {
    if (decl.getScope() == XSConstants.SCOPE_GLOBAL) {
        if (!componentList.contains(decl)) {
            Vector importedNamespaces = findDependentNamespaces(namespace, dependencies);
            addNamespaceDependency(namespace, decl.getNamespace(), importedNamespaces);
            componentList.add(decl);
        }
    }
    else {
        expandRelatedElementComponents(decl, componentList, namespace, dependencies);
    }
}
 

private void addRelatedAttribute(XSAttributeDeclaration decl, Vector componentList, String namespace, Hashtable dependencies) {
    if (decl.getScope() == XSConstants.SCOPE_GLOBAL) {
        if (!componentList.contains(decl)) {
            Vector importedNamespaces = findDependentNamespaces(namespace, dependencies);
            addNamespaceDependency(namespace, decl.getNamespace(), importedNamespaces);
            componentList.add(decl);
        }
    }
    else {
        expandRelatedAttributeComponents(decl, componentList, namespace, dependencies);
    }
}
 

public static void checkElementDeclsConsistent(XSComplexTypeDecl type,
        XSParticleDecl particle,
        SymbolHash elemDeclHash,
        SubstitutionGroupHandler sgHandler)
    throws XMLSchemaException {

    // check for elements in the tree with the same name and namespace

    int pType = particle.fType;

    if (pType == XSParticleDecl.PARTICLE_WILDCARD)
        return;

    if (pType == XSParticleDecl.PARTICLE_ELEMENT) {
        XSElementDecl elem = (XSElementDecl)(particle.fValue);
        findElemInTable(type, elem, elemDeclHash);

        if (elem.fScope == XSConstants.SCOPE_GLOBAL) {
            // Check for subsitution groups.
            XSElementDecl[] subGroup = sgHandler.getSubstitutionGroup(elem);
            for (int i = 0; i < subGroup.length; i++) {
                findElemInTable(type, subGroup[i], elemDeclHash);
            }
        }
        return;
    }

    XSModelGroupImpl group = (XSModelGroupImpl)particle.fValue;
    for (int i = 0; i < group.fParticleCount; i++)
        checkElementDeclsConsistent(type, group.fParticles[i], elemDeclHash, sgHandler);
}
 

private void processPSVIAttributeDeclarationOrRef(XSAttributeDeclaration att) {
    if (att == null)
        return;
    // for global attributes, and attributes that have already been printed,
    // we always want to print references
    if (att.getScope() == XSConstants.SCOPE_GLOBAL
        || fDefined.contains(this.getID(att))) {
        processPSVIAttributeDeclarationRef(att);
    }
    else {
        processPSVIAttributeDeclaration(att);
    }
}
 

private void processPSVIElementDeclarationOrRef(XSElementDeclaration elem) {
    if (elem == null)
        return;
    // for global attributes, and attributes that have already been printed,
    // we always want to print references
    if (elem.getScope() == XSConstants.SCOPE_GLOBAL
        || fDefined.contains(this.getID(elem))) {
        processPSVIElementDeclarationRef(elem);
    }
    else {
        processPSVIElementDeclaration(elem);
    }
}
 

private void processPSVIScope(
    String enclose,
    XSComplexTypeDefinition enclosingCTD,
    short scope) {
    if (scope == XSConstants.SCOPE_ABSENT || scope == XSConstants.SCOPE_GLOBAL) {
        sendElementEvent(enclose, this.translateScope(scope));
    } else {  // XSConstants.SCOPE_LOCAL
        processPSVITypeDefinitionRef(enclose, enclosingCTD);
    }
}
 

private String translateScope(short scope) {
    switch (scope) {
        case XSConstants.SCOPE_ABSENT :
            return null;
        case XSConstants.SCOPE_GLOBAL :
            return "global";
        case XSConstants.SCOPE_LOCAL :
            return "local";
        default :
            return "unknown";
    }
}