protected ViatraQueryEventSource(ViatraQueryEventRealm realm, ViatraQueryEventSourceSpecification<Match> sourceDefinition) { super(sourceDefinition, realm); ViatraQueryMatcher<Match> _matcher = sourceDefinition.getMatcher(realm.getEngine()); this.matcher = _matcher; }
/** * Initializes an attribute monitor listener * @return the prepared attribute monitor listener; must not be null */ protected IAttributeMonitorListener<Match> prepareAttributeMonitorListener() { return atom -> notifyHandlers(new ViatraQueryEvent<Match>(CRUDEventTypeEnum.UPDATED, atom)); }
/** * Creates an event filter that uses the IPatternMatch.isCompatibleWith to check event atoms. * * <p/> Using the matches that are equal will result in equal filters. * * @param filterMatch non-null match to use for filtering * @return the event filter */ public static <Match extends IPatternMatch> EventFilter<Match> newSingleMatchFilter(Match filterMatch) { return ViatraQueryMatchEventFilter.createFilter(filterMatch); }
@Override public void prepareRuleInstance(RuleInstance<Match> ruleInstance, EventFilter<? super Match> filter) { Preconditions.checkArgument(ruleInstance != null, "Cannot prepare null rule instance!"); ViatraQueryEventSource<Match> source = realm.createSource(sourceSpecification); ViatraQueryEventHandler<Match> handler = new ViatraQueryEventHandler<Match>(source, filter, ruleInstance); handler.prepareEventHandler(); }
@Override public void dispose() { getInstance().removeActivationNotificationListener(unregisterListener); ((ViatraQueryEventSource<Match>) getSource()).removeHandler(this); attributeMonitor.dispose(); }
protected AttributeMonitor<Match> prepareAttributeMonitor(){ //return new DefaultAttributeMonitor<Match>(); LightweightAttributeMonitor<Match> monitor = null; ViatraQueryEventSource<Match> eventSource = (ViatraQueryEventSource<Match>) getSource(); try { monitor = new LightweightAttributeMonitor<Match>(eventSource.getMatcher().getEngine().getBaseIndex()); } catch (ViatraQueryException e) { ViatraQueryLoggingUtil.getLogger(getClass()).error("Error happened while accessing base index", e); } return monitor; }
@Override protected void prepareSource() { this.attributeMonitorListener = prepareAttributeMonitorListener(); this.matchUpdateListener = prepareMatchUpdateListener(); }
protected <Match extends IPatternMatch> ViatraQueryEventSource<Match> createSource( EventSourceSpecification<Match> sourceSpecification) { Preconditions.checkArgument(sourceSpecification instanceof ViatraQueryEventSourceSpecification, "Source definition must be ViatraQueryEventSourceSpecification!"); ViatraQueryEventSource<Match> eventSource = new ViatraQueryEventSource<Match>(this, (ViatraQueryEventSourceSpecification<Match>) sourceSpecification); eventSource.prepareSource(); return eventSource; }
/** * Creates a {@link RuleSpecification} with the given query specification, life-cycle and jobs. * * For default life-cycle implementations, see {@link DefaultActivationLifeCycle}. * * @param querySpecification * @param lifecycle * @param jobs */ public static <Match extends IPatternMatch> RuleSpecification<Match> newMatcherRuleSpecification(IQuerySpecification<? extends ViatraQueryMatcher<Match>> querySpecification, ActivationLifeCycle lifecycle, Set<Job<Match>> jobs){ return new RuleSpecification<Match>(ViatraQueryEventRealm.createSourceSpecification(querySpecification), lifecycle, jobs); }
@Override public AbstractRuleInstanceBuilder<Match> getRuleInstanceBuilder(EventRealm realm) { return new ViatraQueryRuleInstanceBuilder<Match>((ViatraQueryEventRealm) realm, this); }
/** * Creates a "multi" event filter that uses the IPatternMatch.isCompatibleWith to check event atoms against a collection * of filter (partial) matches. The possible semantics are documented in {@link ViatraQueryFilterSemantics}. * * @param filterMatches non-null match to use for filtering * @param semantics the filter semantics to use * @return the event filter */ public static <Match extends IPatternMatch> EventFilter<Match> newMultiMatchFilter(Collection<Match> filterMatches, ViatraQueryFilterSemantics semantics) { return ViatraQueryMultiMatchEventFilter.createFilter(filterMatches, semantics); }
protected UnregisterMonitorActivationNotificationListener prepareActivationNotificationListener() { return new UnregisterMonitorActivationNotificationListener(); }
public static <Match extends IPatternMatch> ViatraQueryEventSourceSpecification<Match> createSourceSpecification(IQuerySpecification<? extends ViatraQueryMatcher<Match>> factory){ return new ViatraQueryEventSourceSpecification<Match>(factory); }
public static ViatraQueryEventRealm create(ViatraQueryEngine engine) { return new ViatraQueryEventRealm(engine); }
/** * Creates a new rule engine that is initialized over the given * ViatraQueryEngine and an agenda without rules. * @param engine * @return the prepared rule engine */ public static RuleEngine createViatraQueryRuleEngine(final ViatraQueryEngine engine) { return EventDrivenVM.createRuleEngine(ViatraQueryEventRealm.create(engine)); }
@Override protected void activationExists(Event<Match> event, Activation<Match> activation) { getInstance().activationStateTransition(activation, CRUDEventTypeEnum.UPDATED); }
@Override protected void activationExists(Event<Match> event, Activation<Match> activation) { getInstance().activationStateTransition(activation, CRUDEventTypeEnum.CREATED); }
@Override protected void activationExists(Event<Match> event, Activation<Match> activation) { getInstance().activationStateTransition(activation, CRUDEventTypeEnum.DELETED); }
/** * Initializes the corresponding match update listener * @return the prepared update listener; must not be null */ protected IMatchUpdateListener<Match> prepareMatchUpdateListener(){ Consumer<Match> matchAppearProcessor = match -> notifyHandlers(new ViatraQueryEvent<Match>(CRUDEventTypeEnum.CREATED, match)); Consumer<Match> matchDisppearProcessor = match -> notifyHandlers(new ViatraQueryEvent<Match>(CRUDEventTypeEnum.DELETED, match)); return new MatchUpdateAdapter<Match>(matchAppearProcessor, matchDisppearProcessor); }
/** * Creates a {@link RuleSpecification} with the given query specification, life-cycle and jobs and name. * * For default life-cycle implementations, see {@link DefaultActivationLifeCycle}. * * @param querySpecification * @param lifecycle * @param jobs * @param name */ public static <Match extends IPatternMatch> RuleSpecification<Match> newMatcherRuleSpecification(IQuerySpecification<? extends ViatraQueryMatcher<Match>> querySpecification, ActivationLifeCycle lifecycle, Set<Job<Match>> jobs, String name){ return new RuleSpecification<Match>(ViatraQueryEventRealm.createSourceSpecification(querySpecification), lifecycle, jobs, name); }