xsdabstracttraverser.java

java1.6众多例子参考

    // Temp data structures to be re-used in traversing facets
    private StringBuffer fPattern = new StringBuffer();
    private final XSFacets xsFacets = new XSFacets();
    
    class FacetInfo {
        XSFacets facetdata;
        Element nodeAfterFacets;
        short fPresentFacets;
        short fFixedFacets;
    }
    
    FacetInfo traverseFacets(Element content,
            XSSimpleType baseValidator,
            XSDocumentInfo schemaDoc) {
        
        short facetsPresent = 0 ;
        short facetsFixed = 0; // facets that have fixed="true"        
        String facet;
        boolean hasQName = containsQName(baseValidator);
        Vector enumData = null;
        XSObjectListImpl enumAnnotations = null;
        XSObjectListImpl patternAnnotations = null;
        Vector enumNSDecls = hasQName ? new Vector() : null;       
        int currentFacet = 0;
        xsFacets.reset();
        while (content != null) {           
            // General Attribute Checking
            Object[] attrs = null;
            facet = DOMUtil.getLocalName(content);
            if (facet.equals(SchemaSymbols.ELT_ENUMERATION)) {
                attrs = fAttrChecker.checkAttributes(content, false, schemaDoc, hasQName);
                String enumVal = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];
                NamespaceSupport nsDecls = (NamespaceSupport)attrs[XSAttributeChecker.ATTIDX_ENUMNSDECLS];
                
                // for NOTATION types, need to check whether there is a notation
                // declared with the same name as the enumeration value.
                if (baseValidator.getVariety() == XSSimpleType.VARIETY_ATOMIC &&
                        baseValidator.getPrimitiveKind() == XSSimpleType.PRIMITIVE_NOTATION) {
                    // need to use the namespace context returned from checkAttributes
                    schemaDoc.fValidationContext.setNamespaceSupport(nsDecls);
                    try{
                        QName temp = (QName)fQNameDV.validate(enumVal, schemaDoc.fValidationContext, null);
                        // try to get the notation decl. if failed, getGlobalDecl
                        // reports an error, so we don't need to report one again.
                        fSchemaHandler.getGlobalDecl(schemaDoc, XSDHandler.NOTATION_TYPE, temp, content);
                    }catch(InvalidDatatypeValueException ex){
                        reportSchemaError(ex.getKey(), ex.getArgs(), content);
                    }
                    // restore to the normal namespace context
                    schemaDoc.fValidationContext.setNamespaceSupport(schemaDoc.fNamespaceSupport);
                }
                if (enumData == null){
                    enumData = new Vector();
                    enumAnnotations = new XSObjectListImpl();
                }
                enumData.addElement(enumVal);
                enumAnnotations.add(null);
                if (hasQName)
                    enumNSDecls.addElement(nsDecls);
                Element child = DOMUtil.getFirstChildElement( content );
                
                if (child != null) {
                    // traverse annotation if any
                    
                    if (DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
                        enumAnnotations.add(enumAnnotations.getLength()-1,traverseAnnotationDecl(child, attrs, false, schemaDoc));
                        child = DOMUtil.getNextSiblingElement(child);
                    }
                    else {
                        String text = DOMUtil.getSyntheticAnnotation(content);
                        if (text != null) {
                            enumAnnotations.add(enumAnnotations.getLength()-1, traverseSyntheticAnnotation(content, text, attrs, false, schemaDoc));
                        }
                    }
                    if (child !=null && DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
                        reportSchemaError("s4s-elt-must-match.1", new Object[]{"enumeration", "(annotation?)", DOMUtil.getLocalName(child)}, child);
                    }
                }
                else {
                    String text = DOMUtil.getSyntheticAnnotation(content);
                    if (text != null) {
                        enumAnnotations.add(enumAnnotations.getLength() - 1, traverseSyntheticAnnotation(content, text, attrs, false, schemaDoc));
                    }
                }
            }
            else if (facet.equals(SchemaSymbols.ELT_PATTERN)) {
                attrs = fAttrChecker.checkAttributes(content, false, schemaDoc);
                if (fPattern.length() == 0) {
                    fPattern.append((String)attrs[XSAttributeChecker.ATTIDX_VALUE]);
                } else {
                    // ---------------------------------------------
                    //datatypes: 5.2.4 pattern: src-multiple-pattern
                    // ---------------------------------------------
                    fPattern.append("|");
                    fPattern.append((String)attrs[XSAttributeChecker.ATTIDX_VALUE]);
                }
                Element child = DOMUtil.getFirstChildElement( content );
                if (child != null) {
                    // traverse annotation if any
                    if (DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
                        if (patternAnnotations == null){
                            patternAnnotations = new XSObjectListImpl();
                        }
                        patternAnnotations.add(traverseAnnotationDecl(child, attrs, false, schemaDoc));
                        child = DOMUtil.getNextSiblingElement(child);
                    }
                    if (child !=null && DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
                        reportSchemaError("s4s-elt-must-match.1", new Object[]{"pattern", "(annotation?)", DOMUtil.getLocalName(child)}, child);
                    }
                }
                
            }
            else {
                if (facet.equals(SchemaSymbols.ELT_MINLENGTH)) {
                    currentFacet = XSSimpleType.FACET_MINLENGTH;
                }
                else if (facet.equals(SchemaSymbols.ELT_MAXLENGTH)) {
                    currentFacet = XSSimpleType.FACET_MAXLENGTH;
                }
                else if (facet.equals(SchemaSymbols.ELT_MAXEXCLUSIVE)) {
                    currentFacet = XSSimpleType.FACET_MAXEXCLUSIVE;
                }
                else if (facet.equals(SchemaSymbols.ELT_MAXINCLUSIVE)) {
                    currentFacet = XSSimpleType.FACET_MAXINCLUSIVE;
                }
                else if (facet.equals(SchemaSymbols.ELT_MINEXCLUSIVE)) {
                    currentFacet = XSSimpleType.FACET_MINEXCLUSIVE;
                }
                else if (facet.equals(SchemaSymbols.ELT_MININCLUSIVE)) {
                    currentFacet = XSSimpleType.FACET_MININCLUSIVE;
                }
                else if (facet.equals(SchemaSymbols.ELT_TOTALDIGITS)) {
                    currentFacet = XSSimpleType.FACET_TOTALDIGITS;
                }
                else if (facet.equals(SchemaSymbols.ELT_FRACTIONDIGITS)) {
                    currentFacet = XSSimpleType.FACET_FRACTIONDIGITS;
                }
                else if (facet.equals(SchemaSymbols.ELT_WHITESPACE)) {
                    currentFacet = XSSimpleType.FACET_WHITESPACE;
                }
                else if (facet.equals(SchemaSymbols.ELT_LENGTH)) {
                    currentFacet = XSSimpleType.FACET_LENGTH;
                }
                else {
                    break;   // a non-facet
                }
                
                attrs = fAttrChecker.checkAttributes(content, false, schemaDoc);
                
                // check for duplicate facets
                if ((facetsPresent & currentFacet) != 0) {
                    reportSchemaError("src-single-facet-value", new Object[]{facet}, content);
                } else if (attrs[XSAttributeChecker.ATTIDX_VALUE] != null) {
                    facetsPresent |= currentFacet;
                    // check for fixed facet
                    if (((Boolean)attrs[XSAttributeChecker.ATTIDX_FIXED]).booleanValue()) {
                        facetsFixed |= currentFacet;
                    }
                    switch (currentFacet) {
                    case XSSimpleType.FACET_MINLENGTH:
                        xsFacets.minLength = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();
                    break;
                    case XSSimpleType.FACET_MAXLENGTH:
                        xsFacets.maxLength = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();
                    break;
                    case XSSimpleType.FACET_MAXEXCLUSIVE:
                        xsFacets.maxExclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];
                    break;
                    case XSSimpleType.FACET_MAXINCLUSIVE:
                        xsFacets.maxInclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];
                    break;
                    case XSSimpleType.FACET_MINEXCLUSIVE:
                        xsFacets.minExclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];
                    break;
                    case XSSimpleType.FACET_MININCLUSIVE:
                        xsFacets.minInclusive = (String)attrs[XSAttributeChecker.ATTIDX_VALUE];
                    break;
                    case XSSimpleType.FACET_TOTALDIGITS:
                        xsFacets.totalDigits = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();
                    break;
                    case XSSimpleType.FACET_FRACTIONDIGITS:
                        xsFacets.fractionDigits = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();
                    break;
                    case XSSimpleType.FACET_WHITESPACE:
                        xsFacets.whiteSpace = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).shortValue();
                    break;
                    case XSSimpleType.FACET_LENGTH:
                        xsFacets.length = ((XInt)attrs[XSAttributeChecker.ATTIDX_VALUE]).intValue();
                    break;
                    }
                }
                
                Element child = DOMUtil.getFirstChildElement( content );
                if (child != null) {
                    // traverse annotation if any
                    if (DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION)) {
                        XSAnnotationImpl annotation = traverseAnnotationDecl(child, attrs, false, schemaDoc);
                        switch (currentFacet) {
                        case XSSimpleType.FACET_MINLENGTH:
                            xsFacets.minLengthAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_MAXLENGTH:
                            xsFacets.maxLengthAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_MAXEXCLUSIVE:
                            xsFacets.maxExclusiveAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_MAXINCLUSIVE:
                            xsFacets.maxInclusiveAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_MINEXCLUSIVE:
                            xsFacets.minExclusiveAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_MININCLUSIVE:
                            xsFacets.minInclusiveAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_TOTALDIGITS:
                            xsFacets.totalDigitsAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_FRACTIONDIGITS:
                            xsFacets.fractionDigitsAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_WHITESPACE:
                            xsFacets.whiteSpaceAnnotation = annotation;
                        break;
                        case XSSimpleType.FACET_LENGTH:
                            xsFacets.lengthAnnotation = annotation;
                        break;
                        }
                        
                        
                        child = DOMUtil.getNextSiblingElement(child);
                    }
                    else {
                        String text = DOMUtil.getSyntheticAnnotation(content);
                        if (text != null) {
                            XSAnnotationImpl annotation = traverseSyntheticAnnotation(content, text, attrs, false, schemaDoc);
                            switch (currentFacet) {
                                case XSSimpleType.FACET_MINLENGTH:
                                    xsFacets.minLengthAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_MAXLENGTH:
                                    xsFacets.maxLengthAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_MAXEXCLUSIVE:
                                    xsFacets.maxExclusiveAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_MAXINCLUSIVE:
                                    xsFacets.maxInclusiveAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_MINEXCLUSIVE:
                                    xsFacets.minExclusiveAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_MININCLUSIVE:
                                    xsFacets.minInclusiveAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_TOTALDIGITS:
                                    xsFacets.totalDigitsAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_FRACTIONDIGITS:
                                    xsFacets.fractionDigitsAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_WHITESPACE:
                                    xsFacets.whiteSpaceAnnotation = annotation;
                                    break;
                                case XSSimpleType.FACET_LENGTH:
                                    xsFacets.lengthAnnotation = annotation;
                                    break;
                            }
                        }