soughtValue = soughtValue.convert(BuiltInAtomicType.STRING, true).asAtomic();
} else {
// If the key value is numeric, promote it to a double
// TODO: this could result in two decimals comparing equal because they convert to the same double
BuiltInAtomicType itemType = soughtValue.getPrimitiveType();
if (itemType.equals(BuiltInAtomicType.INTEGER) ||
itemType.equals(BuiltInAtomicType.DECIMAL) ||
itemType.equals(BuiltInAtomicType.FLOAT)) {
soughtValue = new DoubleValue(((NumericValue)soughtValue).getDoubleValue());
}
}
// NOTE: This is much more elaborate than it needs to be. The option convertUntypedToOther
// is used for an index used to support a general comparison. This reports an error if two
// non-comparable values are compared. We could report an error immediately if foundItemTypes
// includes a type that is not comparable to the soughtValue. In practice we only need a maximum
// of two indexes: one for the sought item type, and one for untypedAtomic.
HashSet<BuiltInAtomicType> foundItemTypes = null;
AtomicValue value = soughtValue;
// No special action needed for anyURI to string promotion (it just seems to work: tests idky44, 45)
int keySetNumber = keySet.getKeySetNumber();
BuiltInAtomicType itemType = value.getPrimitiveType();
HashMap index;
Object indexObject = getIndex(doc, keySetNumber, itemType);
if (indexObject instanceof String) {
// index is under construction
XPathException de = new XPathException("Key definition is circular");
de.setXPathContext(context);
de.setErrorCode("XTDE0640");
throw de;
}
index = (HashMap)indexObject;
// If the index does not yet exist, then create it.
if (index==null) {
// Mark the index as being under construction, in case the definition is circular
putIndex(doc, keySetNumber, itemType, "Under Construction", context);
index = buildIndex(keySet, itemType, foundItemTypes, doc, context);
putIndex(doc, keySetNumber, itemType, index, context);
if (foundItemTypes != null) {
// build indexes for each item type actually found
for (Iterator<BuiltInAtomicType> f = foundItemTypes.iterator(); f.hasNext();) {
BuiltInAtomicType t = f.next();
if (!t.equals(BuiltInAtomicType.STRING)) {
putIndex(doc, keySetNumber, t, "Under Construction", context);
index = buildIndex(keySet, t, null, doc, context);
putIndex(doc, keySetNumber, t, index, context);
}
}
}
}
if (foundItemTypes == null) {
ArrayList nodes = (ArrayList)index.get(getCollationKey(value, itemType, collation, context));
if (nodes==null) {
return EmptyIterator.getInstance();
} else {
return new client.net.sf.saxon.ce.tree.iter.ListIterator(nodes);
}
} else {
// we need to search the indexes for all possible types, and combine the results.
SequenceIterator result = null;
HashMap<Long, Object> docIndex = docIndexes.get(doc);
if (docIndex != null) {
for (Iterator<Long> i= index.keySet().iterator(); i.hasNext();) {
long key = (i.next()).longValue();
if (((key >> 32)) == keySetNumber) {
int typefp = (int)key;
BuiltInAtomicType type = (BuiltInAtomicType)BuiltInType.getSchemaType(typefp);
Object indexObject2 = getIndex(doc, keySetNumber, type);
if (indexObject2 instanceof String) {
// index is under construction
XPathException de = new XPathException("Key definition is circular");