Java AttributePSVI类代码示例

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
/** Returns whether the given attribute is an ID type. **/
private boolean processAttributePSVI(AttrImpl attr, AttributePSVI attrPSVI) {
    if (fStorePSVI) {
        ((PSVIAttrNSImpl) attr).setPSVI (attrPSVI);
    }
    Object type = attrPSVI.getMemberTypeDefinition ();
    if (type == null) {
        type = attrPSVI.getTypeDefinition ();
        if (type != null) {
            attr.setType(type);
            return ((XSSimpleType) type).isIDType();
        }
    }
    else {
        attr.setType(type);
        return ((XSSimpleType) type).isIDType();
    }
    return false;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
/**
 * Copy PSVI properties from another psvi item.
 * 
 * @param attr  the source of attribute PSVI items
 */
public void setPSVI(AttributePSVI attr) {
    this.fDeclaration = attr.getAttributeDeclaration();
    this.fValidationContext = attr.getValidationContext();
    this.fValidity = attr.getValidity();
    this.fValidationAttempted = attr.getValidationAttempted();
    this.fErrorCodes = attr.getErrorCodes();
    this.fErrorMessages = attr.getErrorMessages();
    this.fValue.copyFrom(attr.getSchemaValue());
    this.fTypeDecl = attr.getTypeDefinition();
    this.fSpecified = attr.getIsSchemaSpecified();
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
private TypeInfo getAttributeType( int index ) {
    checkStateAttribute();
    if (index < 0 || fAttributes.getLength() <= index) {
        throw new IndexOutOfBoundsException(Integer.toString(index));
    }
    Augmentations augs = fAttributes.getAugmentations(index);
    if (augs == null) {
        return null;
    }
    AttributePSVI psvi = (AttributePSVI)augs.getItem(Constants.ATTRIBUTE_PSVI);
    return getTypeInfoFromPSVI(psvi);
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
AttributePSVI getAttributePSVI(int index) {
    if (fAttributes != null) {
        Augmentations augs = fAttributes.getAugmentations(index);
        if (augs != null) {
            return (AttributePSVI) augs.getItem(Constants.ATTRIBUTE_PSVI);
        }
    }
    return null;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
AttributePSVI getAttributePSVIByName(String uri, String localname) {
    if (fAttributes != null) {
        Augmentations augs = fAttributes.getAugmentations(uri, localname);
        if (augs != null) {
            return (AttributePSVI) augs.getItem(Constants.ATTRIBUTE_PSVI);
        }
    }
    return null;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
/**
 * Reset() 
 */
public void reset() {
    fValue.reset();
    fDeclaration = null;
    fTypeDecl = null;
    fSpecified = false;
    fValidationAttempted = AttributePSVI.VALIDATION_NONE;
    fValidity = AttributePSVI.VALIDITY_NOTKNOWN;
    fErrors = null;
    fValidationContext = null;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
/**
 * Returns the schema-determined-ID.
 * 
 * 
 * @param attributes
 * @param index
 * @return A String containing the schema-determined ID. 
 * @throws XNIException
 */
public String getSchemaDeterminedID(XMLAttributes attributes, int index)
throws XNIException {
    Augmentations augs = attributes.getAugmentations(index);
    AttributePSVI attrPSVI = (AttributePSVI) augs
    .getItem(Constants.ATTRIBUTE_PSVI);
    
    if (attrPSVI != null) {
        // An element or attribute information item is a schema-determined 
        // ID if and only if one of the following is true:]
        
        // 1. It has a [member type definition] or [type definition] property 
        // whose value in turn has [name] equal to ID and [target namespace] 
        // equal to http://www.w3.org/2001/XMLSchema;
        
        // 2. It has a [base type definition] whose value has that [name] and [target namespace];
        
        // 3. It has a [base type definition] whose value has a [base type definition] 
        // whose value has that [name] and [target namespace], and so on following 
        // the [base type definition] property recursively;
        
        XSTypeDefinition typeDef = attrPSVI.getMemberTypeDefinition();
        if (typeDef != null) {
            typeDef = attrPSVI.getTypeDefinition();
        }
        
        // 
        if (typeDef != null && ((XSSimpleType) typeDef).isIDType()) {
            return attrPSVI.getSchemaNormalizedValue();
        }
        
        // 4 & 5 NA
    }
    
    return null;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public AttributePSVI getAttributePSVIByName(String uri, 
                                            String localname){
    return (AttributePSVI)fAttributesProxy.fAttributes.getAugmentations(uri, localname).getItem(Constants.ATTRIBUTE_PSVI);
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public AttributePSVI getAttributePSVI(int index) {
    return ((PSVIProvider)xmlReader).getAttributePSVI(index);
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public AttributePSVI getAttributePSVIByName(String uri, String localname) {
    return ((PSVIProvider)xmlReader).getAttributePSVIByName(uri, localname);
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public AttributePSVI getAttributePSVI(int index) {
    return (fSAXValidatorHelper != null) ? fSAXValidatorHelper.getAttributePSVI(index) : null;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public AttributePSVI getAttributePSVIByName(String uri, String localname) {
    return (fSAXValidatorHelper != null) ? fSAXValidatorHelper.getAttributePSVIByName(uri, localname) : null;
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public void startElement(QName element, XMLAttributes attributes,
        Augmentations augs) throws XNIException {
    Element elem;
    int attrCount = attributes.getLength();
    if (fDocumentImpl == null) {
        elem = fDocument.createElementNS(element.uri, element.rawname);
        for (int i = 0; i < attrCount; ++i) {
            attributes.getName(i, fAttributeQName);
            elem.setAttributeNS(fAttributeQName.uri, fAttributeQName.rawname, attributes.getValue(i));
        }
    }
    // If it's a Xerces DOM store type information for attributes, set idness, etc..
    else {
        elem = fDocumentImpl.createElementNS(element.uri, element.rawname, element.localpart);
        for (int i = 0; i < attrCount; ++i) {
            attributes.getName(i, fAttributeQName);
            AttrImpl attr = (AttrImpl) fDocumentImpl.createAttributeNS(fAttributeQName.uri, 
                    fAttributeQName.rawname, fAttributeQName.localpart);
            attr.setValue(attributes.getValue(i));
            elem.setAttributeNodeNS(attr);
            
            // write type information to this attribute
            AttributePSVI attrPSVI = (AttributePSVI) attributes.getAugmentations(i).getItem (Constants.ATTRIBUTE_PSVI);
            if (attrPSVI != null) {
                if (fStorePSVI) {
                    ((PSVIAttrNSImpl) attr).setPSVI(attrPSVI);
                }
                Object type = attrPSVI.getMemberTypeDefinition();
                if (type == null) {
                    type = attrPSVI.getTypeDefinition();
                    if (type != null) {
                        attr.setType (type);
                        if (((XSSimpleType) type).isIDType()) {
                            ((ElementImpl) elem).setIdAttributeNode (attr, true);
                        }
                    }
                }
                else {
                    attr.setType (type);
                    if (((XSSimpleType) type).isIDType()) {
                        ((ElementImpl) elem).setIdAttributeNode (attr, true);
                    }
                }
            }
            attr.setSpecified(attributes.isSpecified(i));
        }
    }
    append(elem);
    fCurrentNode = elem;
    if (fFragmentRoot == null) {
        fFragmentRoot = elem;
    }
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
private void processPSVIAttribute(Augmentations augs) {
    if (augs == null)
        return;
    AttributePSVI attrPSVI =
        (AttributePSVI)augs.getItem(Constants.ATTRIBUTE_PSVI);
    if (attrPSVI != null) {
        sendElementEvent(
            "psv:validationAttempted",
            this.translateValidationAttempted(
                attrPSVI.getValidationAttempted()));
        // Would rather getValidationContext() return element info item.
        // This is not the same as XSV.
        sendElementEvent(
            "psv:validationContext",
            attrPSVI.getValidationContext());

        sendElementEvent(
            "psv:validity",
            this.translateValidity(attrPSVI.getValidity()));

        processPSVISchemaErrorCode(attrPSVI.getErrorCodes());
        sendElementEvent(
            "psv:schemaNormalizedValue",
            attrPSVI.getSchemaNormalizedValue());
        sendElementEvent(
            "psv:schemaSpecified",
            attrPSVI.getIsSchemaSpecified() ? "schema" : "infoset");
        sendElementEvent("psv:schemaDefault", attrPSVI.getSchemaDefault());

        processPSVITypeDefinitionRef(
            "psv:typeDefinition",
            attrPSVI.getTypeDefinition());
        processPSVITypeDefinitionRef(
            "psv:memberTypeDefinition",
            attrPSVI.getMemberTypeDefinition());

        if (attrPSVI.getAttributeDeclaration() == null) {
            sendElementEvent("psv:declaration");
        }
        else {
            sendIndentedElement("psv:declaration");
            processPSVIAttributeDeclarationRef(
                attrPSVI.getAttributeDeclaration());
            sendUnIndentedElement("psv:declaration");
        }
    }
}
 

import org.apache.xerces.xs.AttributePSVI; //导入依赖的package包/类
public AttributePSVI getAttributePSVI(int index){

        return (AttributePSVI)fAttributesProxy.fAttributes.getAugmentations(index).getItem(Constants.ATTRIBUTE_PSVI);
    }