@GET @Path("/testeditor") public Response getTesteditorVersions(@QueryParam("dependency") final String dependency) { return Response.status(Response.Status.OK).entity(IterableExtensions.<String>toList(this.buildVersionProvider.getTesteditorDependencies(this.configuration, dependency))).build(); } }
/** * Either a single file extension or a comma-separated list of extensions for which the language * shall be registered. */ public void setFileExtensions(final String fileExtensions) { this.fileExtensions = IterableExtensions.<String>toList(((Iterable<String>)Conversions.doWrapArray(fileExtensions.trim().split("\\s*,\\s*")))); }
@GET @Path("/all") public Response getVersions(@QueryParam("dependency") final String dependency) { return Response.status(Response.Status.OK).entity(IterableExtensions.<String>toList(this.buildVersionProvider.getDependencies(this.configuration, dependency))).build(); }
@Override protected List<Class<?>> getExtensionClasses() { List<Class<?>> _extensionClasses = super.getExtensionClasses(); return IterableExtensions.<Class<?>>toList(Iterables.<Class<?>>concat(_extensionClasses, Collections.<Class<?>>unmodifiableList(CollectionLiterals.<Class<?>>newArrayList(Widget.class, DatabindingUtil.class)))); } }
public List<Feature> getIncludedPrimitiveProperties(final ReferenceTreatment refTreatment) { final Function1<Feature, Boolean> _function = (Feature e) -> { return Boolean.valueOf((e instanceof PrimitiveProperty)); }; return IterableExtensions.<Feature>toList(IterableExtensions.<Feature>filter(this.getIncludedProperties(refTreatment), _function)); }
public boolean isObjectMethod(final ResolvedMethod it) { boolean _xblockexpression = false; { final String name = it.getDeclaration().getSimpleName(); final Function1<ResolvedParameter, TypeReference> _function = (ResolvedParameter it_1) -> { return it_1.getResolvedType(); }; final List<TypeReference> parameterTypes = IterableExtensions.<TypeReference>toList(IterableExtensions.map(it.getResolvedParameters(), _function)); _xblockexpression = (((((Objects.equal(name, "hashCode") && parameterTypes.isEmpty()) || (Objects.equal(name, "toString") && parameterTypes.isEmpty())) || (Objects.equal(name, "equals") && Objects.equal(parameterTypes, Collections.<TypeReference>unmodifiableList(CollectionLiterals.<TypeReference>newArrayList(this.context.getObject()))))) || (Objects.equal(name, "finalize") && parameterTypes.isEmpty())) || (Objects.equal(name, "clone") && parameterTypes.isEmpty())); } return _xblockexpression; }
public List<Parameter> getNonBodyParameters(final Operation op) { List<Parameter> _parameters = op.getParameters(); Iterable<Parameter> _filter = null; if (_parameters!=null) { final Function1<Parameter, Boolean> _function = (Parameter it) -> { String _in = it.getIn(); return Boolean.valueOf((!Objects.equal(_in, "body"))); }; _filter=IterableExtensions.<Parameter>filter(_parameters, _function); } return IterableExtensions.<Parameter>toList(_filter); }
private List<MatrixParameter> getMatrixParameters(final ServiceDataResource aResource) { List<MatrixParameter> _xifexpression = null; com.reprezen.rapidml.URI _uRI = aResource.getURI(); boolean _tripleNotEquals = (_uRI != null); if (_tripleNotEquals) { _xifexpression = IterableExtensions.<MatrixParameter>toList(Iterables.<MatrixParameter>filter(aResource.getURI().getUriParameters(), MatrixParameter.class)); } else { _xifexpression = Collections.<MatrixParameter>emptyList(); } return _xifexpression; }
@Override public ConstructorDeclaration findDeclaredConstructor(final TypeReference... parameterTypes) { final Function1<ConstructorDeclaration, Boolean> _function = (ConstructorDeclaration constructor) -> { final Function1<ParameterDeclaration, TypeReference> _function_1 = (ParameterDeclaration it) -> { return it.getType(); }; List<TypeReference> _list = IterableExtensions.<TypeReference>toList(IterableExtensions.map(constructor.getParameters(), _function_1)); List<TypeReference> _list_1 = IterableExtensions.<TypeReference>toList(((Iterable<TypeReference>)Conversions.doWrapArray(parameterTypes))); return Boolean.valueOf(Objects.equal(_list, _list_1)); }; return IterableExtensions.findFirst(this.getDeclaredConstructors(), _function); }
@Override public MethodDeclaration findDeclaredMethod(final String name, final TypeReference... parameterTypes) { final Function1<MethodDeclaration, Boolean> _function = (MethodDeclaration method) -> { return Boolean.valueOf((Objects.equal(method.getSimpleName(), name) && Objects.equal(IterableExtensions.<TypeReference>toList(IterableExtensions.map(method.getParameters(), ((Function1<ParameterDeclaration, TypeReference>) (ParameterDeclaration it) -> { return it.getType(); }))), IterableExtensions.<TypeReference>toList(((Iterable<TypeReference>)Conversions.doWrapArray(parameterTypes)))))); }; return IterableExtensions.findFirst(this.getDeclaredMethods(), _function); }
protected List<AbstractElement> _contentsAsList(final CompoundElement it) { final Function1<AbstractElement, List<AbstractElement>> _function = (AbstractElement it_1) -> { return this.contentsAsList(it_1); }; return IterableExtensions.<AbstractElement>toList(Iterables.<AbstractElement>concat(ListExtensions.<AbstractElement, List<AbstractElement>>map(it.getElements(), _function))); }
private Iterable<? extends IResourceServiceProvider> getAllLanguages() { final Function1<String, IResourceServiceProvider> _function = (String ext) -> { final URI synthUri = URI.createURI(("synth:///file." + ext)); return this.languagesRegistry.getResourceServiceProvider(synthUri); }; return IterableExtensions.<IResourceServiceProvider>toSet(ListExtensions.<String, IResourceServiceProvider>map(IterableExtensions.<String>sort(IterableExtensions.<String>toList(this.languagesRegistry.getExtensionToFactoryMap().keySet())), _function)); }
protected List<ProjectDescription> sortByDependencies(final Iterable<ProjectDescription> projectDescriptions) { final Procedure1<ProjectDescription> _function = (ProjectDescription it) -> { this.reportDependencyCycle(this.workspaceManager.getProjectManager(it.getName())); }; return this.sorterProvider.get().sortByDependencies(IterableExtensions.<ProjectDescription>toList(projectDescriptions), _function); }
protected Collection<EPackage> getRegistryPackagesToValidate() { final Collection<EPackage> packages = GrammarUtil.allEPackagesToValidate(this.getGrammar()); final Function1<GeneratedMetamodel, EPackage> _function = (GeneratedMetamodel it) -> { return it.getEPackage(); }; packages.removeAll(IterableExtensions.<EPackage>toList(IterableExtensions.<GeneratedMetamodel, EPackage>map(Iterables.<GeneratedMetamodel>filter(GrammarUtil.allMetamodelDeclarations(this.getGrammar()), GeneratedMetamodel.class), _function))); return packages; }
/** * Returns all grammars from the hierarchy that are used from rules of this grammar. */ protected List<Grammar> getEffectivelyUsedGrammars(final Grammar grammar) { final Function1<AbstractRule, Grammar> _function = (AbstractRule it) -> { return GrammarUtil.getGrammar(it); }; final Function1<Grammar, Boolean> _function_1 = (Grammar it) -> { return Boolean.valueOf((it != grammar)); }; return IterableExtensions.<Grammar>toList(IterableExtensions.<Grammar>toSet(IterableExtensions.<Grammar>filter(ListExtensions.<AbstractRule, Grammar>map(GrammarUtil.allRules(grammar), _function), _function_1))); }
protected List<AbstractRule> getExportedRulesFromGrammar() { List<AbstractRule> _xblockexpression = null; { final HashSet<EClassifier> alreadyCollected = CollectionLiterals.<EClassifier>newHashSet(); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((this.isExported(it) && alreadyCollected.add(it.getType().getClassifier()))); }; _xblockexpression = IterableExtensions.<AbstractRule>toList(IterableExtensions.<AbstractRule>filter(this.getGrammar().getRules(), _function)); } return _xblockexpression; }
/** * @since 2.14 */ protected List<AbstractRule> getDeprecatedRulesFromGrammar() { final HashSet<EClassifier> alreadyCollected = CollectionLiterals.<EClassifier>newHashSet(); final Function1<AbstractRule, Boolean> _function = (AbstractRule it) -> { return Boolean.valueOf((this.isDeprecated(it) && alreadyCollected.add(it.getType().getClassifier()))); }; return IterableExtensions.<AbstractRule>toList(IterableExtensions.<AbstractRule>filter(this.getGrammar().getRules(), _function)); }
@Override public Iterable<? extends TypeReference> getUpperBounds() { final Function1<JvmUpperBound, TypeReference> _function = (JvmUpperBound it) -> { return this.getCompilationUnit().toTypeReference(it.getTypeReference()); }; return IterableExtensions.<TypeReference>toList(IterableExtensions.<JvmUpperBound, TypeReference>map(Iterables.<JvmUpperBound>filter(this.getDelegate().getConstraints(), JvmUpperBound.class), _function)); }
@Override public Iterable<? extends TypeReference> getUpperBounds() { final Function1<JvmUpperBound, TypeReference> _function = (JvmUpperBound it) -> { return this.getCompilationUnit().toTypeReference(it.getTypeReference()); }; return IterableExtensions.<TypeReference>toList(IterableExtensions.<JvmUpperBound, TypeReference>map(Iterables.<JvmUpperBound>filter(this.getDelegate().getConstraints(), JvmUpperBound.class), _function)); }
protected void formatFeatureCallParams(final List<XExpression> params, final ISemanticRegion open, final ISemanticRegion close, @Extension final IFormattableDocument format) { final XClosure builder = this.builder(params); final Iterable<XExpression> explicitParams = this.explicitParams(params); this.formatCommaSeparatedList(IterableExtensions.<XExpression>toList(explicitParams), open, close, format); this.formatBuilderWithLeadingGap(builder, format); }