/** * Process this instruction * * @param context the dynamic context of the transformation * @return a TailCall to be executed by the caller, always null for this instruction */ public TailCall processLeavingTail(XPathContext context) throws XPathException { Controller controller = context.getController(); SequenceReceiver out = context.getReceiver(); int opt = options; int ann = annotation; // we may need to change the namespace prefix if the one we chose is // already in use with a different namespace URI: this is done behind the scenes // by the Outputter CharSequence value = expandChildren(context); if (schemaType != null) { // test whether the value actually conforms to the given type XPathException err = schemaType.validateContent( value, DummyNamespaceResolver.getInstance(), context.getConfiguration().getNameChecker()); if (err != null) { ValidationException verr = new ValidationException( "Attribute value " + Err.wrap(value, Err.VALUE) + " does not the match the required type " + schemaType.getDescription() + ". " + err.getMessage()); verr.setErrorCode("XTTE1540"); verr.setLocator(this); throw verr; } } else if (validationAction == Validation.STRICT || validationAction == Validation.LAX) { try { ann = controller.getConfiguration().validateAttribute(nameCode, value, validationAction); } catch (ValidationException e) { DynamicError err = DynamicError.makeDynamicError(e); String errorCode = e.getErrorCodeLocalPart(); if (errorCode == null) { errorCode = (validationAction == Validation.STRICT ? "XTTE1510" : "XTTE1515"); } err.setErrorCode(errorCode); err.setXPathContext(context); err.setLocator(this); err.setIsTypeError(true); throw err; } } try { out.attribute(nameCode, ann, value, locationId, opt); } catch (XPathException err) { throw dynamicError(this, err, context); } return null; }
/** * Convert to target data type * * @param requiredType an integer identifying the required atomic type * @return an AtomicValue, a value of the required type; or an ErrorValue */ public AtomicValue convertPrimitive(BuiltInAtomicType requiredType, boolean validate) { switch (requiredType.getPrimitiveType()) { case Type.G_MONTH_DAY: case Type.ATOMIC: case Type.ITEM: return this; case Type.STRING: return new StringValue(getStringValueCS()); case Type.UNTYPED_ATOMIC: return new UntypedAtomicValue(getStringValueCS()); default: ValidationException err = new ValidationException("Cannot convert gMonthDay to " + requiredType.getDisplayName()); err.setErrorCode("FORG0001"); return new ErrorValue(err); } }
public Item evaluateItem(XPathContext context) throws XPathException { Orphan o = (Orphan) super.evaluateItem(context); if (schemaType != null) { XPathException err = schemaType.validateContent( o.getStringValueCS(), DummyNamespaceResolver.getInstance(), context.getConfiguration().getNameChecker()); if (err != null) { throw new ValidationException( "Attribute value " + Err.wrap(o.getStringValueCS(), Err.VALUE) + " does not the match the required type " + schemaType.getDescription() + ". " + err.getMessage()); } o.setTypeAnnotation(schemaType.getFingerprint()); if (schemaType.isNamespaceSensitive()) { throw new DynamicError( "Cannot validate a parentless attribute whose content is namespace-sensitive"); } } else if (validationAction == Validation.STRICT || validationAction == Validation.LAX) { try { int ann = context .getController() .getConfiguration() .validateAttribute(nameCode, o.getStringValueCS(), validationAction); o.setTypeAnnotation(ann); } catch (ValidationException e) { DynamicError err = DynamicError.makeDynamicError(e); err.setErrorCode(e.getErrorCodeLocalPart()); err.setXPathContext(context); err.setLocator(this); err.setIsTypeError(true); throw err; } } return o; }