@Override
public void start(final Input input, final IGGeneratorCallback callback)
throws InterruptedException {
// find processor mappings for all folders
final Map<FolderType, Map<String, Processor<Element>>> registeredProcessors =
getRegisteredProcessors();
final List<Element> documentRules = new ArrayList<Element>();
final List<Element> schemaQueryRules = new ArrayList<Element>();
// run processors on input, gather IG rules
documentRules.addAll(
getRulesFromInput(input.getDocuments(), registeredProcessors.get(FolderType.DOCUMENT)));
verifySimpleGrammar(documentRules);
schemaQueryRules.addAll(
getRulesFromInput(input.getSchemas(), registeredProcessors.get(FolderType.SCHEMA)));
schemaQueryRules.addAll(
getRulesFromInput(input.getQueries(), registeredProcessors.get(FolderType.QUERY)));
// if there are no schema/query rules, or the next module can handle simple
// grammar, just output all of it without expansion
if (BaseUtils.isEmpty(schemaQueryRules)
|| RunningProject.getNextModuleCaps()
.getCapabilities()
.contains("can.handle.complex.regexps")) {
documentRules.addAll(schemaQueryRules);
// show the rules
RuleDisplayerHelper.showRulesAsync("IG", new CloneHelper().cloneGrammar(documentRules), true);
callback.finished(documentRules);
return;
}
// otherwise, we have to expand
// show the rules before expansion
final List<Element> before = new ArrayList<Element>();
before.addAll(documentRules);
before.addAll(schemaQueryRules);
RuleDisplayerHelper.showRulesAsync("Raw", new CloneHelper().cloneGrammar(before), true);
// lookup expander
final Expander expander = Lookup.getDefault().lookup(Expander.class);
final List<Element> expanded = expander.expand(schemaQueryRules);
final List<Element> ret = new ArrayList<Element>();
ret.addAll(documentRules);
ret.addAll(expanded);
// show the rules after expansion
RuleDisplayerHelper.showRulesAsync("Expanded", new CloneHelper().cloneGrammar(ret), true);
// return expanded
callback.finished(ret);
}
@Override
public void start(
final Input input,
final List<Element> grammar,
final NonGrammaticalInputProcessorCallback callback)
throws InterruptedException {
List<ModuleNode> xquerySyntaxTrees =
(processXQueries(input.getQueries(), getXQueryProcessor()));
LOG.info("Input XQuery files parsed into " + xquerySyntaxTrees.size() + " syntax trees");
final List<InferredTypeStatement> inferredTypes = new ArrayList<InferredTypeStatement>();
final KeysInferrer keysInferrer = new KeysInferrer();
for (final ModuleNode root : xquerySyntaxTrees) {
final SyntaxTreeProcessor syntaxTreeProcessor = new SyntaxTreeProcessor(root);
syntaxTreeProcessor.process();
inferredTypes.addAll(syntaxTreeProcessor.getInferredTypes());
keysInferrer.addJoinPatterns(syntaxTreeProcessor.getJoinPatterns());
keysInferrer.addNegativeUniquenessStatements(
syntaxTreeProcessor.getNegativeUniquenessStatements());
for (final NegativeUniquenessStatement negativeUniquenessStatement :
syntaxTreeProcessor.getNegativeUniquenessStatements()) {
LOG.info(
"Inferred negative uniqueness statement: "
+ negativeUniquenessStatement.getTargetPath()
+ ", weight: "
+ negativeUniquenessStatement.getWeight());
}
}
for (final InferredTypeStatement inferredTypeStatement : inferredTypes) {
final NormalizedPathType path = new NormalizedPathType(inferredTypeStatement.getPathType());
final XSDBuiltinAtomicType inferredType =
((XSDType) inferredTypeStatement.getType()).getAtomicType();
if (path.getInitialStep() != InitialStep.ROOT) {
LOG.error("Inferred type statement should not contain a relative path. Probably a bug.");
}
LOG.info("Inferred type statement: " + path.toString() + " -> " + inferredType);
}
LOG.info("Total number of inferred type statements: " + inferredTypes.size());
keysInferrer.summarize();
final Collection<SummarizedKey> keys = keysInferrer.getKeys();
final Map<Key, Set<ForeignKey>> foreignKeys = keysInferrer.getForeignKeys();
for (final SummarizedKey summarizedKey : keys) {
final Key key = summarizedKey.getKey();
final NormalizedPathType contextPath = key.getContextPath();
if (contextPath != null) {
LOG.info(
"Inferred key: ("
+ contextPath
+ ", "
+ key.getTargetPath()
+ ", {"
+ key.getKeyPath()
+ "}), normalized weight: "
+ summarizedKey.getNormalizedWeight());
} else {
LOG.info(
"Inferred key: ("
+ key.getTargetPath()
+ ", {"
+ key.getKeyPath()
+ "}), normalized weight: "
+ summarizedKey.getNormalizedWeight());
}
}
LOG.info("Total number of inferred key statements: " + keys.size());
final Merger merger = new Merger(grammar);
merger.mergeInferredTypes(inferredTypes);
merger.mergeInferredKeys(keys, foreignKeys);
callback.finished(grammar);
}