Author: mar...@jb... Date: 2006-01-02 00:24:21 -0500 (Mon, 02 Jan 2006) New Revision: 1970 Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/rule/EvaluatorFactory.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/AssertedObjectTransformer.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/BetaNodeConstraint.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ClassObjectTypeResolver.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Evaluator.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Field.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/FieldExtractor.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ObjectTypeResolver.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/PredicateEvaluator.java trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ReturnValueEvaluator.java trunk/labs/jbossrules/drools-core/src/test/java/org/drools/Cheese.java trunk/labs/jbossrules/drools-core/src/test/java/org/drools/examples/manners/MannersTest.java trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/ClassFieldExtractor.java trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/MockField.java Log: -Refactored Constraint model to be simpler and more specific Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/rule/EvaluatorFactory.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/rule/EvaluatorFactory.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/rule/EvaluatorFactory.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,373 @@ +package org.drools.rule; + +import org.drools.spi.Evaluator; +import org.drools.spi.BaseEvaluator; + +public class EvaluatorFactory { + private static final EvaluatorFactory INSTANCE = new EvaluatorFactory(); + + public static EvaluatorFactory getInstance() { + return EvaluatorFactory.INSTANCE; + } + + private EvaluatorFactory() { + + } + + public Evaluator getEvaluator(int type, + int operator) { + switch ( type ) { + case Evaluator.OBJECT_TYPE : + return getObjectEvaluator( operator ); + case Evaluator.SHORT_TYPE : + return getShortEvaluator( operator ); + case Evaluator.INTEGER_TYPE : + return getIntegerEvaluator( operator ); + default : + throw new RuntimeException( "Type '" + type + "' does not exist for BaseEvaluatorFactory" ); + } + } + + Evaluator getObjectEvaluator(int operator) { + switch ( operator ) { + case Evaluator.EQUAL : + return ObjectEqualEvaluator.getInstance(); + case Evaluator.NOT_EQUAL : + return ObjectNotEqualEvaluator.getInstance(); + default : + throw new RuntimeException( "Operator '" + operator + "' does not exist for ObjectEvaluator" ); + } + } + + static class ObjectEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ObjectEqualEvaluator(); + } + return INSTANCE; + } + + private ObjectEqualEvaluator() { + super( Evaluator.OBJECT_TYPE, + Evaluator.EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return object1.equals( object2 ); + } + } + + static class ObjectNotEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ObjectNotEqualEvaluator(); + } + return INSTANCE; + } + + private ObjectNotEqualEvaluator() { + super( Evaluator.OBJECT_TYPE, + Evaluator.NOT_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return !object1.equals( object2 ); + } + } + + Evaluator getShortEvaluator(int operator) { + switch ( operator ) { + case Evaluator.EQUAL : + return ShortEqualEvaluator.getInstance(); + case Evaluator.NOT_EQUAL : + return ShortNotEqualEvaluator.getInstance(); + case Evaluator.LESS : + return ShortLessEvaluator.getInstance(); + case Evaluator.LESS_OR_EQUAL : + return ShortLessOrEqualEvaluator.getInstance(); + case Evaluator.GREATER : + return ShortGreaterEvaluator.getInstance(); + case Evaluator.GREATER_OR_EQUAL : + return ShortGreaterOrEqualEvaluator.getInstance(); + default : + throw new RuntimeException( "Operator '" + operator + "' does not exist for BooleanEvaluator" ); + } + } + + static class ShortEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ShortEqualEvaluator(); + } + return INSTANCE; + } + + private ShortEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).shortValue() == ((Number) object2).shortValue(); + } + } + + static class ShortNotEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ShortNotEqualEvaluator(); + } + return INSTANCE; + } + + private ShortNotEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.NOT_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).shortValue() != ((Number) object2).shortValue(); + } + } + + static class ShortLessEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ShortLessEvaluator(); + } + return INSTANCE; + } + + private ShortLessEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.LESS ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).shortValue() < ((Number) object2).shortValue(); + } + } + + static class ShortLessOrEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ShortLessOrEqualEvaluator(); + } + return INSTANCE; + } + + private ShortLessOrEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.LESS_OR_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).shortValue() <= ((Number) object2).shortValue(); + } + } + + static class ShortGreaterEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ShortGreaterEvaluator(); + } + return INSTANCE; + } + + private ShortGreaterEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.GREATER ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).shortValue() > ((Number) object2).shortValue(); + } + } + + static class ShortGreaterOrEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new ShortGreaterOrEqualEvaluator(); + } + return INSTANCE; + } + + private ShortGreaterOrEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.GREATER_OR_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).shortValue() >= ((Number) object2).shortValue(); + } + } + + Evaluator getIntegerEvaluator(int operator) { + switch ( operator ) { + case Evaluator.EQUAL : + return IntegerEqualEvaluator.getInstance(); + case Evaluator.NOT_EQUAL : + return IntegerNotEqualEvaluator.getInstance(); + case Evaluator.LESS : + return IntegerLessEvaluator.getInstance(); + case Evaluator.LESS_OR_EQUAL : + return IntegerLessOrEqualEvaluator.getInstance(); + case Evaluator.GREATER : + return IntegerGreaterEvaluator.getInstance(); + case Evaluator.GREATER_OR_EQUAL : + return IntegerGreaterOrEqualEvaluator.getInstance(); + default : + throw new RuntimeException( "Operator '" + operator + "' does not exist for BooleanEvaluator" ); + } + } + + static class IntegerEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new IntegerEqualEvaluator(); + } + return INSTANCE; + } + + private IntegerEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).intValue() == ((Number) object2).intValue(); + } + } + + static class IntegerNotEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new IntegerNotEqualEvaluator(); + } + return INSTANCE; + } + + private IntegerNotEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.NOT_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).intValue() != ((Number) object2).intValue(); + } + } + + static class IntegerLessEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new IntegerLessEvaluator(); + } + return INSTANCE; + } + + private IntegerLessEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.LESS ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).intValue() < ((Number) object2).intValue(); + } + } + + static class IntegerLessOrEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new IntegerLessOrEqualEvaluator(); + } + return INSTANCE; + } + + private IntegerLessOrEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.LESS_OR_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).intValue() <= ((Number) object2).intValue(); + } + } + + static class IntegerGreaterEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new IntegerGreaterEvaluator(); + } + return INSTANCE; + } + + private IntegerGreaterEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.GREATER ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).intValue() > ((Number) object2).intValue(); + } + } + + static class IntegerGreaterOrEqualEvaluator extends BaseEvaluator { + private static Evaluator INSTANCE; + + public static Evaluator getInstance() { + if ( INSTANCE == null ) { + INSTANCE = new IntegerGreaterOrEqualEvaluator(); + } + return INSTANCE; + } + + private IntegerGreaterOrEqualEvaluator() { + super( Evaluator.SHORT_TYPE, + Evaluator.GREATER_OR_EQUAL ); + } + + public boolean evaluate(Object object1, + Object object2) { + return ((Number) object1).intValue() >= ((Number) object2).intValue(); + } + } +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/AssertedObjectTransformer.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/AssertedObjectTransformer.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/AssertedObjectTransformer.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,5 @@ +package org.drools.spi; + +public interface AssertedObjectTransformer { + Object transform(Object object); +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/BetaNodeConstraint.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/BetaNodeConstraint.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/BetaNodeConstraint.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,13 @@ +package org.drools.spi; + +import org.drools.FactHandle; +import org.drools.rule.Declaration; + +public interface BetaNodeConstraint extends Constraint { + public boolean isAllowed(Object object, + FactHandle handle, + Tuple tuple); + + Declaration[] getRequiredDeclarations(); + +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ClassObjectTypeResolver.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ClassObjectTypeResolver.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ClassObjectTypeResolver.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,28 @@ +package org.drools.spi; + +/** + * + * @author mproctor + * + */ +public class ClassObjectTypeResolver implements ObjectTypeResolver { + ModifieableClassObjectType objectType = new ModifieableClassObjectType( null ); + + public ObjectType resolve(Object object) { + this.objectType.setClass( object.getClass() ); + return this.objectType; + } + + + static class ModifieableClassObjectType extends ClassObjectType { + + public ModifieableClassObjectType(Class objectTypeClass) { + super( objectTypeClass ); + } + + public void setClass(Class clazz) { + this.objectTypeClass = clazz; + } + + } +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Evaluator.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Evaluator.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Evaluator.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,32 @@ +package org.drools.spi; + +public interface Evaluator { + // Operators + public static final int EQUAL = 1; + public static final int NOT_EQUAL = 10; + public static final int LESS = 20; + public static final int LESS_OR_EQUAL = 30; + public static final int GREATER = 40; + public static final int GREATER_OR_EQUAL = 50; + public static final int IS_NULL = 60; + public static final int NOT_NULL = 70; + + // Types + public static final int CHAR_TYPE = 100; + public static final int BYTE_TYPE = 110; + public static final int SHORT_TYPE = 130; + public static final int INTEGER_TYPE = 140; + public static final int LONG_TYPE = 150; + public static final int FLOAT_TYPE = 160; + public static final int DOUBLE_TYPE = 170; + public static final int DATE_TYPE = 180; + public static final int ARRAY_TYPE = 190; + public static final int OBJECT_TYPE = 195; + + public int getType(); + + public int getOperator(); + + public boolean evaluate(Object object1, + Object object2); +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Field.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Field.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/Field.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,11 @@ +package org.drools.spi; + +public interface Field { + + String getName(); + + Object getValue(); + + int getIndex(); + +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/FieldExtractor.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/FieldExtractor.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/FieldExtractor.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,8 @@ +package org.drools.spi; + +public interface FieldExtractor + extends + Extractor { + public int getIndex(); + +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ObjectTypeResolver.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ObjectTypeResolver.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ObjectTypeResolver.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,5 @@ +package org.drools.spi; + +public interface ObjectTypeResolver { + ObjectType resolve(Object object); +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/PredicateEvaluator.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/PredicateEvaluator.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/PredicateEvaluator.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,12 @@ +package org.drools.spi; + +import org.drools.FactHandle; +import org.drools.rule.Declaration; + +public interface PredicateEvaluator { + public boolean evaluate(Tuple tuple, + Object object, + FactHandle handle, + Declaration declaration, + Declaration[] requiredDeclarations); +} Added: trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ReturnValueEvaluator.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ReturnValueEvaluator.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/main/java/org/drools/spi/ReturnValueEvaluator.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,8 @@ +package org.drools.spi; + +import org.drools.rule.Declaration; + +public interface ReturnValueEvaluator { + public Object evaluate(Tuple tuple, + Declaration[] requiredDeclarations); +} Added: trunk/labs/jbossrules/drools-core/src/test/java/org/drools/Cheese.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/test/java/org/drools/Cheese.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/test/java/org/drools/Cheese.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,53 @@ +/** + * + */ +package org.drools; + +import java.beans.IntrospectionException; +import java.beans.Introspector; +import java.beans.PropertyDescriptor; + +public class Cheese { + private String type; + + private int price; + + public Cheese(String type, + int price) { + this.type = type; + this.price = price; + } + + public String getType() { + return this.type; + } + + public int getPrice() { + return this.price; + } + + public String toString() { + return "Cheese type='" + this.type + "' price='" + this.price + "'"; + } + + public boolean equals(Object object) { + if ( object == null || ! ( object instanceof Cheese) ) { + return false; + } + + Cheese other = ( Cheese ) object; + + return (this.type.equals( other.getType() ) && this.price == other.getPrice() ); + } + + public static int getIndex(Class clazz, + String name) throws IntrospectionException { + PropertyDescriptor[] descriptors = Introspector.getBeanInfo( clazz ).getPropertyDescriptors(); + for ( int i = 0; i < descriptors.length; i++ ) { + if ( descriptors[i].getName().equals( name ) ) { + return i; + } + } + return -1; + } +} \ No newline at end of file Added: trunk/labs/jbossrules/drools-core/src/test/java/org/drools/examples/manners/MannersTest.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/test/java/org/drools/examples/manners/MannersTest.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/test/java/org/drools/examples/manners/MannersTest.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,127 @@ +package org.drools.examples.manners; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; +import java.io.StringWriter; +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +import org.drools.rule.Column; +import org.drools.rule.ColumnBinding; +import org.drools.rule.LiteralConstraint; +import org.drools.rule.Rule; +import org.drools.rule.RuleSet; +import org.drools.spi.ClassObjectType; +import org.drools.spi.BaseEvaluator; +import org.drools.spi.LiteralExpressionConstraint; + +public class MannersTest { + /** Number of guests at the dinner (default: 16). */ + private int numGuests = 16; + + /** Number of seats at the table (default: 16). */ + private int numSeats = 16; + + /** Minimum number of hobbies each guest should have (default: 2). */ + private int minHobbies = 2; + + /** Maximun number of hobbies each guest should have (default: 3). */ + private int maxHobbies = 3; + + private ClassObjectType contextType; + private ClassObjectType guestType; + private ClassObjectType seatingType; + private ClassObjectType lastSeatType; + + protected void setUp() throws Exception { + contextType = new ClassObjectType( Context.class ); + guestType = new ClassObjectType( Guest.class ); + seatingType = new ClassObjectType( Seating.class ); + lastSeatType = new ClassObjectType( LastSeat.class ); + + RuleSet ruleSet = new RuleSet( "Miss Manners" ); + Rule assignFirstSeat = getAssignFirstSeatRule(); + + } + + private Rule getAssignFirstSeatRule() { + Rule rule = new Rule( "assignFirstSeat" ); + + Column context = new Column( 0, + contextType, + "context" ); + +// LiteralExpressionConstraint isCheddar = new LiteralExpressionConstraint() { +// +// public boolean isAllowed(Object object, +// BaseEvaluator comparator) { +// Context context = (Context) object; +// return comparator.compare( context, +// Context.START_UP ); +// } +// +// }; + + /* + * Creates a constraint with the given expression + */ +// LiteralConstraint constraint0 = new LiteralConstraint( isCheddar, +// new ObjectConstraintComparator( BaseEvaluator.EQUAL ) ); + + // context. + + return rule; + } + + private InputStream generateData() { + final String LINE_SEPARATOR = System.getProperty( "line.separator" ); + + StringWriter writer = new StringWriter(); + + int maxMale = numGuests / 2; + int maxFemale = numGuests / 2; + + int maleCount = 0; + int femaleCount = 0; + + // init hobbies + List hobbyList = new ArrayList(); + for ( int i = 1; i <= maxHobbies; i++ ) { + hobbyList.add( "h" + i ); + } + + Random rnd = new Random(); + for ( int i = 1; i <= numGuests; i++ ) { + char sex = rnd.nextBoolean() ? 'm' : 'f'; + if ( sex == 'm' && maleCount == maxMale ) { + sex = 'f'; + } + if ( sex == 'f' && femaleCount == maxFemale ) { + sex = 'm'; + } + if ( sex == 'm' ) { + maleCount++; + } + if ( sex == 'f' ) { + femaleCount++; + } + + List guestHobbies = new ArrayList( hobbyList ); + + int numHobbies = minHobbies + rnd.nextInt( maxHobbies - minHobbies + 1 ); + for ( int j = 0; j < numHobbies; j++ ) { + int hobbyIndex = rnd.nextInt( guestHobbies.size() ); + String hobby = (String) guestHobbies.get( hobbyIndex ); + writer.write( "(guest (name n" + i + ") (sex " + sex + ") (hobby " + hobby + "))" + LINE_SEPARATOR ); + guestHobbies.remove( hobbyIndex ); + } + } + writer.write( "(last_seat (seat " + numSeats + "))" + LINE_SEPARATOR ); + + writer.write( LINE_SEPARATOR ); + writer.write( "(context (state start))" + LINE_SEPARATOR ); + + return new ByteArrayInputStream( writer.getBuffer().toString().getBytes() ); + } +} Added: trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/ClassFieldExtractor.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/ClassFieldExtractor.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/ClassFieldExtractor.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,51 @@ +package org.drools.spi; + +import java.beans.IntrospectionException; +import java.beans.Introspector; + +import org.drools.spi.FieldExtractor; + +/** + * Should be able to extract field values for a given index + * + */ +public class ClassFieldExtractor + implements + FieldExtractor { + private Class clazz; + private int index; + + public ClassFieldExtractor(Class clazz, + int index) { + this.clazz = clazz; + this.index = index; + } + + public int getIndex() { + return this.index; + } + + public Object getValue(Object object) { + Object value = null; + try { + System.out.println( object ); + value = Introspector.getBeanInfo( this.clazz ).getPropertyDescriptors()[this.index].getReadMethod().invoke( object, + null ); + } catch ( Exception e ) { + throw new RuntimeException( e ); + } + return value; + } + + public Class getValueType() { + Class clazz = null; + try { + clazz = Introspector.getBeanInfo( this.clazz ).getPropertyDescriptors()[this.index].getPropertyType(); + } catch ( IntrospectionException e ) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + return clazz; + } + +} \ No newline at end of file Added: trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/MockField.java =================================================================== --- trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/MockField.java 2006-01-02 05:19:01 UTC (rev 1969) +++ trunk/labs/jbossrules/drools-core/src/test/java/org/drools/spi/MockField.java 2006-01-02 05:24:21 UTC (rev 1970) @@ -0,0 +1,32 @@ +package org.drools.spi; + +import org.drools.spi.Field; + +public final class MockField + implements + Field { + + private final String name; + private final Object value; + private final int index; + + public MockField(String name, + Object value, + int index) { + this.index = index; + this.value = value; + this.name = name; + } + + public String getName() { + return this.name; + } + + public Object getValue() { + return this.value; + } + + public int getIndex() { + return this.index; + } +} \ No newline at end of file |