You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@vxquery.apache.org by pr...@apache.org on 2012/08/25 03:04:16 UTC
svn commit: r1377170 - in
/incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison:
AbstractDisjunctiveComparisonOperation.java
AbstractNegatingComparisonOperation.java
Author: prestonc
Date: Sat Aug 25 01:04:15 2012
New Revision: 1377170
URL: http://svn.apache.org/viewvc?rev=1377170&view=rev
Log:
Adding exceptions for NaN values on comparisons.
Modified:
incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java
incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java
Modified: incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java?rev=1377170&r1=1377169&r2=1377170&view=diff
==============================================================================
--- incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java (original)
+++ incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java Sat Aug 25 01:04:15 2012
@@ -68,12 +68,18 @@ public abstract class AbstractDisjunctiv
@Override
public boolean operateDecimalDouble(XSDecimalPointable decp1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep2.getDouble())) {
+ return false;
+ }
return (aOp1.operateDecimalDouble(decp1, doublep2) || aOp2.operateDecimalDouble(decp1, doublep2));
}
@Override
public boolean operateDecimalFloat(XSDecimalPointable decp1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp2.getFloat())) {
+ return false;
+ }
return (aOp1.operateDecimalFloat(decp1, floatp2) || aOp2.operateDecimalFloat(decp1, floatp2));
}
@@ -86,24 +92,36 @@ public abstract class AbstractDisjunctiv
@Override
public boolean operateDoubleDecimal(DoublePointable doublep1, XSDecimalPointable decp2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble())) {
+ return false;
+ }
return (aOp1.operateDoubleDecimal(doublep1, decp2) || aOp2.operateDoubleDecimal(doublep1, decp2));
}
@Override
public boolean operateDoubleDouble(DoublePointable doublep1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble()) || Double.isNaN(doublep2.getDouble())) {
+ return false;
+ }
return (aOp1.operateDoubleDouble(doublep1, doublep2) || aOp2.operateDoubleDouble(doublep1, doublep2));
}
@Override
public boolean operateDoubleFloat(DoublePointable doublep1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble()) || Float.isNaN(floatp2.getFloat())) {
+ return false;
+ }
return (aOp1.operateDoubleFloat(doublep1, floatp2) || aOp2.operateDoubleFloat(doublep1, floatp2));
}
@Override
public boolean operateDoubleInteger(DoublePointable doublep1, LongPointable longp2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble())) {
+ return false;
+ }
return (aOp1.operateDoubleInteger(doublep1, longp2) || aOp2.operateDoubleInteger(doublep1, longp2));
}
@@ -143,24 +161,36 @@ public abstract class AbstractDisjunctiv
@Override
public boolean operateFloatDecimal(FloatPointable floatp1, XSDecimalPointable decp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat())) {
+ return false;
+ }
return (aOp1.operateFloatDecimal(floatp1, decp2) || aOp2.operateFloatDecimal(floatp1, decp2));
}
@Override
public boolean operateFloatDouble(FloatPointable floatp1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat()) || Double.isNaN(doublep2.doubleValue())) {
+ return false;
+ }
return (aOp1.operateFloatDouble(floatp1, doublep2) || aOp2.operateFloatDouble(floatp1, doublep2));
}
@Override
public boolean operateFloatFloat(FloatPointable floatp1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat()) || Float.isNaN(floatp2.getFloat())) {
+ return false;
+ }
return (aOp1.operateFloatFloat(floatp1, floatp2) || aOp2.operateFloatFloat(floatp1, floatp2));
}
@Override
public boolean operateFloatInteger(FloatPointable floatp1, LongPointable longp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat())) {
+ return false;
+ }
return (aOp1.operateFloatInteger(floatp1, longp2) || aOp2.operateFloatInteger(floatp1, longp2));
}
@@ -212,12 +242,18 @@ public abstract class AbstractDisjunctiv
@Override
public boolean operateIntegerDouble(LongPointable longp1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep2.doubleValue())) {
+ return false;
+ }
return (aOp1.operateIntegerDouble(longp1, doublep2) || aOp2.operateIntegerDouble(longp1, doublep2));
}
@Override
public boolean operateIntegerFloat(LongPointable longp1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp2.floatValue())) {
+ return false;
+ }
return (aOp1.operateIntegerFloat(longp1, floatp2) || aOp2.operateIntegerFloat(longp1, floatp2));
}
Modified: incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java?rev=1377170&r1=1377169&r2=1377170&view=diff
==============================================================================
--- incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java (original)
+++ incubator/vxquery/trunk/vxquery/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java Sat Aug 25 01:04:15 2012
@@ -63,12 +63,18 @@ public abstract class AbstractNegatingCo
@Override
public boolean operateDecimalDouble(XSDecimalPointable decp1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep2.getDouble())) {
+ return false;
+ }
return !aOp.operateDecimalDouble(decp1, doublep2);
}
@Override
public boolean operateDecimalFloat(XSDecimalPointable decp1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp2.getFloat())) {
+ return false;
+ }
return !aOp.operateDecimalFloat(decp1, floatp2);
}
@@ -81,24 +87,36 @@ public abstract class AbstractNegatingCo
@Override
public boolean operateDoubleDecimal(DoublePointable doublep1, XSDecimalPointable decp2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble())) {
+ return false;
+ }
return !aOp.operateDoubleDecimal(doublep1, decp2);
}
@Override
public boolean operateDoubleDouble(DoublePointable doublep1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble()) || Double.isNaN(doublep2.getDouble())) {
+ return false;
+ }
return !aOp.operateDoubleDouble(doublep1, doublep2);
}
@Override
public boolean operateDoubleFloat(DoublePointable doublep1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble()) || Float.isNaN(floatp2.getFloat())) {
+ return false;
+ }
return !aOp.operateDoubleFloat(doublep1, floatp2);
}
@Override
public boolean operateDoubleInteger(DoublePointable doublep1, LongPointable longp2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep1.getDouble())) {
+ return false;
+ }
return !aOp.operateDoubleInteger(doublep1, longp2);
}
@@ -135,24 +153,36 @@ public abstract class AbstractNegatingCo
@Override
public boolean operateFloatDecimal(FloatPointable floatp1, XSDecimalPointable decp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat())) {
+ return false;
+ }
return !aOp.operateFloatDecimal(floatp1, decp2);
}
@Override
public boolean operateFloatDouble(FloatPointable floatp1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat()) || Double.isNaN(doublep2.doubleValue())) {
+ return false;
+ }
return !aOp.operateFloatDouble(floatp1, doublep2);
}
@Override
public boolean operateFloatFloat(FloatPointable floatp1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat()) || Float.isNaN(floatp2.getFloat())) {
+ return false;
+ }
return !aOp.operateFloatFloat(floatp1, floatp2);
}
@Override
public boolean operateFloatInteger(FloatPointable floatp1, LongPointable longp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp1.getFloat())) {
+ return false;
+ }
return !aOp.operateFloatInteger(floatp1, longp2);
}
@@ -201,12 +231,18 @@ public abstract class AbstractNegatingCo
@Override
public boolean operateIntegerDouble(LongPointable longp1, DoublePointable doublep2) throws SystemException,
IOException {
+ if (Double.isNaN(doublep2.doubleValue())) {
+ return false;
+ }
return !aOp.operateIntegerDouble(longp1, doublep2);
}
@Override
public boolean operateIntegerFloat(LongPointable longp1, FloatPointable floatp2) throws SystemException,
IOException {
+ if (Float.isNaN(floatp2.floatValue())) {
+ return false;
+ }
return !aOp.operateIntegerFloat(longp1, floatp2);
}