public static List<Variable> getUsedVariables(XExpression xExpression, Iterable<Variable> allVariables){ if (xExpression == null) return Collections.emptyList(); List<EObject> contents = Lists.newArrayList(xExpression.eAllContents()); Stream<XFeatureCall> contentStream = contents.stream().filter(XFeatureCall.class::isInstance).map(XFeatureCall.class::cast); Stream<XFeatureCall> featuredCalls = (xExpression instanceof XFeatureCall) ? Stream.concat(Stream.of((XFeatureCall)xExpression), contentStream) : contentStream; final Set<String> valNames = featuredCalls.map(XFeatureCall::getConcreteSyntaxFeatureName).collect(Collectors.toSet()); Iterable<Variable> calledVariables = Iterables.filter(allVariables, var -> valNames.contains(var.getName())); return IterableExtensions.sortBy(calledVariables, Variable::getName); }
public static List<Variable> getUsedVariables(XExpression xExpression, Iterable<Variable> allVariables){ List<EObject> contents = Lists.newArrayList(xExpression.eAllContents()); Iterable<XFeatureCall> featuredCalls = Iterables.filter(contents, XFeatureCall.class); final Set<String> valNames = Sets.newHashSet(Iterables.transform(featuredCalls, new Function<XFeatureCall,String>() { @Override public String apply(final XFeatureCall call) { return call.getConcreteSyntaxFeatureName(); } })); Iterable<Variable> calledVariables = Iterables.filter(allVariables, new Predicate<Variable>() { @Override public boolean apply(final Variable var) { return valNames.contains(var.getName()); } }); return IterableExtensions.sortBy(calledVariables, new Function1<Variable,String>() { public String apply(final Variable var) { return var.getName(); } }); }
public <K extends Object, V extends Object> List<K> sortByPosition(final Collection<K> keys, final Map<K, V> map) { final Function1<K, Integer> _function = (K it) -> { Integer _elvis = null; V _get = map.get(it); RepreZenVendorExtension _rZVE = null; if (_get!=null) { _rZVE=this.attributeHelper.getRZVE(_get); } Integer _position = null; if (_rZVE!=null) { _position=_rZVE.getPosition(); } if (_position != null) { _elvis = _position; } else { _elvis = Integer.valueOf(Integer.MAX_VALUE); } return _elvis; }; return IterableExtensions.<K, Integer>sortBy(keys, _function); } }
private Iterable<EClass> getAccessedClasses(final EPackage pkg) { final Function1<IGrammarConstraintProvider.IConstraint, EClass> _function = (IGrammarConstraintProvider.IConstraint it) -> { return it.getType(); }; final Function1<EClass, Boolean> _function_1 = (EClass it) -> { return Boolean.valueOf(((it != null) && Objects.equal(it.getEPackage(), pkg))); }; final Function1<EClass, String> _function_2 = (EClass it) -> { return it.getName(); }; return IterableExtensions.<EClass, String>sortBy(IterableExtensions.<EClass>toSet(IterableExtensions.<EClass>filter(IterableExtensions.<IGrammarConstraintProvider.IConstraint, EClass>map(this._semanticSequencerExtensions.getGrammarConstraints(this.getGrammar()), _function), _function_1)), _function_2); }
public String renderToString(final int offset, final int length) { String _xblockexpression = null; { final List<TextReplacement> edits = this.renderToEdits(offset, length); int lastOffset = offset; final StringBuilder newDocument = new StringBuilder(); final Function1<TextReplacement, Integer> _function = (TextReplacement it) -> { return Integer.valueOf(offset); }; List<TextReplacement> _sortBy = IterableExtensions.<TextReplacement, Integer>sortBy(edits, _function); for (final TextReplacement edit : _sortBy) { { final String text = this.document.substring(lastOffset, edit.getOffset()); newDocument.append(text); newDocument.append(edit.getText()); int _offset = edit.getOffset(); int _length = edit.getLength(); int _plus = (_offset + _length); lastOffset = _plus; } } final String text = this.document.substring(lastOffset, (offset + length)); newDocument.append(text); _xblockexpression = newDocument.toString(); } return _xblockexpression; }
private Iterable<EPackage> getAccessedPackages() { final Function1<IGrammarConstraintProvider.IConstraint, Boolean> _function = (IGrammarConstraintProvider.IConstraint it) -> { EClass _type = it.getType(); return Boolean.valueOf((_type != null)); }; final Function1<IGrammarConstraintProvider.IConstraint, EPackage> _function_1 = (IGrammarConstraintProvider.IConstraint it) -> { return it.getType().getEPackage(); }; final Function1<EPackage, String> _function_2 = (EPackage it) -> { return it.getName(); }; return IterableExtensions.<EPackage, String>sortBy(IterableExtensions.<EPackage>toSet(IterableExtensions.<IGrammarConstraintProvider.IConstraint, EPackage>map(IterableExtensions.<IGrammarConstraintProvider.IConstraint>filter(this._semanticSequencerExtensions.getGrammarConstraints(this.getGrammar()), _function), _function_1)), _function_2); }
return it.getKey().getName(); }; final List<Map.Entry<IGrammarConstraintProvider.IConstraint, List<ISerializationContext>>> contexts = IterableExtensions.<Map.Entry<IGrammarConstraintProvider.IConstraint, List<ISerializationContext>>, String>sortBy(this._semanticSequencerExtensions.getGrammarConstraints(this.getGrammar(), type).entrySet(), _function); final LinkedHashMultimap<EObject, IGrammarConstraintProvider.IConstraint> context2constraint = LinkedHashMultimap.<EObject, IGrammarConstraintProvider.IConstraint>create(); for (final Map.Entry<IGrammarConstraintProvider.IConstraint, List<ISerializationContext>> e : contexts) {
public List<Variable> variables(final XExpression ex) { List<Variable> _xblockexpression = null; { final PatternBody body = EcoreUtil2.<PatternBody>getContainerOfType(ex, PatternBody.class); TreeIterator<EObject> _eAllContents = ex.eAllContents(); Iterator<XExpression> _iterator = CollectionLiterals.<XExpression>newImmutableList(ex).iterator(); final Function1<XFeatureCall, String> _function = (XFeatureCall it) -> { return it.getConcreteSyntaxFeatureName(); }; final List<String> valNames = IteratorExtensions.<String>toList(IteratorExtensions.<XFeatureCall, String>map(Iterators.<XFeatureCall>filter(Iterators.<EObject>concat(_eAllContents, _iterator), XFeatureCall.class), _function)); final Function1<Variable, Boolean> _function_1 = (Variable it) -> { return Boolean.valueOf(valNames.contains(it.getName())); }; final Function1<Variable, String> _function_2 = (Variable it) -> { return it.getName(); }; _xblockexpression = IterableExtensions.<Variable, String>sortBy(IterableExtensions.<Variable>filter(body.getVariables(), _function_1), _function_2); } return _xblockexpression; }
public List<Dao> getSubClassDaos(final Dao it) { Entity _entity = it.getEntity(); Model _model = this._types.model(_entity); TreeIterator<EObject> _eAllContents = _model.eAllContents(); Iterator<Dao> _filter = Iterators.<Dao>filter(_eAllContents, Dao.class); final Function1<Dao,Boolean> _function = new Function1<Dao,Boolean>() { public Boolean apply(final Dao e) { Entity _entity = e.getEntity(); Entity _superType = _entity.getSuperType(); Entity _entity_1 = it.getEntity(); boolean _equals = Objects.equal(_superType, _entity_1); return Boolean.valueOf(_equals); } }; Iterator<Dao> _filter_1 = IteratorExtensions.<Dao>filter(_filter, _function); List<Dao> _list = IteratorExtensions.<Dao>toList(_filter_1); final Function1<Dao,String> _function_1 = new Function1<Dao,String>() { public String apply(final Dao e) { String _name = e.getName(); return _name; } }; List<Dao> _sortBy = IterableExtensions.<Dao, String>sortBy(_list, _function_1); return _sortBy; }
_xblockexpression = IterableExtensions.<Variable, String>sortBy(_filter_1, _function_2);
return variableToIndexMap.get(it.getValue()); }; final List<Map.Entry<StepContent, TemplateVariable>> sorted = IterableExtensions.<Map.Entry<StepContent, TemplateVariable>, Integer>sortBy(stepContentToTemplateVariables.entrySet(), _function_2); final Function1<Map.Entry<StepContent, TemplateVariable>, Pair<StepContent, Optional<JvmTypeReference>>> _function_3 = (Map.Entry<StepContent, TemplateVariable> it) -> { StepContent _key = it.getKey();
private List<AbstractRule> unassignedCalledTokenRules() { final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf(GrammarUtil.isEObjectRule(it)); }; final Iterable<AbstractRule> rules = IterableExtensions.<AbstractRule>filter(GrammarUtil.allRules(this.getGrammar()), _function); final Function1<AbstractRule, Iterable<RuleCall>> _function_1 = (AbstractRule it) -> { final Function1<RuleCall, Boolean> _function_2 = (RuleCall it_1) -> { return Boolean.valueOf(this.isUnassignedRuleCall(it_1)); }; return IterableExtensions.<RuleCall>filter(GrammarUtil.containedRuleCalls(it), _function_2); }; final Iterable<RuleCall> calls = Iterables.<RuleCall>concat(IterableExtensions.<AbstractRule, Iterable<RuleCall>>map(rules, _function_1)); final Function1<RuleCall, AbstractRule> _function_2 = (RuleCall it) -> { return it.getRule(); }; final Function1<AbstractRule, String> _function_3 = (AbstractRule it) -> { return it.getName(); }; return IterableExtensions.<AbstractRule, String>sortBy(IterableExtensions.<AbstractRule>toSet(IterableExtensions.<RuleCall, AbstractRule>map(calls, _function_2)), _function_3); }
return it_1.message; }; it.setData(IterableExtensions.join(ListExtensions.<ServerRefactoringIssueAcceptor.Issue, String>map(ListExtensions.<ServerRefactoringIssueAcceptor.Issue>reverse(IterableExtensions.<ServerRefactoringIssueAcceptor.Issue, RefactoringIssueAcceptor.Severity>sortBy(this.issues, _function_1)), _function_2), "\n")); int _switchResult_1 = (int) 0; if (maxSeverity != null) {
List<ReferenceableByXmadslVariable> _sortBy = IterableExtensions.<ReferenceableByXmadslVariable, String>sortBy(_filter, _function); for(final ReferenceableByXmadslVariable function : _sortBy) { CharSequence _function_1 = this.toFunction(function, it);
List<Attribute> _sortBy = IterableExtensions.<Attribute, String>sortBy(_set, _function_4); for(final Attribute attribute : _sortBy) { _builder.append("\t");
return Integer.valueOf(it_1.length()); }; List<String> _sortBy = IterableExtensions.<String, Integer>sortBy(IterableExtensions.<String>sort(GrammarUtil.getAllKeywords(it)), _function); for(final String kw : _sortBy) { _builder.append("\t");
List<Attribute> _sortBy = IterableExtensions.<Attribute, String>sortBy(_set, _function_4); for(final Attribute attribute : _sortBy) { _builder.append("\t");