package net.sf.saxon.functions;
import net.sf.saxon.Configuration;
import net.sf.saxon.expr.Expression;
import net.sf.saxon.expr.ExpressionVisitor;
import net.sf.saxon.expr.XPathContext;
import net.sf.saxon.om.*;
import net.sf.saxon.pattern.NameTest;
import net.sf.saxon.sort.GenericAtomicComparer;
import net.sf.saxon.sort.IntHashSet;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.type.ComplexType;
import net.sf.saxon.type.SchemaType;
import net.sf.saxon.type.Type;
import net.sf.saxon.value.*;
import javax.xml.transform.TransformerException;
import java.util.ArrayList;
import java.util.List;
/**
* XSLT 2.0 deep-equal() function.
* Supports deep comparison of two sequences (of nodes and/or atomic values)
* optionally using a collation
*/
public class DeepEqual extends CollatingFunction {
/**
* Flag indicating that two elements should only be considered equal if they have the same
* in-scope namespaces
*/
public static final int INCLUDE_NAMESPACES = 1<<0;
/**
* Flag indicating that two element or attribute nodes are considered equal only if their
* names use the same namespace prefix
*/
public static final int INCLUDE_PREFIXES = 1<<1;
/**
* Flag indicating that comment children are taken into account when comparing element or document nodes
*/
public static final int INCLUDE_COMMENTS = 1<<2;
/**
* Flag indicating that processing instruction nodes are taken into account when comparing element or document nodes
*/
public static final int INCLUDE_PROCESSING_INSTRUCTIONS = 1<<3;
/**
* Flag indicating that whitespace text nodes are ignored when comparing element nodes
*/
public static final int EXCLUDE_WHITESPACE_TEXT_NODES = 1<<4;
/**
* Flag indicating that elements and attributes should always be compared according to their string
* value, not their typed value
*/
public static final int COMPARE_STRING_VALUES = 1<<5;
/**
* Flag indicating that elements and attributes must have the same type annotation to be considered
* deep-equal
*/
public static final int COMPARE_ANNOTATIONS = 1<<6;
/**
* Flag indicating that a warning message explaining the reason why the sequences were deemed non-equal
* should be sent to the ErrorListener
*/
public static final int WARNING_IF_FALSE = 1<<7;
/**
* Flag indicating that adjacent text nodes in the top-level sequence are to be merged
*/
public static final int JOIN_ADJACENT_TEXT_NODES = 1<<8;
private transient Configuration config = null;
/**
* preEvaluate: if all arguments are known statically, evaluate early
* @param visitor an expression visitor
*/
public Expression preEvaluate(ExpressionVisitor visitor) throws XPathException {
config = visitor.getConfiguration();
return super.preEvaluate(visitor);
}
/**
* Evaluate the expression
*/
public Item evaluateItem(XPathContext context) throws XPathException {
GenericAtomicComparer collator = getAtomicComparer(2, context);
SequenceIterator op1 = argument[0].iterate(context);
SequenceIterator op2 = argument[1].iterate(context);
Configuration config =
(this.config!=null ? this.config : context.getConfiguration());
return BooleanValue.get(deepEquals(op1, op2, collator, config, 0));
}
/**
* Determine when two sequences are deep-equal
* @param op1 the first sequence
* @param op2 the second sequence
* @param collator the collator to be used
* @param config the configuration (gives access to the NamePool)
* @param flags bit-significant integer giving comparison options. Always zero for standard
* F+O deep-equals comparison.
* @return true if the sequences are deep-equal
*/
public static boolean deepEquals(SequenceIterator op1, SequenceIterator op2,
GenericAtomicComparer collator, Configuration config, int flags) {
boolean result = true;
String reason = null;
try {
if ((flags & JOIN_ADJACENT_TEXT_NODES) != 0) {
op1 = mergeAdjacentTextNodes(op1);
op2 = mergeAdjacentTextNodes(op2);
}
while (true) {
Item item1 = op1.next();
Item item2 = op2.next();
if (item1 == null && item2 == null) {
break;
}
if (item1 == null || item2 == null) {
result = false;
reason = "sequences have different lengths";
break;
}
if (item1 instanceof NodeInfo) {
if (item2 instanceof NodeInfo) {
if (!deepEquals((NodeInfo)item1, (NodeInfo)item2, collator, config, flags)) {
result = false;
reason = "nodes at position " + op1.position() + " differ";
break;
}
} else {
result = false;
reason = "comparing a node to an atomic value at position " + op1.position();
break;
}
} else {
if (item2 instanceof NodeInfo) {
result = false;
reason = "comparing an atomic value to a node at position " + op1.position();
break;
} else {
AtomicValue av1 = ((AtomicValue)item1);
AtomicValue av2 = ((AtomicValue)item2);
if (av1.isNaN() && av2.isNaN()) {
// treat as equal, no action
} else if (!collator.comparesEqual(av1, av2)) {
result = false;
reason = "atomic values at position " + op1.position() + " differ";
break;
}
}
}
} // end while
} catch (ClassCastException err) {
// this will happen if the sequences contain non-comparable values
// comparison errors are masked
result = false;
reason = "sequences contain non-comparable values";
} catch (XPathException err) {
// comparison errors are masked
result = false;
reason = "error occurred while comparing two values (" + err.getMessage() + ')';
}
if (!result) {
explain(config, reason, flags);
// config.getErrorListener().warning(
// new XPathException("deep-equal(): " + reason)
// );
}
return result;
}
/**
* Determine whether two nodes are deep-equal
*/
private static boolean deepEquals(NodeInfo n1, NodeInfo n2,
GenericAtomicComparer collator, Configuration config, int flags)
throws XPathException {
// shortcut: a node is always deep-equal to itself
if (n1.isSameNodeInfo(n2)) return true;
if (n1.getNodeKind() != n2.getNodeKind()) {
explain(config, "node kinds differ: comparing " + Type.displayTypeName(n1) + " to " + Type.displayTypeName(n2), flags);
return false;
}
final NamePool pool = config.getNamePool();
switch (n1.getNodeKind()) {
case Type.ELEMENT:
if (n1.getFingerprint() != n2.getFingerprint()) {
explain(config, "element names differ: " + config.getNamePool().getClarkName(n1.getFingerprint()) +
" != " + config.getNamePool().getClarkName(n2.getFingerprint()), flags);
return false;
}
if (((flags & INCLUDE_PREFIXES) != 0) && (n1.getNameCode() != n2.getNameCode())) {
explain(config, "element prefixes differ: " + n1.getPrefix() +
" != " + n2.getPrefix(), flags);
return false;
}
AxisIterator a1 = n1.iterateAxis(Axis.ATTRIBUTE);
AxisIterator a2 = n2.iterateAxis(Axis.ATTRIBUTE);
if (Aggregate.count(a1.getAnother()) != Aggregate.count(a2)) {
explain(config, "elements have different number of attributes", flags);
return false;
}
while (true) {
NodeInfo att1 = (NodeInfo)a1.next();
if (att1 == null) break;
AxisIterator a2iter = n2.iterateAxis(Axis.ATTRIBUTE,
new NameTest(Type.ATTRIBUTE, att1.getFingerprint(), pool));
NodeInfo att2 = (NodeInfo)a2iter.next();
if (att2==null) {
explain(config, "one element has an attribute " +
config.getNamePool().getClarkName(att1.getFingerprint()) +
", the other does not", flags);
return false;
}
if (!deepEquals(att1, att2, collator, config, flags)) {
explain(config, "elements have different values for the attribute " +
config.getNamePool().getClarkName(att1.getFingerprint()), flags);
return false;
}
}
if ((flags & INCLUDE_NAMESPACES) != 0) {
IntHashSet ns1 = new IntHashSet(10);
IntHashSet ns2 = new IntHashSet(10);
AxisIterator it1 = n1.iterateAxis(Axis.NAMESPACE);
while (true) {
NodeInfo nn1 = (NodeInfo)it1.next();
if (nn1 == null) {
break;
}
int nscode1 = pool.getNamespaceCode(nn1.getLocalPart(), nn1.getStringValue());
ns1.add(nscode1);
}
AxisIterator it2 = n2.iterateAxis(Axis.NAMESPACE);
while (true) {
NodeInfo nn2 = (NodeInfo)it2.next();
if (nn2 == null) {
break;
}
int nscode2 = pool.getNamespaceCode(nn2.getLocalPart(), nn2.getStringValue());
ns2.add(nscode2);
}
if (!ns1.equals(ns2)) {
explain(config, "elements have different in-scope namespaces", flags);
return false;
}
}
if ((flags & COMPARE_ANNOTATIONS) != 0) {
if (n1.getTypeAnnotation() != n2.getTypeAnnotation()) {
explain(config, "elements have different type annotation", flags);
return false;
}
}
if ((flags & COMPARE_STRING_VALUES) == 0) {
int ann1 = n1.getTypeAnnotation();
int ann2 = n2.getTypeAnnotation();
if (ann1 == -1) {
// defensive programming
ann1 = StandardNames.XS_UNTYPED;
}
if (ann2 == -1) {
// defensive programming
ann2 = StandardNames.XS_UNTYPED;
}
final SchemaType type1 = config.getSchemaType(ann1);
final SchemaType type2 = config.getSchemaType(ann2);
final boolean isSimple1 = type1.isSimpleType() || ((ComplexType)type1).isSimpleContent();
final boolean isSimple2 = type2.isSimpleType() || ((ComplexType)type2).isSimpleContent();
if (isSimple1 != isSimple2) {
explain(config, "one element has a simple type, the other does not", flags);
return false;
}
if (isSimple1 && isSimple2) {
final SequenceIterator v1 = n1.getTypedValue();
final SequenceIterator v2 = n2.getTypedValue();
return deepEquals(v1, v2, collator, config, flags);
}
}
// fall through
case Type.DOCUMENT:
AxisIterator c1 = n1.iterateAxis(Axis.CHILD);
AxisIterator c2 = n2.iterateAxis(Axis.CHILD);
while (true) {
NodeInfo d1 = (NodeInfo)c1.next();
while (d1 != null && isIgnorable(d1, flags)) {
d1 = (NodeInfo)c1.next();
}
NodeInfo d2 = (NodeInfo)c2.next();
while (d2 != null && isIgnorable(d2, flags)) {
d2 = (NodeInfo)c2.next();
}
if (d1 == null || d2 == null) {
boolean r = (d1 == d2);
if (!r) {
explain(config, "nodes have different numbers of children", flags);
}
return r;
}
if (!deepEquals(d1, d2, collator, config, flags)) {
return false;
}
}
case Type.ATTRIBUTE:
if (n1.getFingerprint() != n2.getFingerprint()) {
explain(config, "attribute names differ: " +
config.getNamePool().getClarkName(n1.getFingerprint()) +
" != " + config.getNamePool().getClarkName(n2.getFingerprint()), flags);
return false;
}
if (((flags & INCLUDE_PREFIXES) != 0) && (n1.getNameCode() != n2.getNameCode())) {
explain(config, "attribute prefixes differ: " + n1.getPrefix() +
" != " + n2.getPrefix(), flags);
return false;
}
if ((flags & COMPARE_ANNOTATIONS) != 0) {
if (n1.getTypeAnnotation() != n2.getTypeAnnotation()) {
explain(config, "attributes have different type annotations", flags);
return false;
}
}
boolean ar;
if ((flags & COMPARE_STRING_VALUES) == 0) {
ar = deepEquals(n1.getTypedValue(), n2.getTypedValue(), collator, config, 0);
} else {
ar = collator.comparesEqual(
new StringValue(n1.getStringValueCS()),
new StringValue(n2.getStringValueCS()));
}
if (!ar) {
explain(config, "attribute values differ", flags);
}
return ar;
case Type.PROCESSING_INSTRUCTION:
case Type.NAMESPACE:
if (n1.getFingerprint() != n2.getFingerprint()) {
explain(config, Type.displayTypeName(n1) + " names differ", flags);
return false;
}
// drop through
case Type.TEXT:
case Type.COMMENT:
boolean vr = (collator.comparesEqual((AtomicValue)n1.atomize(), (AtomicValue)n2.atomize()));
if (!vr) {
AtomicValue av1 = (AtomicValue)n1.atomize();
AtomicValue av2 = (AtomicValue)n2.atomize();
explain(config, Type.displayTypeName(n1) + " values differ (\"" +
Navigator.getPath(n1) + ", " + Navigator.getPath(n2) + ": " +
StringValue.diagnosticDisplay(av1.getStringValue()) + "\", \"" +
StringValue.diagnosticDisplay(av2.getStringValue()) + "\")", flags);
}
return vr;
default:
throw new IllegalArgumentException("Unknown node type");
}
}
private static boolean isIgnorable(NodeInfo node, int flags) {
final int kind = node.getNodeKind();
if (kind == Type.COMMENT) {
return (flags & INCLUDE_COMMENTS)==0;
} else if (kind == Type.PROCESSING_INSTRUCTION) {
return (flags & INCLUDE_PROCESSING_INSTRUCTIONS)==0;
} else if (kind == Type.TEXT) {
return ((flags & EXCLUDE_WHITESPACE_TEXT_NODES)!=0) &&
Whitespace.isWhite(node.getStringValueCS());
}
return false;
}
private static void explain(Configuration config, String message, int flags) {
try {
if ((flags & WARNING_IF_FALSE) != 0) {
config.getErrorListener().warning(new XPathException("deep-equal(): " + message));
}
} catch (TransformerException e) {
//
}
}
private static SequenceIterator mergeAdjacentTextNodes(SequenceIterator in) throws XPathException {
Configuration config = null;
List items = new ArrayList(20);
boolean prevIsText = false;
FastStringBuffer textBuffer = new FastStringBuffer(100);
while (true) {
Item next = in.next();
if (next == null) {
break;
}
if (next instanceof NodeInfo && ((NodeInfo)next).getNodeKind() == Type.TEXT) {
textBuffer.append(next.getStringValueCS());
prevIsText = true;
config = ((NodeInfo)next).getConfiguration();
} else {
if (prevIsText) {
Orphan textNode = new Orphan(config);
textNode.setNodeKind(Type.TEXT);
textNode.setStringValue(textBuffer.toString()); // must copy the buffer before reusing it
items.add(textNode);
textBuffer.setLength(0);
}
prevIsText = false;
items.add(next);
}
}
if (prevIsText) {
Orphan textNode = new Orphan(config);
textNode.setNodeKind(Type.TEXT);
textNode.setStringValue(textBuffer.toString()); // must copy the buffer before reusing it
items.add(textNode);
}
SequenceExtent extent = new SequenceExtent(items);
return extent.iterate();
}
}
//
// The contents of this file are subject to the Mozilla Public License Version 1.0 (the "License");
// you may not use this file except in compliance with the License. You may obtain a copy of the
// License at http://www.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS" basis,
// WITHOUT WARRANTY OF ANY KIND, either express or implied.
// See the License for the specific language governing rights and limitations under the License.
//
// The Original Code is: all this file.
//
// The Initial Developer of the Original Code is Michael Kay
//
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
//
// Contributor(s): none.
//