Sequencing v1

drools-base/src/main/java/org/drools/base/base/ValueResolver.java

@@ -20,6 +20,11 @@
 
 import org.drools.base.RuleBase;
 import org.drools.base.rule.accessor.GlobalResolver;
+import org.drools.core.phreak.PropagationEntry;
+import org.drools.core.time.TimerService;
+import org.kie.api.runtime.KieSessionConfiguration;
+
+import java.util.function.Consumer;
 
 public interface ValueResolver {
 
@@ -32,4 +37,29 @@ default Object getGlobal(String identifier) {
     GlobalResolver getGlobalResolver();
 
     RuleBase getRuleBase();
+
+    void addPropagation(PropagationEntry propagationEntry);
+
+    KieSessionConfiguration getKieSessionConfiguration();
+
+    default <T extends ValueResolver> T as(Class<T> t) {
+        return (T) this;
+    }
+
+    default void setWorkingMemoryActionListener(Consumer<PropagationEntry> listener) {
+        throw new UnsupportedOperationException();
+    }
+
+    default Consumer<PropagationEntry> getWorkingMemoryActionListener() {
+        return null;
+    }
+
+    default void onWorkingMemoryAction(PropagationEntry entry) {
+        Consumer<PropagationEntry> listener = getWorkingMemoryActionListener();
+        if (listener != null) {
+            listener.accept(entry);
+        }
+    }
+
+    TimerService getTimerService();
 }

drools-base/src/main/java/org/drools/base/definitions/rule/impl/RuleImpl.java

@@ -51,7 +51,7 @@
 import org.drools.base.rule.accessor.Salience;
 import org.drools.base.rule.accessor.Wireable;
 import org.drools.base.rule.consequence.Consequence;
-import org.drools.base.time.impl.Timer;
+import org.drools.base.time.Timer;
 import org.drools.util.StringUtils;
 import org.kie.api.definition.rule.Query;
 import org.kie.api.io.Resource;

drools-base/src/main/java/org/drools/base/reteoo/NodeTypeEnums.java

@@ -75,6 +75,7 @@ public class NodeTypeEnums {
     public static final int AsyncReceiveNode        = (260 << shift) | TupleSourceMask | TupleSinkMask | TupleNodeMask | MemoryFactoryMask;
     public static final int FromNode                = (270 << shift) | TupleSourceMask | TupleSinkMask | TupleNodeMask | MemoryFactoryMask;
     public static final int ReactiveFromNode        = (280 << shift) | TupleSourceMask | TupleSinkMask | TupleNodeMask | MemoryFactoryMask;
+    public static final int SequenceNode            = (290 << shift) | TupleSourceMask | TupleSinkMask | TupleNodeMask | MemoryFactoryMask;
 
     public static final int QueryElementNode        = (300 << shift) | TupleSourceMask | TupleSinkMask | TupleNodeMask | MemoryFactoryMask;
     public static final int ConditionalBranchNode   = (310 << shift) | TupleSourceMask | TupleSinkMask | TupleNodeMask | MemoryFactoryMask;

drools-core/src/main/java/org/drools/core/time/Job.java → drools-base/src/main/java/org/drools/base/time/Job.java

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.drools.core.time;
+package org.drools.base.time;
 
 public interface Job {
     void execute(JobContext ctx);

drools-core/src/main/java/org/drools/core/time/JobContext.java → drools-base/src/main/java/org/drools/base/time/JobContext.java

@@ -16,15 +16,11 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.drools.core.time;
+package org.drools.base.time;
 
 import java.io.Serializable;
-import java.util.Optional;
 
-import org.drools.base.time.JobHandle;
-import org.drools.core.common.InternalKnowledgeRuntime;
-import org.drools.core.common.InternalWorkingMemory;
-import org.drools.core.common.ReteEvaluator;
+import org.drools.base.base.ValueResolver;
 
 public interface JobContext extends Serializable {
     /**
@@ -34,9 +30,10 @@ public interface JobContext extends Serializable {
 
     JobHandle getJobHandle();
 
-    ReteEvaluator getReteEvaluator();
-
-    default Optional<InternalKnowledgeRuntime> getInternalKnowledgeRuntime() {
-        return getReteEvaluator() instanceof InternalWorkingMemory ? Optional.ofNullable(((InternalWorkingMemory)getReteEvaluator()).getKnowledgeRuntime()) : Optional.empty();
-    }
+    ValueResolver getValueResolver();
+//    ReteEvaluator getReteEvaluator();
+//
+//    default Optional<InternalKnowledgeRuntime> getInternalKnowledgeRuntime() {
+//        return getReteEvaluator() instanceof InternalWorkingMemory ? Optional.ofNullable(((InternalWorkingMemory)getReteEvaluator()).getKnowledgeRuntime()) : Optional.empty();
+//    }
 }

drools-base/src/main/java/org/drools/base/time/impl/Timer.java → drools-base/src/main/java/org/drools/base/time/Timer.java

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-package org.drools.base.time.impl;
+package org.drools.base.time;
 
 import java.io.Serializable;
 
@@ -25,8 +25,6 @@
 import org.drools.base.rule.Declaration;
 import org.drools.base.rule.RuleComponent;
 import org.drools.base.rule.RuleConditionElement;
-import org.drools.base.time.JobHandle;
-import org.drools.base.time.Trigger;
 import org.kie.api.runtime.Calendars;
 
 public interface Timer extends Serializable, RuleComponent, RuleConditionElement {

drools-base/src/main/java/org/drools/core/phreak/PropagationEntry.java

@@ -0,0 +1,44 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.drools.core.phreak;
+
+import org.drools.base.base.ValueResolver;
+
+public interface PropagationEntry<T extends ValueResolver> {
+
+    default void execute(T t) {
+        internalExecute(t);
+        t.onWorkingMemoryAction(this);
+    }
+
+    void internalExecute(T t);
+
+    PropagationEntry getNext();
+    void setNext(PropagationEntry next);
+
+    boolean requiresImmediateFlushing();
+
+    boolean isCalledFromRHS();
+
+    boolean isPartitionSplittable();
+    PropagationEntry getSplitForPartition(int partitionNr);
+
+    boolean defersExpiration();
+
+}

drools-base/src/main/java/org/drools/core/phreak/actions/AbstractPropagationEntry.java

@@ -0,0 +1,41 @@
+package org.drools.core.phreak.actions;
+
+import org.drools.base.base.ValueResolver;
+import org.drools.core.phreak.PropagationEntry;
+
+public abstract class AbstractPropagationEntry<T extends ValueResolver> implements PropagationEntry<T> {
+    protected PropagationEntry next;
+
+    public void setNext(PropagationEntry next) {
+        this.next = next;
+    }
+
+    public PropagationEntry getNext() {
+        return next;
+    }
+
+    @Override
+    public boolean requiresImmediateFlushing() {
+        return false;
+    }
+
+    @Override
+    public boolean isCalledFromRHS() {
+        return false;
+    }
+
+    @Override
+    public boolean isPartitionSplittable() {
+        return false;
+    }
+
+    @Override
+    public boolean defersExpiration() {
+        return false;
+    }
+
+    @Override
+    public PropagationEntry getSplitForPartition(int partitionNr) {
+        throw new UnsupportedOperationException();
+    }
+}

drools-base/src/main/java/org/drools/core/reteoo/DynamicFilter.java

@@ -0,0 +1,50 @@
+package org.drools.core.reteoo;
+
+import org.drools.base.base.ValueResolver;
+import org.drools.base.rule.constraint.AlphaNodeFieldConstraint;
+import org.drools.core.util.AbstractLinkedListNode;
+import org.drools.core.util.LinkedList;
+import org.kie.api.runtime.rule.FactHandle;
+
+public class DynamicFilter extends AbstractLinkedListNode<DynamicFilter> {
+    private AlphaNodeFieldConstraint  constraint;
+    private LinkedList<SignalAdapter> signalAdapters;
+    private int                       activeFilterIndex;
+
+    public DynamicFilter(DynamicFilterProto proto) {
+        this.constraint        = proto.getConstraint();
+        this.activeFilterIndex = proto.getFilterIndex();
+        this.signalAdapters    = new LinkedList<>();
+    }
+
+    public AlphaNodeFieldConstraint getConstraint() {
+        return constraint;
+    }
+
+    public int getActiveFilterIndex() {
+        return activeFilterIndex;
+    }
+
+    public void addSignalAdapter(SignalAdapter signalAdapter) {
+        signalAdapters.add(signalAdapter);
+    }
+
+    public void removeSignalAdapter(SignalAdapter signalAdapter) {
+        signalAdapters.remove(signalAdapter);
+    }
+
+    public LinkedList<SignalAdapter> getSignalAdapters() {
+        return signalAdapters;
+    }
+
+    public void assertObject(final FactHandle factHandle,
+                             final ValueResolver valueResolver) {
+        System.out.println("true : " + factHandle.getObject());
+
+        if (constraint.isAllowed(factHandle, valueResolver)) {
+            for (SignalAdapter signal = signalAdapters.getFirst(); signal != null; signal = signal.getNext()) {
+                signal.receive(valueResolver, factHandle);
+            }
+        }
+    }
+}

drools-base/src/main/java/org/drools/core/reteoo/DynamicFilterProto.java

@@ -0,0 +1,21 @@
+package org.drools.core.reteoo;
+
+import org.drools.base.rule.constraint.AlphaNodeFieldConstraint;
+
+public class DynamicFilterProto {
+    private AlphaNodeFieldConstraint constraint;
+    private int                      filterIndex;
+
+    public DynamicFilterProto(AlphaNodeFieldConstraint constraint, int filterIndex) {
+        this.constraint  = constraint;
+        this.filterIndex = filterIndex;
+    }
+
+    public AlphaNodeFieldConstraint getConstraint() {
+        return constraint;
+    }
+
+    public int getFilterIndex() {
+        return filterIndex;
+    }
+}

drools-base/src/main/java/org/drools/core/reteoo/SignalAdapter.java

@@ -0,0 +1,25 @@
+package org.drools.core.reteoo;
+
+import org.drools.base.base.ValueResolver;
+import org.drools.core.reteoo.sequencing.Sequence.SequenceMemory;
+import org.drools.core.reteoo.sequencing.signalprocessors.SignalProcessor;
+import org.drools.core.reteoo.sequencing.signalprocessors.SignalStatus;
+import org.drools.core.util.AbstractLinkedListNode;
+import org.kie.api.runtime.rule.FactHandle;
+
+public class SignalAdapter extends AbstractLinkedListNode<SignalAdapter> {
+    private SignalProcessor output;
+    private int             signalBitIndex;
+    private SequenceMemory  memory;
+
+    public SignalAdapter(SignalProcessor output, int signalBitIndex, SequenceMemory memory) {
+        this.output         = output;
+        this.signalBitIndex = signalBitIndex;
+        this.memory         = memory;
+    }
+
+    public void receive(ValueResolver reteEvaluator, FactHandle factHandle) {
+        memory.getSequencerMemory().getEvents().add(factHandle);
+        output.consume(signalBitIndex, SignalStatus.MATCHED, memory, reteEvaluator);
+    }
+}

drools-base/src/main/java/org/drools/core/reteoo/sequencing/DynamicFilters.java

@@ -0,0 +1,9 @@
+package org.drools.core.reteoo.sequencing;
+
+import org.drools.core.reteoo.DynamicFilter;
+
+public interface DynamicFilters {
+    DynamicFilter getActiveDynamicFilter(int filterIndex);
+
+    void removeActiveFilter(DynamicFilter filter);
+}