@Override public void error(String message, EObject source, EStructuralFeature feature, String code, String... issueData) { super.error(message, source, feature, code, issueData); } }
private void validateJavaFeatureAccess(Class<?> clazz, String[] nameTokens, Expression context, IIssueCallback validator) { if (nameTokens.length != 1) { validator.error("For Java objects parameters no feature access is supported.", context, PatternLanguagePackage.Literals.STRING_VALUE__VALUE, GENERAL_ISSUE_CODE); } }
@Override protected MethodWrapper createMethodWrapper(AbstractDeclarativeValidator instanceToUse, Method method) { return new CustomMethodWrapper(instanceToUse, method, logger); }
public void logAllMessages(Logger logger) { logErrors(logger); for (Issue diag : foundWarnings) { logger.warn(stringRepresentation(diag)); } }
public Iterable<Issue> getAllDiagnostics() { return Iterables.concat(diag.getAllErrors(), diag.getAllWarnings()); }
@Check public void checkVariableType(Variable variable) { if (PatternLanguageHelper.isParameter(variable)) { checkParameterTypes(variable); } else { checkPatternVariablesType(variable); } }
public Iterable<Issue> getWarnings() { return diag.getAllWarnings(); }
public Iterable<Issue> getErrors() { return diag.getAllErrors(); }
/** * Returns the validation results of a single pattern * * @param pattern * @since 2.0 */ public PatternSetValidationDiagnostics validate(Pattern pattern) { return validate(ImmutableList.of(pattern)); }
/** * This validator looks up all variables in the {@link FunctionEvaluationValue} and reports an error if one them is * not an {@link EDataType} instance. We do not allow arbitrary EMF elements in, so the checks are less likely to * have side-effects. */ @Check public void checkForWrongVariablesInXExpressions(FunctionEvaluationValue eval) { checkForWrongVariablesInXExpressionsInternal(eval.getExpression()); }
@Check(CheckType.NORMAL) public void checkForImpureJavaCallsInCheckConstraints(CheckConstraint checkConstraint) { if (checkConstraint.getExpression() != null) { checkForImpureJavaCallsInternal(checkConstraint.getExpression()); } }
@Override public void warning(String message, EObject source, EStructuralFeature feature, String code, String... issueData) { super.warning(message, source, feature, code, issueData); }
public void logErrors(Logger logger) { for (Issue diag : foundErrors) { logger.error(stringRepresentation(diag)); } }
@Override protected List<EPackage> getEPackages() { // PatternLanguagePackage must be added to the defaults, otherwise the core language validators not used in the // validation process List<EPackage> result = super.getEPackages(); result.add(PatternLanguagePackage.eINSTANCE); return result; }
private void validateClassifierFeatureAccess(EClassifier classifier, String[] nameTokens, Expression context, IIssueCallback validator) { if (nameTokens.length == 1) { checkClassifierFeature(classifier, "name", context, validator, false); } else if (nameTokens.length == 2) { String featureName = nameTokens[1]; checkClassifierFeature(classifier, featureName, context, validator, true); } else { validator.error("Only direct feature references are supported.", context, PatternLanguagePackage.Literals.STRING_VALUE__VALUE, GENERAL_ISSUE_CODE); } }
public boolean hasWarning() { return !diag.getAllWarnings().isEmpty(); }
public boolean hasError() { return !diag.getAllErrors().isEmpty(); }
/** * Returns the validation results of a single pattern and all its (transitively )referenced patterns. * * @param pattern * @since 2.0 */ public PatternSetValidationDiagnostics validateTransitively(Pattern pattern) { Set<Pattern> patternsToValidate = PatternLanguageHelper.getReferencedPatternsTransitive(pattern); return validate(patternsToValidate); }
/** * This validator looks up all variables in the {@link CheckConstraint} and reports an error if one them is not an * {@link EDataType} instance. We do not allow arbitrary EMF elements in, so the checks are less likely to have * side-effects. */ @Check public void checkForWrongVariablesInXExpressions(CheckConstraint checkConstraint) { checkForWrongVariablesInXExpressionsInternal(checkConstraint.getExpression()); }
@Check(CheckType.NORMAL) public void checkForImpureJavaCallsInEvalExpressions(FunctionEvaluationValue eval) { if (eval.getExpression() != null) { checkForImpureJavaCallsInternal(eval.getExpression()); } }