Examples of org.apache.xerces.impl.dv.XSSimpleType

org.apache.xerces.impl.dv.XSSimpleType
This interface XSSimpleType represents the simple type definition of schema component and defines methods to query the information contained. Any simple type (atomic, list or union) will implement this interface. It inherits from XSTypeDecl. @author Sandy Gao, IBM @version $Id: XSSimpleType.java,v 1.10 2002/10/25 16:42:30 sandygao Exp $


            ListDV.ListData values = (ListDV.ListData)ob;
            int len = values.length();
            if (fItemType.fVariety == VARIETY_UNION) {
                XSSimpleTypeDecl[] memberTypes = (XSSimpleTypeDecl[])validatedInfo.memberTypes;
                XSSimpleType memberType = validatedInfo.memberType;
                for (int i = len-1; i >= 0; i--) {
                    validatedInfo.actualValue = values.item(i);
                    validatedInfo.memberType = memberTypes[i];
                    fItemType.checkExtraRules(context, validatedInfo);
                }

View Full Code Here

                // xpath values are validated in xpath parser
                if (oneAttr.dvIndex >= 0) {
                    if (oneAttr.dvIndex != DT_STRING &&
                        oneAttr.dvIndex != DT_XPATH &&
                        oneAttr.dvIndex != DT_XPATH1) {
                        XSSimpleType dv = fExtraDVs[oneAttr.dvIndex];
                        Object avalue = dv.validate(attrVal, schemaDoc.fValidationContext, null);
                        // kludge to handle chameleon includes/redefines...
                        if (oneAttr.dvIndex == DT_QNAME) {
                            QName qname = (QName)avalue;
                            if(qname.prefix == XMLSymbols.EMPTY_STRING && qname.uri == null && schemaDoc.fIsChameleonSchema)
                                qname.uri = schemaDoc.fTargetNamespace;

View Full Code Here

                continue;
            // and get the datatype validator, if there is one
            attrDecl = sGrammar.getGlobalAttributeDecl(attrLocal);
            if (attrDecl == null)
                continue;
            XSSimpleType dv = (XSSimpleType)attrDecl.getTypeDefinition();
            if (dv == null)
                continue;


            // get all values appeared with this attribute name
            Vector values = (Vector)fNonSchemaAttrs.get(attrRName);
            String elName, attrVal;
            String attrName = (String)values.elementAt(0);
            // for each of the values
            int count = values.size();
            for (int i = 1; i < count; i += 2) {
                elName = (String)values.elementAt(i);
                try {
                    // and validate it using the XSSimpleType
                    // REVISIT: what would be the proper validation context?
                    //          guess we need to save that in the vectors too.
                    dv.validate((String)values.elementAt(i+1), null, null);
                } catch(InvalidDatatypeValueException ide) {
                    reportSchemaError ("s4s-att-invalid-value",
                                       new Object[] {elName, attrName, ide.getMessage()},
                                       null);
                }

View Full Code Here

      }
    }
    // normalization: simple type
    else if (fNormalizeData) {
      // if !union type
      XSSimpleType dv = (XSSimpleType) fCurrentType;
      if (dv.getVariety() == XSSimpleType.VARIETY_UNION) {
        fUnionType = true;
      } else {
        try {
          fWhiteSpace = dv.getWhitespace();
        } catch (DatatypeException e) {
          // do nothing
        }
      }
    }

View Full Code Here

    // For an attribute information item to be locally valid with respect to an attribute declaration all of the following must be true:
    // 1 The declaration must not be absent (see Missing Sub-components (5.3) for how this can fail to be the case).
    // 2 Its {type definition} must not be absent.
    // 3 The item's normalized value must be locally valid with respect to that {type definition} as per String Valid (3.14.4).
    // get simple type
    XSSimpleType attDV = currDecl.fType;


    Object actualValue = null;
    try {
      actualValue = attDV.validate(attrValue, fValidationState, fValidatedInfo);
      // store the normalized value
      if (fNormalizeData)
        attributes.setValue(index, fValidatedInfo.normalizedValue);
      if (attributes instanceof XMLAttributesImpl) {
        XMLAttributesImpl attrs = (XMLAttributesImpl) attributes;
        boolean schemaId =
          fValidatedInfo.memberType != null
            ? fValidatedInfo.memberType.isIDType()
            : attDV.isIDType();
        attrs.setSchemaId(index, schemaId);
      }


      // PSVI: element notation
      if (attDV.getVariety() == XSSimpleType.VARIETY_ATOMIC
        && attDV.getPrimitiveKind() == XSSimpleType.PRIMITIVE_NOTATION) {
        QName qName = (QName) actualValue;
        SchemaGrammar grammar = fGrammarBucket.getGrammar(qName.uri);


        //REVISIT: is it possible for the notation to be in different namespace than the attribute
        //with which it is associated, CHECK !!  <fof n1:att1 = "n2:notation1" ..>
        // should we give chance to the application to be able to  retrieve a grammar - nb
        //REVISIT: what would be the triggering component here.. if it is attribute value that
        // triggered the loading of grammar ?? -nb


        if (grammar != null) {
          fNotation = grammar.getGlobalNotationDecl(qName.localpart);
        }
      }
    } catch (InvalidDatatypeValueException idve) {
      reportSchemaError(idve.getKey(), idve.getArgs());
      reportSchemaError(
        "cvc-attribute.3",
        new Object[] { element.rawname, fTempQName.rawname, attrValue, attDV.getName()});
    }


    // get the value constraint from use or decl
    // 4 The item's actual value must match the value of the {value constraint}, if it is present and fixed.                 // now check the value against the simpleType
    if (actualValue != null && currDecl.getConstraintType() == XSConstants.VC_FIXED) {

View Full Code Here

      // 3.1.2 The element information item must have no element information item [children].
      if (fSubElement)
        reportSchemaError("cvc-type.3.1.2", new Object[] { element.rawname });
      // 3.1.3 If clause 3.2 of Element Locally Valid (Element) (3.3.4) did not apply, then the normalized value must be valid with respect to the type definition as defined by String Valid (3.14.4).
      if (!fNil) {
        XSSimpleType dv = (XSSimpleType) fCurrentType;
        try {
          if (!fNormalizeData || fUnionType) {
            fValidationState.setNormalizationRequired(true);
          }
          retValue = dv.validate(textContent, fValidationState, fValidatedInfo);
        } catch (InvalidDatatypeValueException e) {
          reportSchemaError(e.getKey(), e.getArgs());
          reportSchemaError(
            "cvc-type.3.1.3",
            new Object[] { element.rawname, textContent });

View Full Code Here

      }
      // 2.2 If the {content type} is a simple type definition, then the element information item has no element information item [children], and the normalized value of the element information item is valid with respect to that simple type definition as defined by String Valid (3.14.4).
      else if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE) {
        if (fSubElement)
          reportSchemaError("cvc-complex-type.2.2", new Object[] { element.rawname });
        XSSimpleType dv = ctype.fXSSimpleType;
        try {
          if (!fNormalizeData || fUnionType) {
            fValidationState.setNormalizationRequired(true);
          }
          actualValue = dv.validate(textContent, fValidationState, fValidatedInfo);
        } catch (InvalidDatatypeValueException e) {
          reportSchemaError(e.getKey(), e.getArgs());
          reportSchemaError("cvc-complex-type.2.2", new Object[] { element.rawname });
        }
        // REVISIT: eventually, this method should return the same actualValue as elementLocallyValidType...

View Full Code Here

    
                // 4 attributes, so initialize the size as 4*2 = 8
                fGlobalAttrDecls  = new SymbolHash(8);
                String name = null;
                String tns = null;
                XSSimpleType type = null;
                short scope = XSConstants.SCOPE_GLOBAL;
                
                // xsi:type
                name = SchemaSymbols.XSI_TYPE;
                tns = SchemaSymbols.URI_XSI;
                type = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_QNAME);
                fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));
                
                // xsi:nil
                name = SchemaSymbols.XSI_NIL;
                tns = SchemaSymbols.URI_XSI;
                type = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_BOOLEAN);
                fGlobalAttrDecls.put(name, new BuiltinAttrDecl(name, tns, type, scope));
                
                XSSimpleType anyURI = schemaFactory.getBuiltInType(SchemaSymbols.ATTVAL_ANYURI);
    
                // xsi:schemaLocation
                name = SchemaSymbols.XSI_SCHEMALOCATION;
                tns = SchemaSymbols.URI_XSI;
                type = schemaFactory.createTypeList(null, SchemaSymbols.URI_XSI, (short)0, anyURI, null);

View Full Code Here

            return false;
        }


        // 2.2 One of the following must be true:
        // 2.2.1 D's base type definition is B.
        XSSimpleType directBase = (XSSimpleType)derived.getBaseType();
        if (directBase == base)
            return true;


        // 2.2.2 D's base type definition is not the simple ur-type definition and is validly derived from B given the subset, as defined by this constraint.
        if (directBase != SchemaGrammar.fAnySimpleType &&

View Full Code Here

     * returns the compiled form of the value
     * The parameter value could be either a String or a ValidatedInfo object
     */
    public static Object ElementDefaultValidImmediate(XSTypeDefinition type, String value, ValidationContext context, ValidatedInfo vinfo) {


        XSSimpleType dv = null;


        // e-props-correct
        // For a string to be a valid default with respect to a type definition the appropriate case among the following must be true:
        // 1 If the type definition is a simple type definition, then the string must be valid with respect to that definition as defined by String Valid (3.14.4).
        if (type.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) {
            dv = (XSSimpleType)type;
        }


        // 2 If the type definition is a complex type definition, then all of the following must be true:
        else {
            // 2.1 its {content type} must be a simple type definition or mixed.
            XSComplexTypeDecl ctype = (XSComplexTypeDecl)type;
            // 2.2 The appropriate case among the following must be true:
            // 2.2.1 If the {content type} is a simple type definition, then the string must be valid with respect to that simple type definition as defined by String Valid (3.14.4).
            if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE) {
                dv = ctype.fXSSimpleType;
            }
            // 2.2.2 If the {content type} is mixed, then the {content type}'s particle must be emptiable as defined by Particle Emptiable (3.9.6).
            else if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_MIXED) {
                if (!((XSParticleDecl)ctype.getParticle()).emptiable())
                    return null;
            }
            else {
                return null;
            }
        }


        // get the simple type declaration, and validate
        Object actualValue = null;
        if (dv == null) {
            // complex type with mixed. to make sure that we store correct
            // information in vinfo and return the correct value, we use
            // "string" type for validation
            dv = STRING_TYPE;
        }
        try {
            // validate the original lexical rep, and set the actual value
            actualValue = dv.validate(value, context, vinfo);
            // validate the canonical lexical rep
            if (vinfo != null)
                actualValue = dv.validate(vinfo.stringValue(), context, vinfo);
        } catch (InvalidDatatypeValueException ide) {
            return null;
        }


        return actualValue;

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.xerces.impl.dv.XSSimpleType

de.fuberlin.wiwiss.d2rq.optimizer.expr.XSD

nexj.core.util.XSDUtil

org.apache.jena.riot.checker.CheckerLiterals

org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl

org.apache.xerces.impl.dv.xs_new.XSSimpleTypeDecl

org.apache.xerces.impl.xpath.CastNode

org.apache.xerces.impl.xpath.LiteralNode

org.apache.xerces.impl.xs.identity.Field$Matcher

org.apache.xerces.impl.xs.identity.IDValue

org.apache.xerces.impl.xs.identity.XPathMatcher

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.