/// <summary> /// Construct an atomic value of a given built-in or user-defined type /// </summary> /// <example> /// <code>AtomicValue("abcd", QName.XDT_UNTYPED_ATOMIC)</code> /// <para>creates an untyped atomic value containing the string "abcd"</para> /// </example> /// <param name="lexicalForm">The string representation of the value (any value that is acceptable /// in the lexical space, as defined by XML Schema Part 2). Whitespace normalization as defined by /// the target type will be applied to the value.</param> /// <param name="type">The QName giving the name of the target type. This must be an atomic /// type, and it must not be a type that is namespace-sensitive (QName, NOTATION, or types derived /// from these). If the type is a user-defined type then its definition must be present /// in the schema cache maintained by the <c>SchemaManager</c>.</param> /// <param name="processor">The <c>Processor</c> object. This is needed for looking up user-defined /// types, and also because some conversions are context-sensitive, for example they depend on the /// implicit timezone or the choice of XML 1.0 versus XML 1.1 for validating names.</param> /// <exception name="ArgumentException">Thrown if the type is unknown or unsuitable, or if the supplied string is not /// a valid lexical representation of a value of the given type.</exception> public XdmAtomicValue(String lexicalForm, QName type, Processor processor) { JConfiguration jconfig = processor.config; int fp = jconfig.getNamePool().getFingerprint(type.Uri, type.LocalName); if (fp == -1) { throw new ArgumentException("Unknown name " + type); } JSchemaType st = jconfig.getSchemaType(fp); if (st == null) { throw new ArgumentException("Unknown type " + type); } if (!(st is JAtomicType)) { throw new ArgumentException("Specified type " + type + " is not atomic"); } if (((JAtomicType)st).isNamespaceSensitive()) { throw new ArgumentException("Specified type " + type + " is namespace-sensitive"); } JAtomicValue result = new StringValue(lexicalForm).convert( (JAtomicType)st, jconfig.getConversionContext(), true); if (result is ValidationErrorValue) { throw new ArgumentException(((ValidationErrorValue)result).getException().getMessage()); } this.value = result; }
/// <summary> /// Factory method to get an <c>AtomicType</c> object representing the atomic type with a given QName. /// </summary> /// <remarks> /// It is undefined whether two calls on this method supplying the same QName will return the same /// <c>XdmAtomicType</c> object instance. /// </remarks> /// <param name="qname">The QName of the required type</param> /// <returns>An <c>AtomicType</c> object representing this type if it is present in this schema (and is an /// atomic type); otherwise, null. </returns> public XdmAtomicType GetAtomicType(QName qname) { JSchemaType type = config.getSchemaType(qname.ToStructuredQName()); if (type is JBuiltInAtomicType) { return(XdmAtomicType.BuiltInAtomicType(qname)); } else if (type is JAtomicType) { return(new XdmAtomicType((JAtomicType)type)); } else { return(null); } }
/// <summary> /// Factory method to get an <c>AtomicType</c> object representing the atomic type with a given <c>QName</c>. /// </summary> /// <remarks> /// It is undefined whether two calls on this method supplying the same <c>QName</c> will return the same /// <c>XdmAtomicType</c> object instance. /// </remarks> /// <param name="qname">The <c>QName</c> of the required type</param> /// <returns>An <c>AtomicType</c> object representing this type if it is present in this schema (and is an /// atomic type); otherwise, null. </returns> public XdmAtomicType GetAtomicType(QName qname) { JSchemaType type = config.getSchemaType(qname.ToStructuredQName()); if (type is JBuiltInAtomicType) { return XdmAtomicType.BuiltInAtomicType(qname); } else if (type is JAtomicType) { JItemTypeFactory factory = new JItemTypeFactory(processor.JProcessor); return new XdmAtomicType(factory.getAtomicType(qname.UnderlyingQName())); } else { return null; } }