[jboss-svn-commits] JBL Code SVN: r26571 - in labs/jbossrules/trunk: drools-compiler/src/test/java/org/drools/integrationtests and 3 other directories.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Fri May 15 17:58:03 EDT 2009
Author: mark.proctor at jboss.com
Date: 2009-05-15 17:58:03 -0400 (Fri, 15 May 2009)
New Revision: 26571
Added:
labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/ArrayContainsTest.java
Modified:
labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/Primitives.java
labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/MiscTest.java
labs/jbossrules/trunk/drools-core/src/main/java/org/drools/base/evaluators/SetEvaluatorsDefinition.java
labs/jbossrules/trunk/drools-core/src/main/java/org/drools/rule/VariableRestriction.java
labs/jbossrules/trunk/drools-core/src/main/java/org/drools/spi/GlobalExtractor.java
Log:
JBRULES-1954 Issue with using contains operator on array or collection of double (any )
Modified: labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/Primitives.java
===================================================================
--- labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/Primitives.java 2009-05-15 18:46:31 UTC (rev 26570)
+++ labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/Primitives.java 2009-05-15 21:58:03 UTC (rev 26571)
@@ -19,29 +19,38 @@
* limitations under the License.
*/
-public class Primitives implements Serializable {
+public class Primitives
+ implements
+ Serializable {
private static final long serialVersionUID = -3006488134941876318L;
- private boolean booleanPrimitive;
+ private boolean booleanPrimitive;
- private char charPrimitive;
+ private char charPrimitive;
- private byte bytePrimitive;
- private short shortPrimitive;
- private int intPrimitive;
- private long longPrimitive;
+ private byte bytePrimitive;
+ private short shortPrimitive;
+ private int intPrimitive;
+ private long longPrimitive;
- private float floatPrimitive;
- private float doublePrimitive;
- private String stringAttribute;
- private Object[] arrayAttribute;
- private int[] primitiveArrayAttribute;
- private String[] stringArray;
+ private float floatPrimitive;
+ private double doublePrimitive;
+ private String stringAttribute;
+ private Object[] arrayAttribute;
+ private boolean[] primitiveBooleanArray;
+ private byte[] primitiveByteArray;
+ private short[] primitiveShortArray;
+ private char[] primitiveCharArray;
+ private int[] primitiveIntArray;
+ private long[] primitiveLongArray;
+ private float[] primitiveFloatArray;
+ private double[] primitiveDoubleArray;
+ private String[] stringArray;
- private Boolean booleanWrapper;
+ private Boolean booleanWrapper;
- private Object object;
+ private Object object;
public boolean isBooleanPrimitive() {
return this.booleanPrimitive;
@@ -67,11 +76,11 @@
this.charPrimitive = charPrimitive;
}
- public float getDoublePrimitive() {
+ public double getDoublePrimitive() {
return this.doublePrimitive;
}
- public void setDoublePrimitive(final float doublePrimitive) {
+ public void setDoublePrimitive(final double doublePrimitive) {
this.doublePrimitive = doublePrimitive;
}
@@ -113,22 +122,78 @@
public void setArrayAttribute(final Object[] arrayAttribute) {
this.arrayAttribute = arrayAttribute;
+ }
+
+ public boolean[] getPrimitiveBooleanArray() {
+ return primitiveBooleanArray;
}
+ public void setPrimitiveBooleanArray(boolean[] primitiveBooleanArray) {
+ this.primitiveBooleanArray = primitiveBooleanArray;
+ }
+
+ public byte[] getPrimitiveByteArray() {
+ return primitiveByteArray;
+ }
+
+ public void setPrimitiveByteArray(byte[] primitiveByteArray) {
+ this.primitiveByteArray = primitiveByteArray;
+ }
+
+ public short[] getPrimitiveShortArray() {
+ return primitiveShortArray;
+ }
+
+ public void setPrimitiveShortArray(short[] primitiveShortArray) {
+ this.primitiveShortArray = primitiveShortArray;
+ }
+
+ public char[] getPrimitiveCharArray() {
+ return primitiveCharArray;
+ }
+
+ public void setPrimitiveCharArray(char[] primitiveCharArray) {
+ this.primitiveCharArray = primitiveCharArray;
+ }
+
/**
* @return the primitiveArrayAttribute
*/
- public int[] getPrimitiveArrayAttribute() {
- return this.primitiveArrayAttribute;
+ public int[] getPrimitiveIntArray() {
+ return this.primitiveIntArray;
}
/**
* @param primitiveArrayAttribute the primitiveArrayAttribute to set
*/
- public void setPrimitiveArrayAttribute(final int[] primitiveArrayAttribute) {
- this.primitiveArrayAttribute = primitiveArrayAttribute;
+ public void setPrimitiveIntArray(final int[] primitiveArrayAttribute) {
+ this.primitiveIntArray = primitiveArrayAttribute;
}
+ public long[] getPrimitiveLongArray() {
+ return primitiveLongArray;
+ }
+
+ public void setPrimitiveLongArray(long[] primitiveLongArray) {
+ this.primitiveLongArray = primitiveLongArray;
+ }
+
+ public float[] getPrimitiveFloatArray() {
+ return primitiveFloatArray;
+ }
+
+ public void setPrimitiveFloatArray(float[] floatDoubleArray) {
+ this.primitiveFloatArray = floatDoubleArray;
+ }
+
+ public double[] getPrimitiveDoubleArray() {
+ return primitiveDoubleArray;
+ }
+
+ public void setPrimitiveDoubleArray(double[] primitiveDoubleArrayAttribute) {
+ this.primitiveDoubleArray = primitiveDoubleArrayAttribute;
+ }
+
public String[] getStringArray() {
return stringArray;
}
@@ -168,12 +233,14 @@
result = prime * result + (booleanPrimitive ? 1231 : 1237);
result = prime * result + ((booleanWrapper == null) ? 0 : booleanWrapper.hashCode());
result = prime * result + charPrimitive;
- result = prime * result + Float.floatToIntBits( doublePrimitive );
+ long doubeAsLongBits = Double.doubleToLongBits( doublePrimitive );
+ result = prime * result + (int) (doubeAsLongBits ^ (doubeAsLongBits >>> 32));
result = prime * result + Float.floatToIntBits( floatPrimitive );
result = prime * result + intPrimitive;
result = prime * result + (int) (longPrimitive ^ (longPrimitive >>> 32));
result = prime * result + ((object == null) ? 0 : object.hashCode());
- result = prime * result + Arrays.hashCode( primitiveArrayAttribute );
+ result = prime * result + Arrays.hashCode( primitiveIntArray );
+ result = prime * result + Arrays.hashCode( primitiveDoubleArray );
result = prime * result + shortPrimitive;
result = prime * result + Arrays.hashCode( stringArray );
result = prime * result + ((stringAttribute == null) ? 0 : stringAttribute.hashCode());
@@ -193,15 +260,17 @@
} else if ( !booleanWrapper.equals( other.booleanWrapper ) ) return false;
if ( bytePrimitive != other.bytePrimitive ) return false;
if ( charPrimitive != other.charPrimitive ) return false;
- if ( Float.floatToIntBits( doublePrimitive ) != Float.floatToIntBits( other.doublePrimitive ) ) return false;
+ if ( Double.doubleToLongBits( doublePrimitive ) != Double.doubleToLongBits( other.doublePrimitive ) ) return false;
if ( Float.floatToIntBits( floatPrimitive ) != Float.floatToIntBits( other.floatPrimitive ) ) return false;
if ( intPrimitive != other.intPrimitive ) return false;
if ( longPrimitive != other.longPrimitive ) return false;
if ( object == null ) {
if ( other.object != null ) return false;
} else if ( !object.equals( other.object ) ) return false;
- if ( !Arrays.equals( primitiveArrayAttribute,
- other.primitiveArrayAttribute ) ) return false;
+ if ( !Arrays.equals( primitiveIntArray,
+ other.primitiveIntArray ) ) return false;
+ if ( !Arrays.equals( primitiveDoubleArray,
+ other.primitiveDoubleArray ) ) return false;
if ( shortPrimitive != other.shortPrimitive ) return false;
if ( !Arrays.equals( stringArray,
other.stringArray ) ) return false;
@@ -211,6 +280,4 @@
return true;
}
-
-
}
\ No newline at end of file
Added: labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/ArrayContainsTest.java
===================================================================
--- labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/ArrayContainsTest.java (rev 0)
+++ labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/ArrayContainsTest.java 2009-05-15 21:58:03 UTC (rev 26571)
@@ -0,0 +1,491 @@
+package org.drools.integrationtests;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.drools.KnowledgeBase;
+import org.drools.KnowledgeBaseFactory;
+import org.drools.Primitives;
+import org.drools.builder.KnowledgeBuilder;
+import org.drools.builder.KnowledgeBuilderFactory;
+import org.drools.builder.ResourceType;
+import org.drools.io.ResourceFactory;
+import org.drools.runtime.StatefulKnowledgeSession;
+import org.drools.runtime.rule.FactHandle;
+
+import junit.framework.TestCase;
+
+public class ArrayContainsTest extends TestCase {
+ public void testContainsBooleanArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Boolean bGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $b : booleanPrimitive == true ) \n";
+ str += " Primitives( booleanPrimitive == false, primitiveBooleanArray contains bGlobal, primitiveBooleanArray contains $b )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "bGlobal",
+ true );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveBooleanArray( new boolean[]{true, false} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setBooleanPrimitive( true );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsByteArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Byte bGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $b : bytePrimitive == 1 ) \n";
+ str += " Primitives( bytePrimitive != 1, primitiveByteArray contains bGlobal, primitiveByteArray contains $b )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "bGlobal",
+ (byte) 1 );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveByteArray( new byte[]{1, 2, 3} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setBytePrimitive( (byte) 1 );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsShortArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Short sGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $s : shortPrimitive == 1 ) \n";
+ str += " Primitives( shortPrimitive != 1, primitiveShortArray contains sGlobal, primitiveShortArray contains $s )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "sGlobal",
+ (short) 1 );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveShortArray( new short[]{1, 2, 3} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setShortPrimitive( (short) 1 );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsCharArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Character cGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $c : charPrimitive == 'c' ) \n";
+ str += " Primitives( charPrimitive != 'c', primitiveCharArray contains cGlobal, primitiveCharArray contains $c )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "cGlobal",
+ 'c' );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveCharArray( new char[]{ 'a', 'b', 'c'} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setCharPrimitive( 'c' );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsIntArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Integer iGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $i : intPrimitive == 10 ) \n";
+ str += " Primitives( intPrimitive != 10, primitiveIntArray contains iGlobal, primitiveIntArray contains $i )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "iGlobal",
+ 10 );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveIntArray( new int[]{ 5, 10, 20} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setIntPrimitive( 10 );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsLongArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Long lGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $l : longPrimitive == 10 ) \n";
+ str += " Primitives( longPrimitive != 10, primitiveLongArray contains lGlobal, primitiveLongArray contains $l )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "lGlobal",
+ 10l );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveLongArray( new long[]{ 5, 10, 20} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setLongPrimitive( 10 );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsFloatArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Float fGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $f : floatPrimitive == 10 ) \n";
+ str += " Primitives( floatPrimitive != 10, primitiveFloatArray contains fGlobal, primitiveFloatArray contains $f )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "fGlobal",
+ 10.0f );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveFloatArray( new float[]{ 5f, 10f, 20f} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setFloatPrimitive( 10f );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+ public void testContainsDoubleArray() throws Exception {
+ String str = "";
+ str += "package org.drools;\n";
+
+ str += "global java.util.List list;\n";
+ str += "global Double dGlobal;\n";
+
+ str += "rule \"contains in array\"\n";
+ str += " salience 10\n";
+ str += " when\n";
+ str += " Primitives( $d : doublePrimitive == 10 ) \n";
+ str += " Primitives( doublePrimitive != 10, primitiveDoubleArray contains dGlobal, primitiveDoubleArray contains $d )\n";
+ str += " then\n";
+ str += " list.add( \"ok1\" );\n";
+ str += "end\n";
+
+ final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
+ kbuilder.add( ResourceFactory.newByteArrayResource( str.getBytes() ), ResourceType.DRL );
+
+ if ( kbuilder.hasErrors() ) {
+ fail( "kbuilder has errors\n:" + kbuilder.getErrors() );
+ }
+
+ KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
+ kbase.addKnowledgePackages( kbuilder.getKnowledgePackages() );
+
+ kbase = SerializationHelper.serializeObject( kbase );
+ final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
+
+ final List list = new ArrayList();
+ ksession.setGlobal( "list",
+ list );
+
+ ksession.setGlobal( "dGlobal",
+ 10.0d );
+
+ final Primitives p1 = new Primitives();
+ p1.setPrimitiveDoubleArray( new double[]{ 5, 10, 20} );
+ FactHandle p1h = ksession.insert( p1 );
+
+ final Primitives p2 = new Primitives();
+ p2.setDoublePrimitive( 10 );
+ ksession.insert( p2 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 1,
+ list.size() );
+
+ ksession.retract( p1h );
+
+ ksession.insert( p1 );
+
+ ksession.fireAllRules();
+
+ assertEquals( 2,
+ list.size() );
+ }
+
+}
Modified: labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/MiscTest.java
===================================================================
--- labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/MiscTest.java 2009-05-15 18:46:31 UTC (rev 26570)
+++ labs/jbossrules/trunk/drools-compiler/src/test/java/org/drools/integrationtests/MiscTest.java 2009-05-15 21:58:03 UTC (rev 26571)
@@ -319,7 +319,7 @@
result );
final Primitives p1 = new Primitives();
- p1.setPrimitiveArrayAttribute( new int[]{1, 2, 3} );
+ p1.setPrimitiveIntArray( new int[]{1, 2, 3} );
p1.setArrayAttribute( new String[]{"a", "b"} );
session.insert( p1 );
@@ -4202,7 +4202,9 @@
assertEquals( "ok2",
list.get( 1 ) );
}
+
+
public void testNodeSharingNotExists() throws Exception {
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream( "test_nodeSharingNotExists.drl" ) ) );
Modified: labs/jbossrules/trunk/drools-core/src/main/java/org/drools/base/evaluators/SetEvaluatorsDefinition.java
===================================================================
--- labs/jbossrules/trunk/drools-core/src/main/java/org/drools/base/evaluators/SetEvaluatorsDefinition.java 2009-05-15 18:46:31 UTC (rev 26570)
+++ labs/jbossrules/trunk/drools-core/src/main/java/org/drools/base/evaluators/SetEvaluatorsDefinition.java 2009-05-15 21:58:03 UTC (rev 26571)
@@ -21,10 +21,13 @@
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
import org.drools.base.BaseEvaluator;
import org.drools.base.ValueType;
import org.drools.common.InternalWorkingMemory;
+import org.drools.rule.VariableRestriction.DoubleVariableContextEntry;
import org.drools.rule.VariableRestriction.ObjectVariableContextEntry;
import org.drools.rule.VariableRestriction.VariableContextEntry;
import org.drools.spi.Evaluator;
@@ -255,9 +258,9 @@
parameterText,
Target.FACT,
Target.FACT );
-
+
}
-
+
/**
* @inheritDoc
*/
@@ -266,7 +269,7 @@
final boolean isNegated,
final String parameterText,
final Target left,
- final Target right ) {
+ final Target right) {
return this.evaluators.getEvaluator( type,
Operator.determineOperator( operatorId,
isNegated ) );
@@ -288,6 +291,27 @@
return this.evaluators.supportsType( type );
}
+ private static Map<Class, PrimitiveArrayContainsEvaluator> primitiveArrayEvaluator = new HashMap() {
+ {
+ put( boolean[].class,
+ new BooleanArrayContainsEvaluator() );
+ put( byte[].class,
+ new ByteArrayContainsEvaluator() );
+ put( short[].class,
+ new ShortArrayContainsEvaluator() );
+ put( char[].class,
+ new CharArrayContainsEvaluator() );
+ put( int[].class,
+ new IntegerArrayContainsEvaluator() );
+ put( long[].class,
+ new LongArrayContainsEvaluator() );
+ put( float[].class,
+ new FloatArrayContainsEvaluator() );
+ put( double[].class,
+ new DoubleArrayContainsEvaluator() );
+ }
+ };
+
/* *********************************************************
* Evaluator Implementations
* *********************************************************
@@ -306,34 +330,42 @@
final InternalReadAccessor extractor,
final Object object1,
final FieldValue object2) {
- final Object value = object2.getValue();
- final Object[] array = (Object[]) extractor.getValue( workingMemory,
- object1 );
+ final Object array = extractor.getValue( workingMemory,
+ object1 );
+
if ( array == null ) return false;
- return contains( array,
- value );
+
+ return primitiveArrayEvaluator.get( array.getClass() ).contains( array,
+ object2,
+ true );
}
public boolean evaluateCachedRight(InternalWorkingMemory workingMemory,
final VariableContextEntry context,
final Object left) {
- final Object value = context.declaration.getExtractor().getValue( workingMemory,
- left );
- final Object[] array = (Object[]) ((ObjectVariableContextEntry) context).right;
+ final Object array = ((ObjectVariableContextEntry) context).right;
if ( array == null ) return false;
- return contains( array,
- value );
+
+ return primitiveArrayEvaluator.get( array.getClass() ).contains( array,
+ workingMemory,
+ context.declaration.getExtractor(),
+ left,
+ true );
}
public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
final VariableContextEntry context,
final Object right) {
- final Object value = ((ObjectVariableContextEntry) context).left;
- final Object[] array = (Object[]) context.extractor.getValue( workingMemory,
- right );
+ final Object array = context.extractor.getValue( workingMemory,
+ right );
+
if ( array == null ) return false;
- return contains( array,
- value );
+
+ return primitiveArrayEvaluator.get( array.getClass() ).contains( array,
+ workingMemory,
+ context.declaration.getExtractor(),
+ context.getTuple().get( context.getVariableDeclaration() ).getObject(),
+ true );
}
public boolean evaluate(InternalWorkingMemory workingMemory,
@@ -341,14 +373,16 @@
final Object object1,
final InternalReadAccessor extractor2,
final Object object2) {
- final Object value = extractor2.getValue( workingMemory,
- object2 );
- final Object[] array = (Object[]) extractor1.getValue( workingMemory,
- object1 );
+ final Object array = extractor1.getValue( workingMemory,
+ object1 );
if ( array == null ) return false;
- return contains( array,
- value );
+
+ return primitiveArrayEvaluator.get( array.getClass() ).contains( array,
+ workingMemory,
+ extractor2,
+ object2,
+ true );
}
public String toString() {
@@ -520,7 +554,7 @@
final Object value = ((ObjectVariableContextEntry) context).right;
if ( array == null ) return true;
return !SetEvaluatorsDefinition.contains( array,
- value );
+ value );
}
public boolean evaluateCachedLeft(InternalWorkingMemory workingMemory,
@@ -546,16 +580,16 @@
if ( array == null ) return true;
return !SetEvaluatorsDefinition.contains( array,
- value );
+ value );
}
public String toString() {
return "Array not memberOf";
}
}
-
+
private static boolean contains(Object[] array,
- Object value) {
+ Object value) {
for ( int i = 0; i < array.length; i++ ) {
if ( array[i] == null && value == null || array[i] != null && array[i].equals( value ) ) {
return true;
@@ -1237,4 +1271,348 @@
return "String not memberOf";
}
}
+
+ public interface PrimitiveArrayContainsEvaluator {
+ Class getArrayType();
+
+ boolean contains(Object array,
+ FieldValue value,
+ boolean negate);
+
+ boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate);
+ }
+
+ public static class BooleanArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ boolean[] boolArray = (boolean[]) array;
+
+ for ( int i = 0, length = boolArray.length; i < length; i++ ) {
+ if ( boolArray[i] == value.getBooleanValue() ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ boolean[] boolArray = (boolean[]) array;
+
+ for ( int i = 0, length = boolArray.length; i < length; i++ ) {
+ if ( boolArray[i] == accessor.getBooleanValue( workingMemory,
+ object ) ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ private boolean contains(byte[] array,
+ byte value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+
+ public Class getArrayType() {
+ return boolean[].class;
+ }
+
+ }
+
+ public static class ByteArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ return contains( (byte[]) array, value.getByteValue(), negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (byte[]) array, accessor.getByteValue( workingMemory,
+ object ), negate );
+ }
+
+ private boolean contains(byte[] array,
+ byte value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return byte[].class;
+ }
+
+ }
+
+ public static class ShortArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ return contains( (short[]) array, value.getShortValue(), negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (short[]) array, accessor.getShortValue( workingMemory,
+ object ), negate );
+ }
+
+ private boolean contains(short[] array,
+ short value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return short[].class;
+ }
+ }
+
+ public static class CharArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ return contains( (char[]) array,
+ value.getCharValue(),
+ negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (char[]) array,
+ accessor.getCharValue( workingMemory,
+ object ),
+ negate );
+ }
+
+ private boolean contains(char[] array,
+ char value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return char[].class;
+ }
+
+ }
+
+ public static class IntegerArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ return contains( (int[]) array,
+ value.getIntValue(),
+ negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (int[]) array,
+ accessor.getIntValue( workingMemory,
+ object ),
+ negate );
+ }
+
+ private boolean contains(int[] array,
+ int value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return int[].class;
+ }
+
+ }
+
+ public static class LongArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ return contains( (long[]) array,
+ value.getLongValue(),
+ negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (long[]) array,
+ accessor.getLongValue( workingMemory,
+ object ),
+ negate );
+ }
+
+ private boolean contains(long[] array,
+ long value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return long[].class;
+ }
+
+ }
+
+ public static class FloatArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue value,
+ boolean negate) {
+ return contains( (float[]) array,
+ value.getFloatValue(),
+ negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (float[]) array,
+ accessor.getFloatValue( workingMemory,
+ object ),
+ negate );
+ }
+
+ private boolean contains(float[] array,
+ float value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return float[].class;
+ }
+ }
+
+ public static class DoubleArrayContainsEvaluator
+ implements
+ PrimitiveArrayContainsEvaluator {
+
+ public boolean contains(Object array,
+ FieldValue fieldValue,
+ boolean negate) {
+ return contains( (double[]) array,
+ fieldValue.getDoubleValue(),
+ negate );
+ }
+
+ public boolean contains(Object array,
+ InternalWorkingMemory workingMemory,
+ InternalReadAccessor accessor,
+ Object object,
+ boolean negate) {
+ return contains( (double[]) array,
+ accessor.getDoubleValue( workingMemory,
+ object ),
+ negate );
+ }
+
+ private boolean contains(double[] array,
+ double value,
+ boolean negate) {
+ for ( int i = 0, length = array.length; i < length; i++ ) {
+ if ( array[i] == value ) {
+ return negate == true;
+ }
+ }
+
+ return negate == false;
+ }
+
+ public Class getArrayType() {
+ return double[].class;
+ }
+ }
}
Modified: labs/jbossrules/trunk/drools-core/src/main/java/org/drools/rule/VariableRestriction.java
===================================================================
--- labs/jbossrules/trunk/drools-core/src/main/java/org/drools/rule/VariableRestriction.java 2009-05-15 18:46:31 UTC (rev 26570)
+++ labs/jbossrules/trunk/drools-core/src/main/java/org/drools/rule/VariableRestriction.java 2009-05-15 21:58:03 UTC (rev 26571)
@@ -343,7 +343,67 @@
this.object = null;
}
}
+
+ public static class PrimitiveArrayVariableContextEntry extends VariableContextEntry {
+ private static final long serialVersionUID = 400L;
+ public Object left;
+ public Object right;
+
+ public PrimitiveArrayVariableContextEntry() {
+ }
+
+ public PrimitiveArrayVariableContextEntry(final InternalReadAccessor extractor,
+ final Declaration declaration,
+ final Evaluator evaluator) {
+ super( extractor,
+ declaration,
+ evaluator );
+ }
+
+ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
+ super.readExternal(in);
+ left = in.readObject();
+ right = in.readObject();
+ }
+
+ public void writeExternal(ObjectOutput out) throws IOException {
+ super.writeExternal(out);
+ out.writeObject(left);
+ out.writeObject(right);
+ }
+
+ public void updateFromTuple(final InternalWorkingMemory workingMemory,
+ final LeftTuple tuple) {
+ this.reteTuple = tuple;
+ this.workingMemory = workingMemory;
+ this.leftNull = this.declaration.getExtractor().isNullValue( workingMemory,
+ evaluator.prepareLeftObject( tuple.get( this.declaration ) ) );
+ this.left = this.declaration.getExtractor().getValue( workingMemory,
+ evaluator.prepareLeftObject( tuple.get( this.declaration ) ) );
+ }
+
+ public void updateFromFactHandle(final InternalWorkingMemory workingMemory,
+ final InternalFactHandle handle) {
+ this.object = evaluator.prepareLeftObject( handle );
+ this.workingMemory = workingMemory;
+ this.rightNull = this.extractor.isNullValue( workingMemory,
+ evaluator.prepareRightObject( handle ) );
+ this.right = this.extractor.getValue( workingMemory,
+ evaluator.prepareRightObject( handle ) );
+ }
+
+ public void resetTuple() {
+ this.left = null;
+ this.reteTuple = null;
+ }
+
+ public void resetFactHandle() {
+ this.right = null;
+ this.object = null;
+ }
+ }
+
public static class LongVariableContextEntry extends VariableContextEntry {
private static final long serialVersionUID = 400L;
Modified: labs/jbossrules/trunk/drools-core/src/main/java/org/drools/spi/GlobalExtractor.java
===================================================================
--- labs/jbossrules/trunk/drools-core/src/main/java/org/drools/spi/GlobalExtractor.java 2009-05-15 18:46:31 UTC (rev 26570)
+++ labs/jbossrules/trunk/drools-core/src/main/java/org/drools/spi/GlobalExtractor.java 2009-05-15 21:58:03 UTC (rev 26571)
@@ -43,18 +43,15 @@
private static final long serialVersionUID = 400L;
private String identifier;
- private ValueType valueType;
private ObjectType objectType;
public GlobalExtractor() {
-
}
public GlobalExtractor(final String identifier,
final ObjectType objectType) {
this.identifier = identifier;
this.objectType = objectType;
- this.valueType = objectType.getValueType();
}
public Object getValue(InternalWorkingMemory workingMemory, final Object object) {
@@ -71,7 +68,6 @@
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
identifier = in.readUTF();
objectType = ( ObjectType) in.readObject();
- valueType = objectType.getValueType();
}
public void setClassObjectType(ClassObjectType objectType) {
@@ -83,7 +79,7 @@
if ( objectType instanceof ClassObjectType ) {
return ((ClassObjectType)objectType).getClassType();
} else {
- return valueType.getClassType();
+ return objectType.getValueType().getClassType();
}
}
@@ -91,65 +87,65 @@
if ( objectType instanceof ClassObjectType ) {
return ((ClassObjectType)objectType).getClassName();
} else {
- return valueType.getClassType().getName();
+ return objectType.getValueType().getClassType().getName();
}
}
public ValueType getValueType() {
- return valueType;
+ return objectType.getValueType();
}
public boolean getBooleanValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isBoolean() ) {
+ if( this.objectType.getValueType().isBoolean() ) {
return ((Boolean) workingMemory.getGlobal( identifier )).booleanValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a boolean.");
}
public byte getByteValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isNumber() ) {
+ if( this.objectType.getValueType().isNumber() ) {
return ((Number) workingMemory.getGlobal( identifier )).byteValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a byte.");
}
public char getCharValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isChar() ) {
+ if( this.objectType.getValueType().isChar() ) {
return ((Character) workingMemory.getGlobal( identifier )).charValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a char.");
}
public double getDoubleValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isNumber() ) {
+ if( this.objectType.getValueType().isNumber() ) {
return ((Number) workingMemory.getGlobal( identifier )).doubleValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a double.");
}
public float getFloatValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isNumber() ) {
+ if( this.objectType.getValueType().isNumber() ) {
return ((Number) workingMemory.getGlobal( identifier )).floatValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a float.");
}
public int getIntValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isNumber() ) {
+ if( this.objectType.getValueType().isNumber() ) {
return ((Number) workingMemory.getGlobal( identifier )).intValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into an int.");
}
public long getLongValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isNumber() ) {
+ if( this.objectType.getValueType().isNumber() ) {
return ((Number) workingMemory.getGlobal( identifier )).longValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a long.");
}
public short getShortValue(InternalWorkingMemory workingMemory, final Object object) {
- if( this.valueType.isNumber() ) {
+ if( this.objectType.getValueType().isNumber() ) {
return ((Number) workingMemory.getGlobal( identifier )).shortValue();
}
throw new ClassCastException("Not possible to convert global '"+identifier+"' into a short.");
More information about the jboss-svn-commits
mailing list