/** * Returns the name of the pattern, qualified by package name. */ public static String getFullyQualifiedName(Pattern pattern) { String packageName = getPackageName(pattern); if (packageName == null || packageName.isEmpty()) { return pattern.getName(); } else { return packageName + "." + pattern.getName(); } // TODO ("local pattern?") }
/** * This method returns the pattern name. * If the pattern name contains the package (any dot), * then removes all segment except the last one. */ public String realPatternName(final Pattern pattern) { String name = pattern.getName(); boolean _contains = name.contains("."); if (_contains) { int _lastIndexOf = name.lastIndexOf("."); int _plus = (_lastIndexOf + 1); return name.substring(_plus); } return name; }
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(); }
@Override public Boolean apply(final Pattern it) { boolean _and = false; boolean _isPublic = PatternGroupClassInferrer.this._eMFPatternLanguageJvmModelInferrerUtil.isPublic(it); if (!_isPublic) { _and = false; } else { String _name = it.getName(); boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(_name); boolean _not = (!_isNullOrEmpty); _and = _not; } return Boolean.valueOf(_and); } };
/** * Returns the MatchClass name based on the Pattern's name */ public String matchClassName(final Pattern pattern) { String _xblockexpression = null; { String name = pattern.getName(); boolean _contains = name.contains("."); if (_contains) { String _realPatternName = this.realPatternName(pattern); name = _realPatternName; } String _firstUpper = StringExtensions.toFirstUpper(name); _xblockexpression = (_firstUpper + "Match"); } return _xblockexpression; }
/** * Returns the MatcherClass name based on the Pattern's name */ public String matcherClassName(final Pattern pattern) { String _xblockexpression = null; { String name = pattern.getName(); boolean _contains = name.contains("."); if (_contains) { String _realPatternName = this.realPatternName(pattern); name = _realPatternName; } String _firstUpper = StringExtensions.toFirstUpper(name); _xblockexpression = (_firstUpper + "Matcher"); } return _xblockexpression; }
/** * Returns the ProcessorClass name based on the Pattern's name */ public String processorClassName(final Pattern pattern) { String _xblockexpression = null; { String name = pattern.getName(); boolean _contains = name.contains("."); if (_contains) { String _realPatternName = this.realPatternName(pattern); name = _realPatternName; } String _firstUpper = StringExtensions.toFirstUpper(name); _xblockexpression = (_firstUpper + "Processor"); } return _xblockexpression; }
private String prettyPrintPatternCall(PatternCall call) { return (isNegativePatternCall(call) ? "neg " : "") + call.getPatternRef().getName(); }
/** * Returns the QuerySpecificationClass name based on the Pattern's name */ public String querySpecificationClassName(final Pattern pattern) { String _xblockexpression = null; { String name = pattern.getName(); boolean _contains = name.contains("."); if (_contains) { String _realPatternName = this.realPatternName(pattern); name = _realPatternName; } String _firstUpper = StringExtensions.toFirstUpper(name); _xblockexpression = (_firstUpper + "QuerySpecification"); } return _xblockexpression; }
/** * Returns the packageName: PatternModel.packageName + Pattern.name, packageName is ignored, when nullOrEmpty. */ public String getPackageNameOld(final Pattern pattern) { EObject _eContainer = pattern.eContainer(); String packageName = ((PatternModel) _eContainer).getPackageName(); boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(packageName); if (_isNullOrEmpty) { packageName = ""; } else { packageName = (packageName + "."); } String _name = pattern.getName(); String _plus = (packageName + _name); return _plus.toLowerCase(); }
@Check public void checkPrivatePatternUsage(Pattern pattern) { if (CorePatternLanguageHelper.isPrivate(pattern) && !isLocallyUsed(pattern, pattern.eContainer())) { String message = String.format(UNUSED_PRIVATE_PATTERN_MESSAGE, pattern.getName()); warning(message, PatternLanguagePackage.Literals.PATTERN__NAME, IssueCodes.UNUSED_PRIVATE_PATTERN); } }
@Check public void checkPatternBody(PatternBody body) { if (body.getConstraints().isEmpty()) { String bodyName = getName(body); if (bodyName == null) { Pattern pattern = ((Pattern) body.eContainer()); String patternName = pattern.getName(); error("A patternbody of " + patternName + " is empty", body, PatternLanguagePackage.Literals.PATTERN_BODY__CONSTRAINTS, IssueCodes.PATTERN_BODY_EMPTY); } else { error("The patternbody " + bodyName + " cannot be empty", body, PatternLanguagePackage.Literals.PATTERN_BODY__NAME, IssueCodes.PATTERN_BODY_EMPTY); } } }
String _name = model.getName(); String _firstUpper = StringExtensions.toFirstUpper(_name); String _plus = ("get" + _firstUpper);
String _name = pattern.getName(); boolean _isNullOrEmpty = StringExtensions.isNullOrEmpty(_name); boolean _not = (!_isNullOrEmpty);
private void inferPrivate(final Pattern pattern, final IJvmDeclaredTypeAcceptor acceptor, final SpecificationBuilder builder, final boolean isPrelinkingPhase) { String _name = pattern.getName(); String _plus = ("Inferring Jvm Model for private pattern " + _name); this.logger.debug(_plus); final String utilPackageName = this._eMFPatternLanguageJvmModelInferrerUtil.getUtilPackageName(pattern); JvmTypeReference _typeRef = this._typeReferenceBuilder.typeRef(IPatternMatch.class); JvmTypeReference _typeRef_1 = this._typeReferenceBuilder.typeRef(IncQueryMatcher.class, _typeRef); final JvmType matcherClass = _typeRef_1.getType(); final JvmDeclaredType querySpecificationClass = this._patternQuerySpecificationClassInferrer.inferQuerySpecificationClass(pattern, isPrelinkingPhase, utilPackageName, matcherClass, this._typeReferenceBuilder, this._annotationTypesBuilder); this.associator.associatePrimary(pattern, querySpecificationClass); final Procedure1<JvmDeclaredType> _function = new Procedure1<JvmDeclaredType>() { @Override public void apply(final JvmDeclaredType it) { EMFPatternLanguageJvmModelInferrer.this._patternQuerySpecificationClassInferrer.initializePrivateSpecification(querySpecificationClass, pattern, matcherClass, null, builder); } }; acceptor.<JvmDeclaredType>accept(querySpecificationClass, _function); }
String _name = model.getName(); String _firstUpper = StringExtensions.toFirstUpper(_name); String _plus = ("get" + _firstUpper);
@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); } } }
private String getVariableName(ValueReference reference, PatternModelAcceptor<?> acceptor) throws SpecificationBuilderException { if (reference instanceof VariableValue) return getVariableName(((VariableValue) reference).getValue(), acceptor); else if (reference instanceof AggregatedValue) return aggregate((AggregatedValue) reference, acceptor); else if (reference instanceof FunctionEvaluationValue) return eval((FunctionEvaluationValue) reference, acceptor); else if (reference instanceof IntValue) return acceptor.createConstantVariable(((IntValue) reference).getValue()); else if (reference instanceof StringValue) return acceptor.createConstantVariable(((StringValue) reference).getValue()); else if (reference instanceof EnumValue) // EMF-specific return acceptor.createConstantVariable(((EnumValue) reference).getLiteral().getInstance()); else if (reference instanceof DoubleValue) { return acceptor.createConstantVariable(((DoubleValue) reference).getValue()); } else if (reference instanceof BoolValue) { return acceptor.createConstantVariable(((BoolValue) reference).isValue()); } else throw new SpecificationBuilderException( "Unsupported value reference of type {1} from EPackage {2} currently unsupported by pattern builder in pattern {3}.", new String[] { reference != null ? reference.eClass().getName() : "(null)", reference != null ? reference.eClass().getEPackage().getNsURI() : "(null)", pattern.getName() }, "Unsupported value expression", pattern); }
private void inferPublic(final Pattern pattern, final IJvmDeclaredTypeAcceptor acceptor, final SpecificationBuilder builder, final boolean isPrelinkingPhase) { String _name = pattern.getName(); String _plus = ("Inferring Jvm Model for pattern" + _name); this.logger.debug(_plus);
for(final Pattern p : _patterns) { _builder.append("<li>"); String _name = p.getName(); _builder.append(_name, ""); _builder.append("</li>");