return fire(wm, filter, fireCount, fireLimit, outerStack, agenda, fireUntilHalt);

    }

    public synchronized void fire(InternalWorkingMemory wm, LinkedList<StackEntry> outerStack) {

        fire(wm, null, 0, Integer.MAX_VALUE, outerStack, agenda, fireUntilHalt);

    }

    public void doLeftInserts(TerminalNode rtnNode,

                              InternalWorkingMemory wm,

                              LeftTupleSets srcLeftTuples,

                              RuleExecutor executor) {

        RuleAgendaItem ruleAgendaItem = executor.getRuleAgendaItem();

        int salienceInt = 0;

        Salience salience = ruleAgendaItem.getRule().getSalience();

        if ( !salience.isDynamic() ) {

    public void doLeftUpdates(TerminalNode rtnNode,

                              InternalWorkingMemory wm,

                              LeftTupleSets srcLeftTuples,

                              RuleExecutor executor) {

        RuleAgendaItem ruleAgendaItem = executor.getRuleAgendaItem();

        if ( rtnNode.getRule().getAutoFocus() && !ruleAgendaItem.getAgendaGroup().isActive() ) {

            ((InternalAgenda)wm.getAgenda()).setFocus(ruleAgendaItem.getAgendaGroup());

        }

        Activation activation = (Activation) leftTuple;

        activation.setMatched( false );

                                 pctx,

                                 wm,

                                 activation,

                                 rtnLt.getTerminalNode() );

    private static void writeAgenda(MarshallerWriteContext context,

                                    ProtobufMessages.RuleData.Builder _ksb) throws IOException {

        InternalWorkingMemory wm = context.wm;

        org.drools.core.marshalling.impl.ProtobufMessages.Agenda.Builder _ab = ProtobufMessages.Agenda.newBuilder();

        Arrays.sort( agendaGroups,

                     AgendaGroupSorter.instance );

        for ( AgendaGroup ag : agendaGroups ) {

            AgendaGroupQueueImpl group = (AgendaGroupQueueImpl) ag;

            org.drools.core.marshalling.impl.ProtobufMessages.Agenda.AgendaGroup.Builder _agb = ProtobufMessages.Agenda.AgendaGroup.newBuilder();

            _agb.setName( group.getName() )

                    .setIsActive( group.isActive() )

                    .setIsAutoDeactivate( group.isAutoDeactivate() )

                    .setClearedForRecency( group.getClearedForRecency() )

                    .setHasRuleFlowLister( group.isRuleFlowListener() )

                    .setActivatedForRecency( group.getActivatedForRecency() );

            Map<Long, String> nodeInstances = group.getNodeInstances();

            for ( Map.Entry<Long, String> entry : nodeInstances.entrySet() ) {

                org.drools.core.marshalling.impl.ProtobufMessages.Agenda.AgendaGroup.NodeInstance.Builder _nib = ProtobufMessages.Agenda.AgendaGroup.NodeInstance.newBuilder();

                _nib.setProcessInstanceId( entry.getKey() );

                _nib.setNodeInstanceId( entry.getValue() );

                _agb.addNodeInstance( _nib.build() );

            }

            _ab.addAgendaGroup( _agb.build() );

        }

        org.drools.core.marshalling.impl.ProtobufMessages.Agenda.FocusStack.Builder _fsb = ProtobufMessages.Agenda.FocusStack.newBuilder();

        for ( Iterator<AgendaGroup> it = focusStack.iterator(); it.hasNext(); ) {

            AgendaGroup group = it.next();

            _fsb.addGroupName( group.getName() );

        }

        _ab.setFocusStack( _fsb.build() );

        // serialize all dormant activations

        org.drools.core.util.Iterator it = ActivationIterator.iterator( wm );

        List<org.drools.core.spi.Activation> dormant = new ArrayList<org.drools.core.spi.Activation>();

        for ( org.drools.core.spi.Activation item = (org.drools.core.spi.Activation) it.next(); item != null; item = (org.drools.core.spi.Activation) it.next() ) {

            if ( !item.isQueued() ) {

                dormant.add( item );

            }

        }

        Collections.sort( dormant, ActivationsSorter.INSTANCE );

        for ( org.drools.core.spi.Activation activation : dormant ) {

            _ab.addMatch( writeActivation( context, (AgendaItem) activation ) );

        }

        // serialize all network evaluator activations

            if ( activation.isRuleAgendaItem() ) {

                // serialize it

                _ab.addRuleActivation( writeActivation( context, (AgendaItem) activation ) );

            }

        }

            leftTuple.setObject( Boolean.TRUE );

            return;

        }

                                                context,

                                                workingMemory,

                                                this,

                                                false );

        if( fire && !fireDirect ) {

        }

    }

            context = findMostRecentPropagationContext( leftTuple,

                                                        context );

        }

       

     

        // we need the inserted facthandle so we can update the network with new Activation

      Object o = leftTuple.getObject();

      if ( o != Boolean.TRUE) {  // would be true due to lock-on-active blocking activation creation

        AgendaItem match = (AgendaItem) o;      

          if ( match != null && match.isActivated() ) {

              // already activated, do nothing

              // although we need to notify the inserted Activation, as it's declarations may have changed.

              return;

          }

      }

        // if the current Rule is no-loop and the origin rule is the same then return

        if ( (!this.rule.isEffective( leftTuple,

                                      this,

                                      workingMemory )) ||

             (this.rule.isNoLoop() && this.rule.equals( context.getRuleOrigin() )) ) {

            return;

        }

        boolean reuseActivation = true;

        // o (AgendaItem) could be null, if this was staged as an insert but not processed, then pushed as a update

        if ( o == null || o  == Boolean.TRUE ) {

          // set to Boolean.TRUE when lock-on-active stops an Activation being created

          reuseActivation = false;

          leftTuple.setObject( null );

        }

        if ( fire && !isFireDirect() ) {

        }

    }

        Activation activation = (Activation) obj;

        activation.setMatched( false );

       

                                 context,

                                 workingMemory,

                                 activation,

                                 this );

    }

            leftTuple.setObject( Boolean.TRUE );

            return;

        }

                                                context,

                                                workingMemory,

                                                this );

        if( fire && !fireDirect ) {

        }

    }

            context = findMostRecentPropagationContext( leftTuple,

                                                        context );

        }

       

     

        // we need the inserted facthandle so we can update the network with new Activation

      Object o = leftTuple.getObject();

      if ( o != Boolean.TRUE) {  // would be true due to lock-on-active blocking activation creation

        AgendaItem match = (AgendaItem) o;      

          if ( match != null && match.isQueued() ) {

              // already activated, do nothing

              // although we need to notify the inserted Activation, as it's declarations may have changed.

              return;

          }

      }

        // if the current Rule is no-loop and the origin rule is the same then return

        if ( (!this.rule.isEffective( leftTuple,

                                      this,

                                      workingMemory )) ||

             (this.rule.isNoLoop() && this.rule.equals( context.getRuleOrigin() )) ) {

            return;

        }

        // o (AgendaItem) could be null, if this was staged as an insert but not processed, then pushed as a update

        if ( o == null || o  == Boolean.TRUE ) {

          // set to Boolean.TRUE when lock-on-active stops an Activation being created

          leftTuple.setObject( null );

        }

        if ( fire && !isFireDirect() ) {

        }

    }