/** * Returns the parameter of a pattern by name * * @param pattern * @param name * @return the requested parameter of the pattern, or null if none exists * @since 0.7.0 */ public static Variable getParameterByName(final Pattern pattern, final String name) { return Iterables.find(pattern.getParameters(), new Predicate<Variable>() { @Override public boolean apply(Variable variable) { return name.equals(variable.getName()); } }, null); }
@Override public List<PParameter> getParameters() { return Lists.transform(pattern.getParameters(), new Function<Variable, PParameter>() { @Override public PParameter apply(Variable var) { if (var == null) { return new PParameter("", ""); } else { IEMFTypeProvider typeProvider = XtextInjectorProvider.INSTANCE.getInjector().getInstance(IEMFTypeProvider.class); JvmTypeReference ref = typeProvider.getVariableType(var); // bug 411866: JvmUnknownTypeReference.getType() returns null in Xtext 2.4 String clazz = (ref == null || ref instanceof JvmUnknownTypeReference) ? "" : ref.getType() .getQualifiedName(); return new PParameter(var.getName(), clazz); } } }); }
/** Compiles a map for name-based lookup of symbolic parameter positions. */ public static Map<String, Integer> getParameterPositionsByName(Pattern pattern) { EList<Variable> parameters = pattern.getParameters(); Map<String, Integer> posMapping = new HashMap<String, Integer>(); int parameterPosition = 0; for (Variable parameter : parameters) { posMapping.put(parameter.getName(), parameterPosition++); } return posMapping; }
private String getFormattedPattern(Pattern pattern) { StringBuilder builder = new StringBuilder(); builder.append(pattern.getName()); builder.append("("); for (Iterator<Variable> iter = pattern.getParameters().iterator(); iter.hasNext();) { builder.append(iter.next().getName()); if (iter.hasNext()) { builder.append(", "); } } builder.append(")"); return builder.toString(); }
@Check public void checkPatternParameters(Pattern pattern) { if (pattern.getParameters().size() == 0) { warning("Parameterless patterns can only be used to check for existence of a condition.", PatternLanguagePackage.Literals.PATTERN__NAME, IssueCodes.MISSING_PATTERN_PARAMETERS); // As no duplicate parameters are available, returning now return; } for (int i = 0; i < pattern.getParameters().size(); ++i) { String leftParameterName = pattern.getParameters().get(i).getName(); for (int j = i + 1; j < pattern.getParameters().size(); ++j) { if (equal(leftParameterName, pattern.getParameters().get(j).getName())) { error(DUPLICATE_VARIABLE_MESSAGE + leftParameterName, PatternLanguagePackage.Literals.PATTERN__PARAMETERS, i, IssueCodes.DUPLICATE_PATTERN_PARAMETER_NAME); error(DUPLICATE_VARIABLE_MESSAGE + leftParameterName, PatternLanguagePackage.Literals.PATTERN__PARAMETERS, j, IssueCodes.DUPLICATE_PATTERN_PARAMETER_NAME); } } } }
@Check public void checkParametersNamed(Pattern pattern) { for (Variable var : pattern.getParameters()) { if (var.getName() != null && var.getName().startsWith("_")) { error("Parameter name must not start with _", var, PatternLanguagePackage.Literals.VARIABLE__NAME, EMFIssueCodes.SINGLEUSE_PARAMETER); } } }
private void preprocessParameters(final PatternBody body, PatternModelAcceptor<?> acceptor) { EList<Variable> parameters = pattern.getParameters(); for (Variable variable : parameters) { if (variable.getType() != null && variable.getType() instanceof ClassType) { EClassifier classifier = ((ClassType) variable.getType()).getClassname(); IInputKey inputKey = classifierToInputKey(classifier); acceptor.acceptTypeConstraint(ImmutableList.of(variable.getName()), inputKey); } } acceptor.acceptExportedParameters(parameters); }
/** * This validator checks if the literal or computational values match the pattern call's type. * * @param patternCall */ @Check public void checkForWrongLiteralAndComputationValuesInPatternCalls(PatternCall patternCall) { if (patternCall.getParameters().size() != patternCall.getPatternRef().getParameters().size()) { //This kind of error is detected in another place, however it throws an exception during literal checks return; } // Find and neg find (including count find as well) for (ValueReference valueReference : patternCall.getParameters()) { if (valueReference instanceof LiteralValueReference || valueReference instanceof ComputationValue) { Pattern pattern = patternCall.getPatternRef(); Variable variable = pattern.getParameters().get(patternCall.getParameters().indexOf(valueReference)); EClassifier typeClassifier = emfTypeProvider.getClassifierForVariable(variable); EClassifier inputClassifier = emfTypeProvider .getClassifierForLiteralComputationEnumValueReference(valueReference); if (!isCompatibleClassifiers(typeClassifier, inputClassifier)) { final String typeClassifierName = typeClassifier == null ? "(unknown)" : typeClassifier.getInstanceClassName(); error("The type inferred from the called pattern (" + typeClassifierName + ") is different from the input literal/computational value (" + inputClassifier.getInstanceClassName() + ").", patternCall, null, EMFIssueCodes.LITERAL_OR_COMPUTATION_TYPE_MISMATCH_IN_PATTERN_CALL); } } } }
/** * <!-- begin-user-doc --> * <!-- end-user-doc --> * @generated */ public Variable getVariable() { if (variable == null) { InternalEObject container = this.eContainer; while (container != null && !(container instanceof org.eclipse.incquery.patternlanguage.patternLanguage.PatternBody || container instanceof org.eclipse.incquery.patternlanguage.patternLanguage.Pattern)) { container = container.eInternalContainer(); } if (container instanceof org.eclipse.incquery.patternlanguage.patternLanguage.PatternBody) { //The side-effect of this call initializes the variable ((org.eclipse.incquery.patternlanguage.patternLanguage.PatternBody) container).getVariables(); } else if (container instanceof org.eclipse.incquery.patternlanguage.patternLanguage.Pattern) { org.eclipse.incquery.patternlanguage.patternLanguage.Pattern pattern = (org.eclipse.incquery.patternlanguage.patternLanguage.Pattern) container; for (org.eclipse.incquery.patternlanguage.patternLanguage.Variable var : pattern.getParameters()) { if (var.getName() != null && var.getName().equals(getVar())) { setVariable(var); } } } } return variable; }
@Check public void checkPatternCallParameters(PatternCall call) { if (call.getPatternRef() != null && call.getPatternRef().getName() != null && call.getParameters() != null) { final int definitionParameterSize = call.getPatternRef().getParameters().size(); final int callParameterSize = call.getParameters().size(); if (definitionParameterSize != callParameterSize) { error("The pattern " + getFormattedPattern(call.getPatternRef()) + " is not applicable for the arguments(" + getFormattedArgumentsList(call) + ")", PatternLanguagePackage.Literals.PATTERN_CALL__PATTERN_REF, IssueCodes.WRONG_NUMBER_PATTERNCALL_PARAMETER); } } }
@Override public void apply(final JvmOperation it) { JvmTypeReference _typeRef = PatternMatchProcessorClassInferrer.this.builder.typeRef(Void.TYPE); it.setReturnType(_typeRef); CharSequence _javadocProcessMethod = PatternMatchProcessorClassInferrer.this._javadocInferrer.javadocProcessMethod(pattern); String _string = _javadocProcessMethod.toString(); PatternMatchProcessorClassInferrer.this._eMFJvmTypesBuilder.setDocumentation(it, _string); it.setAbstract(true); EList<Variable> _parameters = pattern.getParameters(); for (final Variable parameter : _parameters) { EList<JvmFormalParameter> _parameters_1 = it.getParameters(); String _parameterName = PatternMatchProcessorClassInferrer.this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(parameter); JvmTypeReference _calculateType = PatternMatchProcessorClassInferrer.this._eMFPatternLanguageJvmModelInferrerUtil.calculateType(parameter); JvmFormalParameter _parameter = PatternMatchProcessorClassInferrer.this._eMFJvmTypesBuilder.toParameter(parameter, _parameterName, _calculateType); PatternMatchProcessorClassInferrer.this._eMFJvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters_1, _parameter); } } };
public CharSequence javadocProcessMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Defines the action that is to be executed on each match."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(" in the currently processed match"); _builder.newLineIfNotEmpty(); } } return _builder; }
public CharSequence javadocForEachMatchMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Executes the given processor on each match of the pattern that conforms to the given fixed values of some parameters."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@param processor the action that will process each pattern match."); _builder.newLine(); return _builder; }
public CharSequence javadocCountMatchesMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Returns the number of all matches of the pattern that conform to the given fixed values of some parameters."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@return the number of pattern matches found."); _builder.newLine(); return _builder; }
public CharSequence javadocHasMatchMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,"); _builder.newLine(); _builder.append("under any possible substitution of the unspecified parameters (if any)."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@return true if the input is a valid (partial) match of the pattern."); _builder.newLine(); return _builder; }
public CharSequence javadocNewMutableMatchMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Returns a mutable (partial) match."); _builder.newLine(); _builder.append("Fields of the mutable match can be filled to create a partial match, usable as matcher input."); _builder.newLine(); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@return the new, mutable (partial) match object."); _builder.newLine(); return _builder; }
public CharSequence javadocGetAllMatchesMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Returns the set of all matches of the pattern that conform to the given fixed values of some parameters."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@return matches represented as a "); String _matchClassName = this._eMFPatternLanguageJvmModelInferrerUtil.matchClassName(pattern); _builder.append(_matchClassName, ""); _builder.append(" object."); _builder.newLineIfNotEmpty(); return _builder; }
public CharSequence javadocNewMatchMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Returns a new (partial) match."); _builder.newLine(); _builder.append("This can be used e.g. to call the matcher with a partial match."); _builder.newLine(); _builder.append("<p>The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@return the (partial) match object."); _builder.newLine(); return _builder; }
public CharSequence javadocForOneArbitraryMatchMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters."); _builder.newLine(); _builder.append("Neither determinism nor randomness of selection is guaranteed."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@param processor the action that will process the selected match."); _builder.newLine(); _builder.append("@return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked"); _builder.newLine(); return _builder; }
public CharSequence javadocGetOneArbitraryMatchMethod(final Pattern pattern) { StringConcatenation _builder = new StringConcatenation(); _builder.append("Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters."); _builder.newLine(); _builder.append("Neither determinism nor randomness of selection is guaranteed."); _builder.newLine(); { EList<Variable> _parameters = pattern.getParameters(); for(final Variable p : _parameters) { _builder.append("@param "); String _parameterName = this._eMFPatternLanguageJvmModelInferrerUtil.parameterName(p); _builder.append(_parameterName, ""); _builder.append(" the fixed value of pattern parameter "); String _name = p.getName(); _builder.append(_name, ""); _builder.append(", or null if not bound."); _builder.newLineIfNotEmpty(); } } _builder.append("@return a match represented as a "); String _matchClassName = this._eMFPatternLanguageJvmModelInferrerUtil.matchClassName(pattern); _builder.append(_matchClassName, ""); _builder.append(" object, or null if no match is found."); _builder.newLineIfNotEmpty(); return _builder; }