Package org.drools.core.util.index

Examples of org.drools.core.util.index.LeftTupleList


                                  LeftTupleSink sink,
                                  InternalWorkingMemory wm,
                                  LeftTupleSets srcLeftTuples,
                                  LeftTupleSets trgLeftTuples, RuleNetworkEvaluatorActivation activation) {
            ConditionalBranchEvaluator branchEvaluator = branchNode.getBranchEvaluator();
            LeftTupleList tupleList = activation.getLeftTupleList();

            for (LeftTuple leftTuple = srcLeftTuples.getInsertFirst(); leftTuple != null; ) {
                LeftTuple next = leftTuple.getStagedNext();

                boolean breaking = false;
                ConditionalExecution conditionalExecution = branchEvaluator.evaluate(leftTuple, wm, cbm.context);

                boolean useLeftMemory = useLeftMemory(branchNode, leftTuple);

                if (conditionalExecution != null) {
                    RuleTerminalNode rtn = (RuleTerminalNode) conditionalExecution.getSink().getFirstLeftTupleSink();
                    LeftTuple branchedLeftTuple = rtn.createLeftTuple(leftTuple,
                                                                      rtn,
                                                                      leftTuple.getPropagationContext(), useLeftMemory);

                    leftTuple.setObject(branchedLeftTuple);

                    //rtn.assertLeftTuple(branchedLeftTuple, leftTuple.getPropagationContext(), wm);
                    tupleList.add(branchedLeftTuple);

                    breaking = conditionalExecution.isBreaking();
                }

                if (!breaking) {
View Full Code Here


                                  InternalWorkingMemory wm,
                                  LeftTupleSets srcLeftTuples,
                                  LeftTupleSets trgLeftTuples,
                                  LeftTupleSets stagedLeftTuples, RuleNetworkEvaluatorActivation activation) {
            ConditionalBranchEvaluator branchEvaluator = branchNode.getBranchEvaluator();
            LeftTupleList tupleList = activation.getLeftTupleList();

            for (LeftTuple leftTuple = srcLeftTuples.getUpdateFirst(); leftTuple != null; ) {
                LeftTuple next = leftTuple.getStagedNext();

                LeftTuple rtnLeftTuple = (LeftTuple) leftTuple.getObject();
                LeftTuple mainLeftTuple = leftTuple.getFirstChild();

                RuleTerminalNode oldRtn = null;
                if (rtnLeftTuple != null) {
                    oldRtn = (RuleTerminalNode) rtnLeftTuple.getSink();
                }

                ConditionalExecution conditionalExecution = branchEvaluator.evaluate(leftTuple, wm, cbm.context);

                RuleTerminalNode newRtn = null;
                boolean breaking = false;
                if (conditionalExecution != null) {
                    newRtn = (RuleTerminalNode) conditionalExecution.getSink().getFirstLeftTupleSink();
                    breaking = conditionalExecution.isBreaking();
                }

                // Handle conditional branches
                if (oldRtn != null) {
                    if (newRtn == null) {
                        // old exits, new does not, so delete
                        if ( rtnLeftTuple.getMemory() != null ) {
                            tupleList.remove(rtnLeftTuple);
                        }
                        oldRtn.retractLeftTuple(rtnLeftTuple, rtnLeftTuple.getPropagationContext(), wm);

                    } else if (newRtn == oldRtn) {
                        // old and new on same branch, so update
                        if ( rtnLeftTuple.getMemory() != null ) {
                            tupleList.remove(rtnLeftTuple); // must be removed before it can bereadded
                        }
                        tupleList.add(rtnLeftTuple);
                        //oldRtn.modifyLeftTuple(rtnLeftTuple, rtnLeftTuple.getPropagationContext(), wm);

                    } else {
                        // old and new on different branches, delete one and insert the other
                        if ( rtnLeftTuple.getMemory() != null ) {
                            tupleList.remove(rtnLeftTuple);
                        }
                        oldRtn.retractLeftTuple(rtnLeftTuple, rtnLeftTuple.getPropagationContext(), wm);

                        rtnLeftTuple = newRtn.createLeftTuple(leftTuple,
                                                              newRtn,
                                                              leftTuple.getPropagationContext(), true);

                        leftTuple.setObject(rtnLeftTuple);
                        tupleList.add(rtnLeftTuple);
                        //newRtn.assertLeftTuple(rtnLeftTuple, rtnLeftTuple.getPropagationContext(), wm);
                    }

                } else if (newRtn != null) {
                    // old does not exist, new exists, so insert
                    rtnLeftTuple = newRtn.createLeftTuple(leftTuple,
                                                          newRtn,
                                                          leftTuple.getPropagationContext(), true);

                    leftTuple.setObject(rtnLeftTuple);
                    //newRtn.assertLeftTuple(rtnLeftTuple, rtnLeftTuple.getPropagationContext(), wm);
                    tupleList.add(rtnLeftTuple);
                }

                // Handle main branch
                if (mainLeftTuple != null) {
                    switch (mainLeftTuple.getStagedType()) {
View Full Code Here

                                  ConditionalBranchMemory cbm,
                                  InternalWorkingMemory wm,
                                  LeftTupleSets srcLeftTuples,
                                  LeftTupleSets trgLeftTuples,
                                  LeftTupleSets stagedLeftTuples, RuleNetworkEvaluatorActivation activation) {
            LeftTupleList tupleList = activation.getLeftTupleList();

            for (LeftTuple leftTuple = srcLeftTuples.getDeleteFirst(); leftTuple != null; ) {
                LeftTuple next = leftTuple.getStagedNext();

                LeftTuple rtnLeftTuple = (LeftTuple) leftTuple.getObject();
                LeftTuple mainLeftTuple = leftTuple.getFirstChild();

                if (rtnLeftTuple != null) {
                    RuleTerminalNode rtn = (RuleTerminalNode) rtnLeftTuple.getSink();
                    if ( rtnLeftTuple.getMemory() != null ) {
                        tupleList.remove(rtnLeftTuple);
                    }
                    rtn.retractLeftTuple(rtnLeftTuple,
                                         rtnLeftTuple.getPropagationContext(),
                                         wm);
                }
View Full Code Here

        private LeftTupleList leftTuples;
        private SegmentMemory memory;


        public TimerNodeMemory() {
            this.leftTuples = new LeftTupleList();
        }
View Full Code Here

        return true;
    }

    public BetaMemory createBetaMemory(final RuleBaseConfiguration config,
                                       final short nodeType) {
        final BetaMemory memory = new BetaMemory( config.isSequential() ? null : new LeftTupleList(),
                                                  new RightTupleList(),
                                                  this.createContext(),
                                                  nodeType );

        return memory;
View Full Code Here

     * Helper method
     */
    public Map getActivationParameters(Activation activation) {
        if (activation instanceof RuleAgendaItem) {
            RuleAgendaItem ruleAgendaItem = (RuleAgendaItem)activation;
            LeftTupleList tupleList = ruleAgendaItem.getRuleExecutor().getLeftTupleList();
            Map result = new TreeMap();
            int i = 0;
            for (LeftTuple tuple = tupleList.getFirst(); tuple != null; tuple = (LeftTuple) tuple.getNext()) {
                Map params = getActivationParameters(tuple);
                result.put("Parameters set [" + i++ + "]", (Map.Entry[]) params.entrySet().toArray(new Map.Entry[params.size()]));
            }
            return result;
        } else {
View Full Code Here

            this.betaConstraints.resetTuple( memory.betaMemory.getContext() );
        }
    }

    public Memory createMemory(final RuleBaseConfiguration config) {
        BetaMemory beta = new BetaMemory( new LeftTupleList(),
                                          null,
                                          this.betaConstraints.createContext(),
                                          NodeTypeEnums.FromNode );
        return new FromMemory( beta,
                               this.dataProvider.createContext(),
View Full Code Here

            Activation act = ( Activation ) match;
            if ( act.isRuleAgendaItem() ) {
                // The lazy RuleAgendaItem must be fully evaluated, to see if there is a rule match
                RuleAgendaItem ruleAgendaItem = (RuleAgendaItem) act;
                ruleAgendaItem.getRuleExecutor().evaluateNetwork(workingMemory);
                LeftTupleList list = ruleAgendaItem.getRuleExecutor().getLeftTupleList();
                for (RuleTerminalNodeLeftTuple lt = (RuleTerminalNodeLeftTuple) list.getFirst(); lt != null; lt = (RuleTerminalNodeLeftTuple) lt.getNext()) {
                    if ( ruleName.equals( lt.getRule().getName() ) ) {
                        if ( checkProcessInstance( lt, processInstanceId ) ) {
                            return true;
                        }
                    }
View Full Code Here

    public RuleExecutor(final PathMemory pmem,
            RuleAgendaItem ruleAgendaItem,
            boolean declarativeAgendaEnabled) {
        this.pmem = pmem;
        this.ruleAgendaItem = ruleAgendaItem;
        this.tupleList = new LeftTupleList();
        this.declarativeAgendaEnabled = declarativeAgendaEnabled;
        if (ruleAgendaItem.getRule().getSalience().isDynamic()) {
            queue = new BinaryHeapQueue(SalienceComparator.INSTANCE);
        }
    }
View Full Code Here

            Activation act = ( Activation ) match;
            if ( act.isRuleAgendaItem() ) {
                // The lazy RuleAgendaItem must be fully evaluated, to see if there is a rule match
                RuleAgendaItem ruleAgendaItem = (RuleAgendaItem) act;
                ruleAgendaItem.getRuleExecutor().evaluateNetwork(workingMemory);
                LeftTupleList list = ruleAgendaItem.getRuleExecutor().getLeftTupleList();
                for (RuleTerminalNodeLeftTuple lt = (RuleTerminalNodeLeftTuple) list.getFirst(); lt != null; lt = (RuleTerminalNodeLeftTuple) lt.getNext()) {
                    if ( ruleName.equals( lt.getRule().getName() ) ) {
                        if ( checkProcessInstance( lt, processInstanceId ) ) {
                            return true;
                        }
                    }
View Full Code Here

TOP

Related Classes of org.drools.core.util.index.LeftTupleList

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.