super.addConnectiveFieldRestriction(buf, type, fieldType,
@Override protected void generateConstraint(final FieldConstraint constr, final LHSGeneratorContext gctx) { boolean generateTemplateCheck = isTemplateKey(constr); if (generateTemplateCheck) { if (constr instanceof SingleFieldConstraint && ((SingleFieldConstraint) constr).getConnectives() != null) { // if there are connectives, and the first is a template key, then all templates keys must be checked up front // individual connectives, that have template keys, will still need to be checked too. SingleFieldConstraint sconstr = (SingleFieldConstraint) constr; buf.append("@if{" + ((SingleFieldConstraint) constr).getValue() + " != empty"); for (int j = 0; j < sconstr.getConnectives().length; j++) { final ConnectiveConstraint conn = sconstr.getConnectives()[j]; if (conn.getConstraintValueType() == BaseSingleFieldConstraint.TYPE_TEMPLATE) { buf.append(" || " + conn.getValue() + " != empty"); } } buf.append("}"); } else { buf.append("@if{" + ((SingleFieldConstraint) constr).getValue() + " != empty}"); } } buf.append("@code{hasLHSOutput" + gctx.getDepth() + "_" + gctx.getOffset() + " = true}"); super.generateConstraint(constr, gctx); if (generateTemplateCheck) { buf.append("@end{}"); } }
@Override public void visitFreeFormLine(final FreeFormLine ffl) { if (ffl.getText() == null) { return; } final Matcher matcherTemplateKey = patternTemplateKey.matcher(ffl.getText()); boolean found = matcherTemplateKey.find(); if (found) { buf.append("@if{"); boolean addAnd = false; while (found) { String varName = matcherTemplateKey.group(1); if (addAnd) { buf.append(" && "); } buf.append(varName + " != empty"); addAnd = true; found = matcherTemplateKey.find(); } buf.append("}"); super.visitFreeFormLine(ffl); buf.append("@end{}"); } else { // no variables found super.visitFreeFormLine(ffl); } }
final LHSGeneratorContext gctx = generatorContextFactory.newChildGeneratorContext(rootContext, pattern.getFactPattern()); generateFactPattern(pattern.getFactPattern(), gctx); if (pattern.getSourcePattern() instanceof FactPattern) { final LHSGeneratorContext soucrceGctx = generatorContextFactory.newGeneratorContext(); generateFactPattern((FactPattern) pattern.getSourcePattern(), soucrceGctx); } else if (pattern.getSourcePattern() instanceof FromAccumulateCompositeFactPattern) { visitFromAccumulateCompositeFactPattern((FromAccumulateCompositeFactPattern) pattern.getSourcePattern(), _isSubPattern); } else if (pattern.getSourcePattern() instanceof FromCollectCompositeFactPattern) { visitFromCollectCompositeFactPattern((FromCollectCompositeFactPattern) pattern.getSourcePattern(), _isSubPattern); } else if (pattern.getSourcePattern() instanceof FromEntryPointFactPattern) { visitFromEntryPointFactPattern((FromEntryPointFactPattern) pattern.getSourcePattern(), _isSubPattern); } else if (pattern.getSourcePattern() instanceof FromCompositeFactPattern) { visitFromCompositeFactPattern((FromCompositeFactPattern) pattern.getSourcePattern(), _isSubPattern); } else {
buf.append(buildOperatorParameterDRL(parameters)); buildReturnValueFieldValue(value, buf); break; case BaseSingleFieldConstraint.TYPE_LITERAL: buildLiteralFieldValue(operator, type, fieldType, break; case BaseSingleFieldConstraint.TYPE_EXPR_BUILDER_VALUE: buildExpressionFieldValue(expression, buf); break; case BaseSingleFieldConstraint.TYPE_TEMPLATE: buildTemplateFieldValue(operator, type, fieldType, break; case BaseSingleFieldConstraint.TYPE_ENUM: buildEnumFieldValue(operator, type, fieldType, break; default: buildDefaultFieldValue(operator,
generateSeparator(con, parentContext); if (con instanceof CompositeFieldConstraint) { LHSGeneratorContext nestedGctx = generatorContextFactory.newChildGeneratorContext(parentContext, con); preGenerateNestedConstraint(nestedGctx); if (parentContext.getParent().getFieldConstraint() instanceof CompositeFieldConstraint) { buf.append("( "); generateConstraint(nestedConstr, gctx); buf.append(")"); postGenerateNestedConstraint(parentContext); generateSingleFieldConstraint((SingleFieldConstraint) con, parentContext);
super.visitFromCollectCompositeFactPattern(pattern, isSubPattern); buf.append("@end{}"); } else { super.visitFromCollectCompositeFactPattern(pattern, isSubPattern); super.visitFromCollectCompositeFactPattern(pattern, isSubPattern);
final LHSGeneratorContext gctx = generatorContextFactory.newChildGeneratorContext(rootContext, pattern.getFactPattern()); generateFactPattern(pattern.getFactPattern(), gctx); generateFactPattern((FactPattern) pattern.getRightPattern(), generatorContextFactory.newGeneratorContext()); } else if (pattern.getRightPattern() instanceof FromAccumulateCompositeFactPattern) { visitFromAccumulateCompositeFactPattern((FromAccumulateCompositeFactPattern) pattern.getRightPattern(), _isSubPattern); } else if (pattern.getRightPattern() instanceof FromCollectCompositeFactPattern) { visitFromCollectCompositeFactPattern((FromCollectCompositeFactPattern) pattern.getRightPattern(), _isSubPattern); } else if (pattern.getRightPattern() instanceof FromEntryPointFactPattern) { visitFromEntryPointFactPattern((FromEntryPointFactPattern) pattern.getRightPattern(), _isSubPattern); } else if (pattern.getRightPattern() instanceof FromCompositeFactPattern) { visitFromCompositeFactPattern((FromCompositeFactPattern) pattern.getRightPattern(), _isSubPattern); } else if (pattern.getRightPattern() instanceof FreeFormLine) { visitFreeFormLine((FreeFormLine) pattern.getRightPattern()); } else { throw new IllegalArgumentException("Unsupported pattern " + pattern.getRightPattern() + " for FROM COLLECT");
assertConstraintValue(constr); if (isConstraintComplete(constr)) { if (constr instanceof SingleFieldConstraintEBLeftSide) { final SingleFieldConstraintEBLeftSide sfcexp = ((SingleFieldConstraintEBLeftSide) constr); generateNormalFieldRestriction(constr, parameters); } else { generateConnectiveFieldRestriction(constr, parameters, gctx);
if (constr instanceof SingleFieldConstraintEBLeftSide) { SingleFieldConstraintEBLeftSide sfexp = (SingleFieldConstraintEBLeftSide) constr; addConnectiveFieldRestriction(buf, sfexp.getConstraintValueType(), sfexp.getExpressionLeftSide().getGenericType(), true); } else { addConnectiveFieldRestriction(buf, constr.getConstraintValueType(), constr.getFieldType(), final Map<String, String> connectiveParameters = conn.getParameters(); addConnectiveFieldRestriction(buf, conn.getConstraintValueType(), conn.getFieldType(),
protected void addConnectiveFieldRestriction(final StringBuilder buf, final int type, final String fieldType, final String operator, final Map<String, String> parameters, final String value, final ExpressionFormLine expression, final LHSGeneratorContext gctx, final boolean spaceBeforeOperator) { String _operator = operator; boolean generateTemplateCheck = type == BaseSingleFieldConstraint.TYPE_TEMPLATE; if (generateTemplateCheck && !gctx.isHasOutput() && operator.startsWith("||") || operator.startsWith("&&")) { _operator = _operator.substring(2); } super.addConnectiveFieldRestriction(buf, type, fieldType, _operator, parameters, value, expression, gctx, true); }
private void renderSubPattern(final CompositeFactPattern pattern, final int subIndex) { if (pattern.getPatterns() == null || pattern.getPatterns().length == 0) { return; } IFactPattern subPattern = pattern.getPatterns()[subIndex]; if (subPattern instanceof FactPattern) { final LHSGeneratorContext gctx = generatorContextFactory.newChildGeneratorContext(rootContext, subPattern); this.generateFactPattern((FactPattern) subPattern, gctx); } else if (subPattern instanceof FromAccumulateCompositeFactPattern) { this.visitFromAccumulateCompositeFactPattern((FromAccumulateCompositeFactPattern) subPattern, true); } else if (subPattern instanceof FromCollectCompositeFactPattern) { this.visitFromCollectCompositeFactPattern((FromCollectCompositeFactPattern) subPattern, true); } else if (subPattern instanceof FromCompositeFactPattern) { this.visitFromCompositeFactPattern((FromCompositeFactPattern) subPattern, true); } else { throw new IllegalStateException("Unsupported Pattern: " + subPattern.getClass().getName()); } }
private void generateNormalFieldRestriction(final SingleFieldConstraint constr, final Map<String, String> parameters) { if (constr instanceof SingleFieldConstraintEBLeftSide) { SingleFieldConstraintEBLeftSide sfexp = (SingleFieldConstraintEBLeftSide) constr; addFieldRestriction(buf, sfexp.getConstraintValueType(), sfexp.getExpressionLeftSide().getGenericType(), sfexp.getOperator(), parameters, sfexp.getValue(), sfexp.getExpressionValue(), true); } else { addFieldRestriction(buf, constr.getConstraintValueType(), constr.getFieldType(), constr.getOperator(), parameters, constr.getValue(), constr.getExpressionValue(), true); } }
@Override public void visitFreeFormLine(final FreeFormLine ffl) { StringBuffer interpolatedResult = new StringBuffer(); final Matcher matcherTemplateKey = patternTemplateKey.matcher(ffl.getText()); while (matcherTemplateKey.find()) { String varName = matcherTemplateKey.group(1); String value = rowDataProvider.getTemplateKeyValue(varName); // All vars must be populated for a single FreeFormLine if (StringUtils.isEmpty(value)) { return; } matcherTemplateKey.appendReplacement(interpolatedResult, value); } matcherTemplateKey.appendTail(interpolatedResult); //Don't update the original FreeFormLine object FreeFormLine fflClone = new FreeFormLine(); fflClone.setText(interpolatedResult.toString()); super.visitFreeFormLine(fflClone); }
public void visitFromCollectCompositeFactPattern(final FromCollectCompositeFactPattern pattern, final boolean isSubPattern) { if (pattern.getRightPattern() instanceof FreeFormLine) { // must skip the collect, if the any variable is empty for the FFL final FreeFormLine ffl = (FreeFormLine) pattern.getRightPattern(); final Matcher matcherTemplateKey = patternTemplateKey.matcher(ffl.getText()); while (matcherTemplateKey.find()) { String varName = matcherTemplateKey.group(1); String value = rowDataProvider.getTemplateKeyValue(varName); // All vars must be populated for a single FreeFormLine if (StringUtils.isEmpty(value)) { return; } } } super.visitFromCollectCompositeFactPattern(pattern, isSubPattern); } }
protected void addConnectiveFieldRestriction(final StringBuilder buf, final int type, final String fieldType, final String operator, final Map<String, String> parameters, final String value, final ExpressionFormLine expression, LHSGeneratorContext gctx, final boolean spaceBeforeOperator) { addFieldRestriction(buf, type, fieldType, operator, parameters, value, expression, spaceBeforeOperator); }
private void generateConstraints(final FactPattern pattern, final LHSGeneratorContext parentContext) { LHSGeneratorContext gctx = null; for (int constraintIndex = 0; constraintIndex < pattern.getFieldConstraints().length; constraintIndex++) { FieldConstraint constr = pattern.getConstraintList().getConstraints()[constraintIndex]; if (constraintIndex == 0) { gctx = generatorContextFactory.newChildGeneratorContext(parentContext, constr); } else { gctx = generatorContextFactory.newPeerGeneratorContext(gctx, constr); } generateConstraint(constr, gctx); } }
protected LHSPatternVisitor getLHSPatternVisitor(final boolean isDSLEnhanced, final StringBuilder buf, final String nestedIndentation, final boolean isNegated, final LHSGeneratorContextFactory generatorContextFactory) { return new LHSPatternVisitor(isDSLEnhanced, bindingsPatterns, bindingsFields, constraintValueBuilder, generatorContextFactory, buf, nestedIndentation, isNegated); }
public void visitFromCollectCompositeFactPattern(final FromCollectCompositeFactPattern pattern) { visitFromCollectCompositeFactPattern(pattern, generatorContextFactory.getMaximumDepth() > 1); }
@Override protected void generateConstraint(final FieldConstraint constr, final LHSGeneratorContext gctx) { if (isValidFieldConstraint(constr)) { super.generateConstraint(constr, gctx); } }