[jboss-svn-commits] JBL Code SVN: r26252 - in labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo: builder and 1 other directory.
jboss-svn-commits at lists.jboss.org
jboss-svn-commits at lists.jboss.org
Fri Apr 24 22:32:50 EDT 2009
Author: dsotty
Date: 2009-04-24 22:32:50 -0400 (Fri, 24 Apr 2009)
New Revision: 26252
Added:
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/OperandSet.java
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/PatternNegator.java
labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/builder/ImperfectForallBuilder.java
Log:
quantifiers and args
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/OperandSet.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/OperandSet.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/OperandSet.java 2009-04-25 02:32:50 UTC (rev 26252)
@@ -0,0 +1,96 @@
+package org.drools.reteoo;
+
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.Vector;
+
+import org.drools.FactHandle;
+import org.drools.common.BetaConstraints;
+import org.drools.common.EmptyBetaConstraints;
+import org.drools.common.InternalWorkingMemory;
+import org.drools.common.TupleStartEqualsConstraint;
+import org.drools.degrees.factory.IDegreeFactory;
+import org.drools.rule.ContextEntry;
+import org.drools.runtime.rule.WorkingMemory;
+
+
+public class OperandSet extends Observable implements Observer {
+
+ private ObservableRightTupleMemoryWrapper memory;
+ private ContextEntry[] context;
+ private IDegreeFactory factory;
+ private LeftTuple tuple;
+ private InternalWorkingMemory workMem;
+
+ private BetaConstraints joinConstraints;
+
+
+ public OperandSet(LeftTuple lTuple, ObservableRightTupleMemoryWrapper mem, BetaConstraints constraints, ContextEntry[] context, InternalWorkingMemory wmem, IDegreeFactory factory) {
+ this.tuple = lTuple;
+ this.memory = mem;
+ this.memory.addObserver(this);
+ this.factory = factory;
+ this.context = context;
+ this.joinConstraints = constraints;
+ this.workMem = wmem;
+ }
+
+ public LinkedList<Evaluation> getEvaluations() {
+ return memory.getEvaluations();
+ }
+
+ public LinkedList<FactHandle> getHandles() {
+ return memory.getHandles();
+ }
+
+
+ public int size() {
+ return memory.size();
+ }
+
+
+
+
+ public IDegreeFactory getFactory() {
+ return factory;
+ }
+
+ public ContextEntry[] getContext() {
+ return context;
+ }
+
+
+
+ public void update(Observable arg0, Object newArg) {
+
+
+ if (newArg instanceof ImperfectRightTuple) {
+ ImperfectRightTuple impRT = (ImperfectRightTuple) newArg;
+ EvalRecord record = impRT.getRecord().clone();
+
+ joinConstraints.updateFromTuple(getContext(), workMem, tuple);
+ if (! (joinConstraints instanceof EmptyBetaConstraints)) {
+ Evaluation[] newEvals = joinConstraints.isSatisfiedCachedRight(context, tuple, factory);
+ for (Evaluation newEv : newEvals) {
+ if (! newEv.getKey().toString().equals("starts(tuple,...)"))
+ record.addEvaluation(newEv);
+ }
+ }
+ joinConstraints.resetTuple(getContext());
+
+ this.setChanged();
+ this.notifyObservers(record);
+
+
+ } else {
+
+
+ }
+
+ }
+
+
+
+}
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/PatternNegator.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/PatternNegator.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/PatternNegator.java 2009-04-25 02:32:50 UTC (rev 26252)
@@ -0,0 +1,147 @@
+package org.drools.reteoo;
+
+import org.drools.RuntimeDroolsException;
+import org.drools.common.BaseNode;
+import org.drools.common.ImperfectFactHandle;
+import org.drools.common.InternalFactHandle;
+import org.drools.common.InternalWorkingMemory;
+import org.drools.common.PropagationContextImpl;
+import org.drools.degrees.factory.IDegreeFactory;
+import org.drools.degrees.operators.IDegreeCombiner;
+import org.drools.degrees.operators.NegationOperator;
+import org.drools.reteoo.builder.BuildContext;
+import org.drools.spi.AlphaNodeFieldConstraint;
+import org.drools.spi.PropagationContext;
+
+public class PatternNegator extends ObjectSource
+ implements ObjectSinkNode {
+
+ private ObjectSinkNode previousRightTupleSinkNode;
+ private ObjectSinkNode nextRightTupleSinkNode;
+
+
+
+ public PatternNegator(final int id,
+ final ObjectSource objectSource,
+ final BuildContext context) {
+ super( id,
+ context.getPartitionId(),
+ context.getRuleBase().getConfiguration().isMultithreadEvaluation(),
+ objectSource,
+ context.getRuleBase().getConfiguration().getAlphaNodeHashingThreshold() );
+ }
+
+ public ConstraintKey getConstraintKey() {
+ throw new RuntimeDroolsException("Wrapper does not have a key");
+ }
+
+
+ public void updateSink(ObjectSink sink, PropagationContext context,
+ InternalWorkingMemory workingMemory) {
+ this.source.updateSink(sink, context, workingMemory);
+ }
+
+
+ public void attach() {
+ this.source.addObjectSink( this );
+ }
+
+ public void attach(final InternalWorkingMemory[] workingMemories) {
+ attach();
+
+ for ( int i = 0, length = workingMemories.length; i < length; i++ ) {
+ final InternalWorkingMemory workingMemory = workingMemories[i];
+ final PropagationContext propagationContext = new PropagationContextImpl( workingMemory.getNextPropagationIdCounter(),
+ PropagationContext.RULE_ADDITION,
+
+ null,
+ null,
+ null );
+ this.source.updateSink( this,
+ propagationContext,
+ workingMemory );
+ }
+ }
+
+
+ protected void doRemove(final RuleRemovalContext context,
+ final ReteooBuilder builder,
+ final BaseNode node,
+ final InternalWorkingMemory[] workingMemories) {
+ if ( !node.isInUse() ) {
+ removeObjectSink( (ObjectSink) node );
+ }
+
+ this.source.remove( context,
+ builder,
+ this,
+ workingMemories );
+ }
+
+
+ /**
+ * Returns the next node
+ * @return
+ * The next ObjectSinkNode
+ */
+ public ObjectSinkNode getNextObjectSinkNode() {
+ return this.nextRightTupleSinkNode;
+ }
+
+ /**
+ * Sets the next node
+ * @param next
+ * The next ObjectSinkNode
+ */
+ public void setNextObjectSinkNode(final ObjectSinkNode next) {
+ this.nextRightTupleSinkNode = next;
+ }
+
+ /**
+ * Returns the previous node
+ * @return
+ * The previous ObjectSinkNode
+ */
+ public ObjectSinkNode getPreviousObjectSinkNode() {
+ return this.previousRightTupleSinkNode;
+ }
+
+ /**
+ * Sets the previous node
+ * @param previous
+ * The previous ObjectSinkNode
+ */
+ public void setPreviousObjectSinkNode(final ObjectSinkNode previous) {
+ this.previousRightTupleSinkNode = previous;
+ }
+
+
+
+
+ public void assertObject(InternalFactHandle factHandle,
+ PropagationContext propagationContext,
+ InternalWorkingMemory workingMemory) {
+ //throw new RuntimeDroolsException("Patterns can be negated only using imperfection");
+ this.sink.propagateAssertObject(factHandle, propagationContext, workingMemory);
+ }
+
+
+ public void assertObject(ImperfectFactHandle factHandle,
+ PropagationContext propagationContext,
+ InternalWorkingMemory workingMemory, IDegreeFactory factory,
+ EvalRecord record) {
+
+ IDegreeCombiner oldOp = record.getOperator();
+ NegationOperator negOp = (NegationOperator) factory.getNegationOperator();
+ negOp.setOperator(oldOp);
+ record.setOperator( negOp );
+ record.setKey(record.getKey().cloneReplace(oldOp.getName(),negOp.getName()));
+ record.combine();
+
+ this.sink.propagateAssertObject(factHandle, propagationContext, workingMemory, factory, record);
+
+ }
+
+
+
+}
Added: labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/builder/ImperfectForallBuilder.java
===================================================================
--- labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/builder/ImperfectForallBuilder.java (rev 0)
+++ labs/jbossrules/branches/DroolsChance/drools-core/src/main/java/org/drools/reteoo/builder/ImperfectForallBuilder.java 2009-04-25 02:32:50 UTC (rev 26252)
@@ -0,0 +1,123 @@
+package org.drools.reteoo.builder;
+
+import java.util.Iterator;
+
+import org.drools.rule.Forall;
+import org.drools.rule.GroupElement;
+import org.drools.rule.GroupElementFactory;
+import org.drools.rule.Pattern;
+import org.drools.rule.RuleConditionElement;
+
+public class ImperfectForallBuilder extends ForallBuilder implements
+ ReteooComponentBuilder {
+
+
+
+ public void build(final BuildContext context,
+ final BuildUtils utils,
+ final RuleConditionElement rce) {
+
+ final Forall forall = (Forall) rce;
+
+ // forall can be translated into
+ // not EXIST( basePattern and not EXIST( <remaining_patterns>+ ) )
+ // so we just do that:
+
+ final GroupElement not = GroupElementFactory.newNotInstance();
+ final GroupElement exists = GroupElementFactory.newExistsInstance();
+
+ final GroupElement and = GroupElementFactory.newAndInstance();
+
+ final GroupElement notInner = GroupElementFactory.newNotInstance();
+ final GroupElement existsInner = GroupElementFactory.newExistsInstance();
+ final GroupElement andInner = GroupElementFactory.newAndInstance();
+
+
+ Pattern base = forall.getBasePattern();
+ //Pattern child1 = (Pattern) forall.getRemainingPatterns().get(0);
+
+// if ( forall.getRemainingPatterns().size() == 1 ) {
+// notInner.addChild( (Pattern) forall.getRemainingPatterns().get( 0 ) );
+//
+// exists.addChild(notInner);
+//
+// }
+
+
+ if ( forall.getRemainingPatterns().size() == 1 ) {
+ Pattern pat = (Pattern) forall.getRemainingPatterns().get( 0 );
+ pat.dropLastConstraint();
+
+ notInner.addChild(pat);
+ exists.addChild(notInner);
+
+
+
+// and.addChild(base);
+//
+//
+// existsInner.addChild( (Pattern) forall.getRemainingPatterns().get( 0 ) );
+//
+// notInner.addChild(existsInner);
+// and.addChild(notInner);
+
+
+
+// exists.addChild(and);
+
+ } else if ( forall.getRemainingPatterns().size() > 1 ) {
+
+
+ and.addChild(base);
+
+
+ for ( final Iterator it = forall.getRemainingPatterns().iterator(); it.hasNext(); ) {
+ andInner.addChild( (Pattern) it.next() );
+ }
+
+ existsInner.addChild( andInner );
+ notInner.addChild(existsInner);
+ and.addChild(notInner);
+
+ exists.addChild(and);
+
+
+ /*
+ and.addChild(base);
+ for ( final Iterator it = forall.getRemainingPatterns().iterator(); it.hasNext(); ) {
+ and.addChild( (Pattern) it.next() );
+ }
+
+ notInner.addChild(and);
+ exists.addChild(notInner);
+ */
+ }
+
+
+
+
+
+ not.addChild(exists);
+
+
+
+
+
+
+
+
+
+
+ GroupElement baseElement = not;
+ // get builder for the CEs
+ final ReteooComponentBuilder builder = utils.getBuilderFor( baseElement );
+
+ // builds the CEs
+ builder.build( context,
+ utils,
+ not );
+ }
+
+
+
+}
More information about the jboss-svn-commits
mailing list