[jboss-svn-commits] JBL Code SVN: r26164 - labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Mon Apr 20 22:09:27 EDT 2009
Author: dsotty
Date: 2009-04-20 22:09:26 -0400 (Mon, 20 Apr 2009)
New Revision: 26164
Added:
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/IOperandSet.java
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ImperfectExistsNode.java
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ObservableRightTupleMemoryWrapper.java
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/SetCompositeEvaluation.java
Log:
many bugfixes
support for imperfect exists
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/IOperandSet.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/IOperandSet.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/IOperandSet.java 2009-04-21 02:09:26 UTC (rev 26164)
@@ -0,0 +1,14 @@
+package org.drools.reteoo;
+
+import java.util.Collection;
+
+
+public interface IOperandSet {
+
+ public Collection<Evaluation> getArgs();
+
+ public int size();
+
+
+
+}
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ImperfectExistsNode.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ImperfectExistsNode.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ImperfectExistsNode.java 2009-04-21 02:09:26 UTC (rev 26164)
@@ -0,0 +1,229 @@
+package org.drools.reteoo;
+
+import java.util.Observable;
+import java.util.Observer;
+
+import org.drools.RuleBaseConfiguration;
+import org.drools.RuntimeDroolsException;
+import org.drools.common.BetaConstraints;
+import org.drools.common.ImperfectFactHandle;
+import org.drools.common.InternalWorkingMemory;
+import org.drools.common.TupleStartEqualsConstraint;
+import org.drools.degrees.factory.IDegreeFactory;
+import org.drools.reteoo.builder.BuildContext;
+import org.drools.reteoo.filters.IFilterStrategy;
+import org.drools.rule.Behavior;
+import org.drools.rule.ContextEntry;
+import org.drools.rule.VariableConstraint;
+import org.drools.spi.PropagationContext;
+import org.drools.util.LeftTupleIndexHashTable;
+import org.drools.util.LeftTupleList;
+import org.drools.util.RightTupleIndexHashTable;
+import org.drools.util.RightTupleList;
+import org.drools.util.AbstractHashTable.FieldIndex;
+
+public class ImperfectExistsNode extends ExistsNode implements Observer {
+
+
+
+ protected CompositeEvaluationTemplate template;
+
+ public ImperfectExistsNode(int nextId, LeftTupleSource tupleSource,
+ ObjectSource objectSource, BetaConstraints betaConstraints,
+ Behavior[] behaviors, BuildContext context) {
+ super(nextId,tupleSource,objectSource,betaConstraints,behaviors,context);
+
+ IDegreeFactory factory = ((ImperfectRuleBase) context.getRuleBase()).getDegreeFactory();
+ this.filterStrat = factory.getDefaultStrategy();
+
+// ConstraintKey argKey = null;
+// if (this.rightInput instanceof RightInputAdapterNode)
+// argKey = ((RightInputAdapterNode) this.rightInput).getConstraintKeys()[0];
+// else if (this.rightInput instanceof ObjectSource)
+// argKey = ((ObjectSource) this.rightInput).getConstraintKey();
+// else
+// throw new RuntimeDroolsException("Source of type"+rightInput.getClass()+ " temporarily not supported");
+
+ //ConstraintKey key = new ConstraintKey(factory.getExistsOperator().getName(),argKey.toString());
+ ConstraintKey key = new DynamicConstraintKey(factory.getExistsOperator().getName());
+ template = new CompositeEvaluationTemplate(this.getId(),
+ key,
+ context.getRule().getDependencies().get(key),
+ 1,
+ factory.getExistsOperator(),
+ factory.getMergeStrategy(),
+ factory.getNullHandlingStrategy());
+
+ }
+
+
+ public Object createMemory(final RuleBaseConfiguration config) {
+ BetaMemory memory = new BetaMemory( new LeftTupleList(),
+ new ObservableRightTupleMemoryWrapper(new RightTupleList()),
+ new ContextEntry[0] );
+ return memory;
+ }
+
+
+
+
+ public void assertObject(ImperfectFactHandle factHandle,
+ PropagationContext propagationContext,
+ InternalWorkingMemory workingMemory, IDegreeFactory factory,
+ EvalRecord record) {
+
+ final RightTuple rightTuple = new ImperfectRightTuple( factHandle,
+ this, record );
+
+ final BetaMemory memory = (BetaMemory) workingMemory.getNodeMemory( this );
+ if ( !behavior.assertRightTuple( memory.getBehaviorContext(),
+ rightTuple,
+ workingMemory ) ) {
+ // destroy right tuple
+ rightTuple.unlinkFromRightParent();
+ return;
+ }
+
+ memory.getRightTupleMemory().add( rightTuple );
+ //will call notify on observers!
+
+ if ( !this.tupleMemoryEnabled ) {
+ // do nothing here, as we know there are no left tuples at this stage in sequential mode.
+ return;
+ }
+
+
+
+
+
+
+ /*
+ this.constraints.updateFromFactHandle( memory.getContext(),
+ workingMemory,
+ factHandle );
+ for ( LeftTuple leftTuple = memory.getLeftTupleMemory().getFirst( rightTuple ); leftTuple != null; ) {
+ // preserve next now, in case we remove this leftTuple
+ LeftTuple temp = (LeftTuple) leftTuple.getNext();
+
+ // we know that only unblocked LeftTuples are still in the memory
+ if ( this.constraints.isAllowedCachedRight( memory.getContext(),
+ leftTuple ) ) {
+ leftTuple.setBlocker( rightTuple );
+ rightTuple.setBlocked( leftTuple );
+
+ if ( this.tupleMemoryEnabled ) {
+ // this is now blocked so remove it from memory
+ memory.getLeftTupleMemory().remove( leftTuple );
+ }
+ this.sink.propagateAssertLeftTuple( leftTuple,
+ propagationContext,
+ workingMemory,
+ this.tupleMemoryEnabled );
+ }
+
+ leftTuple = temp;
+ }
+
+ this.constraints.resetFactHandle( memory.getContext() );
+ */
+ }
+
+
+ public void assertLeftTuple(ImperfectLeftTuple leftTuple,
+ PropagationContext context, InternalWorkingMemory workingMemory,
+ IDegreeFactory factory) {
+
+ final BetaMemory memory = (BetaMemory) workingMemory.getNodeMemory( this );
+ RightTupleMemory rtMem = memory.getRightTupleMemory();
+ ObservableRightTupleMemoryWrapper opSet = (ObservableRightTupleMemoryWrapper) rtMem;
+
+ EvalRecord mainRecord = leftTuple.getRecord();
+
+ SetCompositeEvaluation eval = (SetCompositeEvaluation) template.spawn(opSet);
+ opSet.addObserver( eval);
+
+ mainRecord.addEvaluation(eval);
+
+
+
+
+ System.out.println("Situation at EXISTS eval"+mainRecord.expand());
+
+
+ switch (this.filterStrat.doTry(mainRecord)) {
+ case IFilterStrategy.DROP :
+ System.out.println("Exist FAIL at assertTuple: DROP record");
+ return;
+
+ case IFilterStrategy.HOLD : //TODO: HOLD
+ System.out.println("HOLD RULES @EXIST NODE"+this.getId());
+ System.out.println("Situation is "+mainRecord.expand());
+
+ mainRecord.setLeftTuple(leftTuple);
+ mainRecord.setFactory(factory);
+ mainRecord.setPropagationContext(context);
+ mainRecord.setWorkingMemory(workingMemory);
+ mainRecord.addObserver(this);
+
+ break;
+
+ case IFilterStrategy.PASS :
+ System.out.println("Exist PASS at assertTuple: propagate record");
+ this.sink.propagateAssertLeftTuple( leftTuple,
+ context,
+ workingMemory,
+ factory,
+ mainRecord,
+ this.tupleMemoryEnabled );
+
+ break;
+ default : return;
+
+ }
+
+ }
+
+ public ConstraintKey[] getConstraintKeys() {
+ return new ConstraintKey[] {this.template.getConstraintKey()};
+ }
+
+
+
+
+
+
+
+ public void update(Observable o, Object arg) {
+
+ System.out.println(this.getClass().toString() + " NOTIFIED OF CHANGE");
+
+ EvalRecord mainRecord = (EvalRecord) o;
+ System.out.println("Situation changed at EXISTS eval"+mainRecord.expand());
+
+
+ switch (this.filterStrat.doTry(mainRecord)) {
+ case IFilterStrategy.DROP :
+ System.out.println("Exist FAIL at assertTuple: DROP record");
+ return;
+
+ case IFilterStrategy.HOLD : //TODO: HOLD
+ System.out.println("HOLD RULES @EXIST NODE"+this.getId());
+ System.out.println("Situation is "+mainRecord.expand());
+ break;
+
+ case IFilterStrategy.PASS :
+ System.out.println("Exist PASS at assertTuple: propagate record");
+ this.sink.propagateAssertLeftTuple( mainRecord.getLeftTuple(),
+ mainRecord.getPropagationContext(),
+ mainRecord.getWorkingMemory(),
+ mainRecord.getFactory(),
+ mainRecord,
+ this.tupleMemoryEnabled );
+
+ break;
+ default : return;
+
+ }
+ }
+
+}
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ObservableRightTupleMemoryWrapper.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ObservableRightTupleMemoryWrapper.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/ObservableRightTupleMemoryWrapper.java 2009-04-21 02:09:26 UTC (rev 26164)
@@ -0,0 +1,96 @@
+package org.drools.reteoo;
+
+import java.util.Collection;
+import java.util.Observable;
+import java.util.Vector;
+
+import org.drools.util.Iterator;
+
+public class ObservableRightTupleMemoryWrapper extends Observable
+ implements RightTupleMemory {
+
+
+ private RightTupleMemory memory;
+
+ public ObservableRightTupleMemoryWrapper(RightTupleMemory wrapped) {
+ this.memory = wrapped;
+ }
+
+
+ public EvalIterator getIterator() {
+ return new EvalIterator(memory.iterator());
+ }
+
+
+ public Collection<Evaluation> getArgs() {
+ Vector<Evaluation> ans = new Vector<Evaluation>(memory.size());
+ EvalIterator iter = this.getIterator();
+ while (iter.hasNext()) {
+ ans.add(iter.next());
+ }
+
+ return ans;
+ }
+
+
+ public void add(RightTuple rightTuple) {
+ memory.add(rightTuple);
+ this.setChanged();
+ this.notifyObservers(rightTuple);
+ }
+
+ public boolean contains(RightTuple rightTuple) {
+ return memory.contains(rightTuple);
+ }
+
+ public RightTuple getFirst(LeftTuple leftTuple) {
+ return memory.getFirst(leftTuple);
+ }
+
+ public RightTuple getLast(LeftTuple leftTuple) {
+ return memory.getLast(leftTuple);
+ }
+
+ public boolean isIndexed() {
+ return memory.isIndexed();
+ }
+
+ public Iterator iterator() {
+ return memory.iterator();
+
+ }
+
+ public void remove(RightTuple rightTuple) {
+ memory.remove(rightTuple);
+ this.setChanged();
+ this.notifyObservers(rightTuple);
+ }
+
+ public int size() {
+ return memory.size();
+ }
+
+
+ class EvalIterator implements java.util.Iterator<Evaluation> {
+
+ private Iterator iterator;
+
+ public EvalIterator(Iterator iter) {
+ this.iterator = iter;
+ }
+
+ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+
+ public Evaluation next() {
+ return ((ImperfectRightTuple) iterator.next()).getRecord();
+ }
+
+ public void remove() {
+
+ }
+
+ }
+
+}
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/SetCompositeEvaluation.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/SetCompositeEvaluation.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/SetCompositeEvaluation.java 2009-04-21 02:09:26 UTC (rev 26164)
@@ -0,0 +1,72 @@
+package org.drools.reteoo;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.Set;
+import java.util.Vector;
+
+import org.drools.degrees.IDegree;
+import org.drools.degrees.operators.IDegreeCombiner;
+import org.drools.degrees.operators.IMergeStrategy;
+import org.drools.degrees.operators.INullHandlingStrategy;
+
+public class SetCompositeEvaluation extends CompositeEvaluation {
+
+ //IOperandSet args;
+
+ public SetCompositeEvaluation(int id, ConstraintKey key, Set<String> deps,
+ IDegreeCombiner operator, IOperandSet args,
+ IMergeStrategy mergeStrat, INullHandlingStrategy nullStrat) {
+ super(id,key,deps,mergeStrat,nullStrat);
+
+ setOperator(operator);
+
+ if (args != null) {
+ this.operands = new Vector<Evaluation>(args.size());
+
+ int j = 0;
+ for (Evaluation eval : args.getArgs())
+ setOperand(j++,eval);
+
+ } else {
+ this.operands = new Vector<Evaluation>(0);
+ }
+
+ combine();
+
+ System.out.println("Created setCE \n "+this.toString());
+ }
+
+
+ public void update(Observable o, Object arg) {
+ System.out.println("UPDATE HAS BEEN CALLED ON SETVAL by "+ o.toString());
+
+ if (arg instanceof ImperfectRightTuple) {
+ ImperfectRightTuple impRT = (ImperfectRightTuple) arg;
+ if (! this.operands.contains(impRT.getRecord()))
+ this.operands.add(impRT.getRecord());
+ combine();
+// setChanged();
+// this.notifyObservers();
+ } else {
+
+
+ }
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+}
More information about the jboss-svn-commits
mailing list