org.kie.api.event.rule.BeforeMatchFiredEvent Java Examples

/**
 * @see org.kie.api.event.rule.AgendaEventListener
 */
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    filterLogEvent( new ActivationLogEvent( LogEvent.BEFORE_ACTIVATION_FIRE,
                                            getActivationId( event.getMatch() ),
                                            event.getMatch().getRule().getName(),
                                            extractDeclarations( event.getMatch() ),
                                            ((RuleImpl)event.getMatch().getRule()).getRuleFlowGroup(),
                                            extractFactHandleIds( (Activation) event.getMatch() ) ) );
}
 

public void fireAfterActivationFired(final Activation activation,
                                     final InternalWorkingMemory workingMemory, 
                                     BeforeMatchFiredEvent beforeMatchFiredEvent) {
    Iterator<AgendaEventListener> iter = getEventListenersIterator();
    AfterMatchFiredEvent event = new AfterActivationFiredEventImpl(activation, getKRuntime(workingMemory), beforeMatchFiredEvent);

    if (iter.hasNext()) {
        
        do{
            iter.next().afterMatchFired(event);
        }  while (iter.hasNext());
    }
}
 

public BeforeMatchFiredEvent fireBeforeActivationFired(final Activation activation,
                                      final WorkingMemory workingMemory) {
    Iterator<AgendaEventListener> iter = getEventListenersIterator();
    BeforeMatchFiredEvent event = new BeforeActivationFiredEventImpl(activation, getKRuntime(workingMemory));

    if (iter.hasNext()) {
        
        do{
            iter.next().beforeMatchFired(event);
        }  while (iter.hasNext());
    }
    
    return event;
}
 

/**
 * @see AgendaEventListener#beforeMatchFired(org.kie.api.event.rule.BeforeMatchFiredEvent)
 */
@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    log.info("{}", event);

}
 

public void beforeMatchFired(BeforeMatchFiredEvent event) {
}
 

/**
 * @see AgendaEventListener#beforeMatchFired(org.kie.api.event.rule.BeforeMatchFiredEvent)
 */
@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    log.info("{}", event);

}
 

/**
 * @see AgendaEventListener#beforeMatchFired(org.kie.api.event.rule.BeforeMatchFiredEvent)
 */
@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    log.info("{}", event);

}
 

@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    log.debug(event);
}
 

public BeforeActivationFiredEventImpl getBeforeImpl(BeforeMatchFiredEvent e) {
    return (BeforeActivationFiredEventImpl)e;
}
 

@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    long nanoTime = System.nanoTime();
    BeforeActivationFiredEventImpl impl = getBeforeImpl(event);
    impl.setTimestamp(nanoTime);
}
 

public BeforeMatchFiredEvent getBeforeMatchFiredEvent() {
    return beforeMatchFiredEvent;
}
 

public AfterActivationFiredEventImpl(Match activation, KieRuntime kruntime, BeforeMatchFiredEvent beforeMatchFiredEvent) {
    super( activation, kruntime );
    this.beforeMatchFiredEvent = beforeMatchFiredEvent;
}
 

public void beforeMatchFired(BeforeMatchFiredEvent event) {
    logger.info( event.toString() );
}
 

public void beforeMatchFired(BeforeMatchFiredEvent event) {
    // intentionally left blank
}
 

public void fireActivation(InternalWorkingMemory wm, InternalAgenda agenda, Activation activation) throws ConsequenceException {
    // We do this first as if a node modifies a fact that causes a recursion
    // on an empty pattern
    // we need to make sure it re-activates
    wm.startOperation();
    try {
        BeforeMatchFiredEvent beforeMatchFiredEvent = wm.getAgendaEventSupport().fireBeforeActivationFired(activation, wm);

        if ( activation.getActivationGroupNode() != null ) {
            // We know that this rule will cancel all other activations in the group
            // so lets remove the information now, before the consequence fires
            final InternalActivationGroup activationGroup = activation.getActivationGroupNode().getActivationGroup();
            activationGroup.removeActivation( activation );
            agenda.clearAndCancelActivationGroup( activationGroup);
        }
        activation.setQueued(false);

        try {
            innerFireActivation( wm, agenda, activation, activation.getConsequence() );
        } finally {
            // if the tuple contains expired events
            for ( Tuple tuple = activation.getTuple(); tuple != null; tuple = tuple.getParent() ) {
                if ( tuple.getFactHandle() != null && tuple.getFactHandle().isEvent() ) {
                    // can be null for eval, not and exists that have no right input

                    EventFactHandle handle = ( EventFactHandle ) tuple.getFactHandle();
                    // decrease the activation count for the event
                    handle.decreaseActivationsCount();
                    // handles "expire" only in stream mode.
                    if ( handle.expirePartition() && handle.isExpired() &&
                            handle.getFirstRightTuple() == null && handle.getActivationsCount() <= 0 ) {
                        // and if no more activations, retract the handle
                        handle.getEntryPoint().delete( handle );
                    }
                }
            }
        }

        wm.getAgendaEventSupport().fireAfterActivationFired( activation, wm, beforeMatchFiredEvent );
    } finally {
        wm.endOperation();
    }
}
 

public void beforeMatchFired(BeforeMatchFiredEvent event) {
    AgendaStatsData data = getRuleStatsInstance( event.getMatch().getRule().getName() );
    this.consolidated.startFireClock();
    data.startFireClock();
}
 

public void beforeMatchFired(BeforeMatchFiredEvent event) {
}
 

@Override
public void beforeMatchFired(BeforeMatchFiredEvent event) {
    
}