The Event-driven Virtual Machine

/* Precondition for add generalization rule */
pattern possibleSuperClass(cl : Class, sup : Class) {
	neg find superClass(cl, _otherSup);
	neg find superClass(_cl2, sup);
}
/* Precondition for create owned operation */
pattern onlyInheritedOperations(cl : Class) {
	find hasOperation(cl, _op);
	neg find ownsOperation(cl, _ownOp);
}

// the job specifies what to do when an activation is fired in the given state
Job job = Jobs.newStatelessJob(CRUDActivationStateEnum.APPEARED, new PossibleSuperClassProcessor() {
  @Override
  public void process(Class cl, Class sup) {
    System.out.println("Found cl " + cl + " without superclass");
    Generalization generalization = UMLFactory.eINSTANCE.createGeneralization();
    generalization.setGeneral(sup);
    generalization.setSpecific(cl);
  }
});
// the life-cycle determines how events affect the state of activations
DefaultActivationLifeCycle lifecycle = DefaultActivationLifeCycle.DEFAULT_NO_UPDATE_AND_DISAPPEAR;
// the factory is used to initialize the matcher for the precondition
IMatcherFactory<PossibleSuperClassMatcher> factory = PossibleSuperClassMatcher.factory();
// the rule specification is a model-independent definition that can be used to instantiate a rule
RuleSpecification spec = Rules.newSimpleMatcherRuleSpecification(factory, lifecycle, Sets.newHashSet(job));

Job job = Jobs.newStatelessJob(CRUDActivationStateEnum.APPEARED, new OnlyInheritedOperationsProcessor() {
  @Override
  public void process(Class cl) {
    System.out.println("Found class " + cl + " without operation");
    Operation operation = UMLFactory.eINSTANCE.createOperation();
    operation.setName("newOp");
    operation.setClass_(cl);
  }
});
DefaultActivationLifeCycle lifecycle = DefaultActivationLifeCycle.DEFAULT_NO_UPDATE_AND_DISAPPEAR;
IMatcherFactory<OnlyInheritedOperationsMatcher> factory = OnlyInheritedOperationsMatcher.factory();
RuleSpecification spec = Rules.newSimpleMatcherRuleSpecification(factory, lifecycle, Sets.newHashSet(job));

// create rule engine over query engine
RuleEngine ruleEngine = RuleEngines.createViatraQueryRuleEngine(engine);
// create context for execution
Context context = Context.create();
// prepare rule specifications
RuleSpecification createGeneralization = getCreateGeneralizationRule();
RuleSpecification createOperation = getCreateOperationRule();
// add rule specifications to engine
ruleEngine.addRule(createGeneralization);
ruleEngine.addRule(createOperation);

// check rule applicability
Set<Activation> createClassesActivations = ruleEngine.getActivations(createGeneralization);
if (!createClassesActivations.isEmpty()) {
    // fire activation of a given rule
    createClassesActivations.iterator().next().fire(context);
}
// check for any applicable rules
while (!ruleEngine.getConflictingActivations().isEmpty()) {
    // fire next activation as long as possible
    ruleEngine.getNextActivation().fire(context);
}

// rules that are no longer needed can be removed
ruleEngine.removeRule(createGeneralization);
// rule engine manages the activations of the added rules until disposed
ruleEngine.dispose();

// use IQBase update callback for scheduling execution
UpdateCompleteBasedSchedulerFactory schedulerFactory = Schedulers.getIQEngineSchedulerFactory(engine);
// create execution schema over ViatraQueryEngine
ExecutionSchema executionSchema = ExecutionSchemas.createViatraQueryExecutionSchema(engine, schedulerFactory);
// prepare rule specifications
RuleSpecification createGeneralization = getCreateGeneralizationRule();
RuleSpecification createOperation = getCreateOperationRule();
// add rule specifications to engine
executionSchema.addRule(createGeneralization);
executionSchema.addRule(createOperation);

// execution schema waits for a scheduling to fire activations
// we trigger this by removing one generalization at random
SuperClassMatcher.factory().getMatcher(engine).forOneArbitraryMatch(new SuperClassProcessor() {
    @Override
    public void process(Class sub, Class sup) {
        sub.getGeneralizations().remove(0);
    }
});

// rules that are no longer needed can be removed
executionSchema.removeRule(createGeneralization);
// execution schema manages and fires the activations of the added
// rules until disposed
executionSchema.dispose();

// just set the log level of the engine as needed
ruleEngine.getLogger().setLevel(Level.DEBUG);

public RuleEngine createAdaptableRuleEngine(ViatraQueryEngine queryEngine) {
        //Create an adaptable conflict resolver that wraps a default arbitrary conflict resolver
        //If an adaptable conflict resolver is not needed, create the arbitrary conflict resolver
        AdaptableConflictResolver conflictResolver = new AdaptableConflictResolver(new ArbitraryOrderConflictResolver(),
                this);

        //Create an agenda based on the created conflict resolver regardless of adaptability
        Agenda debugAgenda = new Agenda(conflictResolver);
        //Set the used activation state change listener. At this point either an adaptable listener, or a default listener can be handed to the Agenda.
        //Note, that the adaptable listener wraps the default one
        debugAgenda.setActivationListener(
                new AdaptableActivationNotificationListener(debugAgenda.getActivationListener(), this));

        //Create an adaptable rule based based on the created adaptable or default EVM components.
        //If listening to rule additions is not needed the adaptable RuleBase can be replaced with an EVM default one.
        RuleBase debugRulebase = new AdaptableRuleBase(ViatraQueryEventRealm.create(queryEngine), debugAgenda, this);

        //Create the RuleEngine based on the rule base.
        return RuleEngine.create(debugRulebase);
    }
</source>

public ExecutionSchema createAdaptableExecutionSchema(ViatraQueryEngine queryEngine,
            ISchedulerFactory schedulerFactory, ConflictResolver conflictResolver) {

        //Create an adaptable executor that wraps a default EVM executor
        //If an adaptable Executor is not needed, create the default EVM one.
        IExecutor executor = new AdaptableExecutor(new Executor(), this);

        //Create an adaptable conflict resolver that wraps a default arbitrary conflict resolver
        //If an adaptable conflict resolver is not needed, create the arbitrary conflict resolver
        ConflictResolver adaptableConflictResolver = new AdaptableConflictResolver(conflictResolver, this);

        //Create an agenda based on the created conflict resolver regardless of adaptability
        Agenda debugAgenda = new Agenda(adaptableConflictResolver);
        //Set the used activation state change listener. At this point either an adaptable listener, or a default listener can be handed to the Agenda.
        //Note, that the adaptable listener wraps the default one
        debugAgenda.setActivationListener(
                new AdaptableActivationNotificationListener(debugAgenda.getActivationListener(), this));

        //Create an adaptable rule based based on the created adaptable or default EVM components.
        //If listening to rule additions is not needed the adaptable RuleBase can be replaced with an EVM default one.
        RuleBase debugRulebase = new AdaptableRuleBase(ViatraQueryEventRealm.create(queryEngine), debugAgenda, this);

        //Create a scheduled execution instance based on the executor and rule base objects. (regardless of adaptability)
        //The scheduled execution is responsible for handling scheduling reentry.
        ScheduledExecution execution = new ScheduledExecution(debugRulebase, executor);

        //Create a scheduler instance based on the scheduled execution object. (regardless of adaptability)
        Scheduler scheduler = schedulerFactory.prepareScheduler(execution);

        //Create execution schema
        final ExecutionSchema schema = ExecutionSchema.create(scheduler);
        //Ser the conflcit resolve of the schema
        schema.setConflictResolver(adaptableConflictResolver);
        return schema;
}