public String executeDemo_GenericAPI(String modelPath, String patternFQN) {
 final StringBuilder results = new StringBuilder();
 Resource resource = loadModel(modelPath);
 if (resource != null) {
  try {
   // get all matches of the pattern
   // create an *unmanaged* engine to ensure that noone else is going
   // to use our engine
   IncQueryEngine engine = EngineManager.getInstance().createUnmanagedIncQueryEngine(resource);
   // instantiate a pattern matcher through the registry, by only knowing its FQN
   IncQueryMatcher<? extends IPatternMatch> matcher = MatcherFactoryRegistry.getMatcherFactory(patternFQN).getMatcher(engine);
   // assuming that there is a pattern definition registered matching 'patternFQN'
   if (matcher!=null) {
    Collection<? extends IPatternMatch> matches = matcher.getAllMatches();
    prettyPrintMatches(results, matches);
   }
   // wipe the engine
   engine.wipe();
   // after a wipe, new patterns can be rebuilt with much less overhead than 
   // complete traversal (as the base indexes will be kept)
   // completely dispose of the engine once's it is not needed
   engine.dispose();
   resource.unload();
  } catch (IncQueryException e) {
   e.printStackTrace();
   results.append(e.getMessage());
  } 
 } else {
  results.append("Resource not found");
 }
 return results.toString();
}

private void changeProcessing_lowlevel(final StringBuilder results, IncQueryMatcher<? extends IPatternMatch> matcher) {
 // (+) these update callbacks are called whenever there is an actual change in the
 // result set of the pattern you are interested in. Hence, they are called fewer times
 // than the "afterUpdates" option, giving better performance.
 // (-)  the downside is that the callbacks are *not* guaranteed to be called in a consistent
 // state (i.e. when the update propagation is settled), hence
 //  * you must not invoke pattern matching and model manipulation _inside_ the callback method
 //  * the callbacks might encounter "hazards", i.e. when an appearance is followed immediately by a disappearance.
 matcher.addCallbackOnMatchUpdate(new IMatchUpdateListener<IPatternMatch>() {
  @Override
  public void notifyAppearance(IPatternMatch match) {
   results.append("\tNew match found by changeset low level callback: " + match.prettyPrint()+"\n");
  }
 }, false);
}

 
private void changeProcessing_deltaMonitor(final StringBuilder results, IncQueryMatcher<? extends IPatternMatch> matcher) {
 final DeltaMonitor<? extends IPatternMatch> dm = matcher.newDeltaMonitor(false);
 // (+) these updates are guaranteed to be called in a *consistent* state,
 // i.e. when the pattern matcher is guaranteed to be consistent with the model
 // anything can be written into the callback method
 // (-) the downside is that the callback is called after *every* update
 // that propagates through the matcher, i.e. also when the updates do not actually
 // influence the result set you are interested in. Hence, the performance is somewhat
 // lower than for the "lowlevel" option.
 matcher.addCallbackAfterUpdates(new Runnable() {
  @Override
  public void run() {
   for (IPatternMatch newMatch : dm.matchFoundEvents) {
    results.append("\tNew match found by changeset delta monitor: " + newMatch.prettyPrint()+"\n");
   }
}