public Iterable<String> getKeywords() { final Function1<Keyword, Boolean> _function = (Keyword it) -> { return Boolean.valueOf(Character.isLetter(it.getValue().charAt(0))); }; final Function1<Keyword, String> _function_1 = (Keyword it) -> { return it.getValue(); }; return IterableExtensions.<String>sort(IterableExtensions.<String>toSet(IterableExtensions.<Keyword, String>map(IterableExtensions.<Keyword>filter(GrammarUtil.containedKeywords(this.grammarAccess.getGrammar()), _function), _function_1))); } }
protected EAttribute getNameEAttribute(final EObject target) { final Function1<EAttribute, Boolean> _function = (EAttribute it) -> { return Boolean.valueOf((Objects.equal(it.getName(), "name") && Objects.equal(it.getEType(), EcorePackage.Literals.ESTRING))); }; return IterableExtensions.<EAttribute>head(IterableExtensions.<EAttribute>filter(target.eClass().getEAllAttributes(), _function)); } }
/** * @since 2.9 */ public static String getDefaultArgumentList(ParserRule rule) { String result = IterableExtensions.join(rule.getParameters(), "[", ", ", "]", new Functions.Function1<Parameter, String>() { @Override public String apply(Parameter p) { return Boolean.FALSE.toString(); } }); return result; }
/** * filter against types (must match one of the given types) */ public Iterable<?> filterByTypes(final Iterable<?> unfiltered, final Class<?>... types) { final Function1<Object, Boolean> _function = (Object obj) -> { final Function1<Class<?>, Boolean> _function_1 = (Class<?> it) -> { return Boolean.valueOf(it.isInstance(obj)); }; return Boolean.valueOf(IterableExtensions.<Class<?>>exists(((Iterable<Class<?>>)Conversions.doWrapArray(types)), _function_1)); }; return IterableExtensions.filter(unfiltered, _function); }
private Set<JvmType> _getTestStepFixtureTypes(final ComponentTestStepContext context) { final Set<InteractionType> interactionTypes = IterableExtensions.<InteractionType>toSet(this._modelUtil.getAllInteractionTypes(context.getComponent())); final Function1<InteractionType, JvmType> _function = (InteractionType it) -> { return this._modelUtil.getFixtureType(it); }; final Set<JvmType> fixtureTypes = IterableExtensions.<JvmType>toSet(IterableExtensions.<JvmType>filterNull(IterableExtensions.<InteractionType, JvmType>map(interactionTypes, _function))); return fixtureTypes; }
protected Collection<Enumeration> _getUsedEnums(final ResourceAPI resourceAPI) { final Function1<ServiceDataResource, Collection<Enumeration>> _function = (ServiceDataResource dataInterface) -> { return this.getUsedEnums(dataInterface); }; return IterableExtensions.<Enumeration>toSet(Iterables.<Enumeration>concat(IterableExtensions.<ServiceDataResource, Collection<Enumeration>>map(Iterables.<ServiceDataResource>filter(resourceAPI.getOwnedResourceDefinitions(), ServiceDataResource.class), _function))); }
public Iterable<FEnumerationType> getEnumDataTypes(final FModel fModel) { final Function1<FType, Boolean> _function = (FType type) -> { return Boolean.valueOf(this._typeUtil.isEnum(type)); }; final Function1<FType, FEnumerationType> _function_1 = (FType type) -> { return this._typeUtil.getEnumType(type); }; return IterableExtensions.<FEnumerationType>filterNull(IterableExtensions.<FType, FEnumerationType>map(IterableExtensions.<FType>filter(this.getDataTypes(fModel), _function), _function_1)); }
@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); }
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); }
/** * 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))); }
public BodyParameter getBodyParameter(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); } Parameter _last = IterableExtensions.<Parameter>last(_filter); return ((BodyParameter) _last); }
public boolean hasEquals(final ClassDeclaration it) { final Function1<MethodDeclaration, Boolean> _function = (MethodDeclaration it_1) -> { return Boolean.valueOf(((Objects.equal(it_1.getSimpleName(), "equals") && (IterableExtensions.size(it_1.getParameters()) == 1)) && Objects.equal(IterableExtensions.head(it_1.getParameters()).getType(), this.context.getObject()))); }; return IterableExtensions.exists(it.getDeclaredMethods(), _function); }
private Iterable<Pair<String, String>> getProjectMappings() { final Function1<ISubProjectConfig, Boolean> _function = (ISubProjectConfig it) -> { return Boolean.valueOf(((it.getName() != null) && (it.getRoot() != null))); }; final Function1<ISubProjectConfig, Pair<String, String>> _function_1 = (ISubProjectConfig it) -> { String _name = it.getName(); String _path = it.getRoot().getPath(); return Pair.<String, String>of(_name, _path); }; return IterableExtensions.map(IterableExtensions.filter(this.projectConfig.getEnabledProjects(), _function), _function_1); }
private boolean matches(final Collection<PropertySelector> selectors, final Feature feature, final RealizationContext context) { final Function1<PropertySelector, Boolean> _function = (PropertySelector it) -> { return Boolean.valueOf(this.matches(it, feature, context)); }; return IterableExtensions.<PropertySelector>exists(selectors, _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; }
private Set<IClassAnnotation> getClassAnnotations() { final Function1<IClassAnnotation, Boolean> _function = (IClassAnnotation it) -> { return Boolean.valueOf(it.appliesTo(this)); }; Iterable<IClassAnnotation> _filter = IterableExtensions.<IClassAnnotation>filter(this.codeConfig.getClassAnnotations(), _function); return IterableExtensions.<IClassAnnotation>toSet(Iterables.<IClassAnnotation>concat(this.annotations, _filter)); }
@Override public void apply(final JvmOperation d) { final EObject source = IterableExtensions.<EObject>head(EmfParsleyDslValidator.this._iJvmModelAssociations.getSourceElements(d)); boolean _add = errorSourceSeen.add(source); if (_add) { EmfParsleyDslValidator.this.error( "Duplicate element", source, null, EmfParsleyDslValidator.DUPLICATE_ELEMENT); } } };
public boolean isPackageVisibility(final Iterable<Modifier> modifier) { final Function1<Modifier, Boolean> _function = (Modifier it) -> { return Boolean.valueOf(((it.isPublic() || it.isPrivate()) || it.isProtected())); }; return IterableExtensions.isEmpty(IterableExtensions.<Modifier>filter(modifier, _function)); }
@Override public FieldDeclaration findDeclaredField(final String name) { final Function1<FieldDeclaration, Boolean> _function = (FieldDeclaration it) -> { String _simpleName = it.getSimpleName(); return Boolean.valueOf(Objects.equal(_simpleName, name)); }; return IterableExtensions.<FieldDeclaration>findFirst(Iterables.<FieldDeclaration>filter(this.getDeclaredMembers(), FieldDeclaration.class), _function); }
private URLClassLoader createURLClassLoader(final Iterable<String> classPathEntries) { final Function1<String, URL> _function = (String str) -> { try { return new File(str).toURI().toURL(); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }; final Iterable<URL> classPathUrls = IterableExtensions.<String, URL>map(classPathEntries, _function); return new URLClassLoader(((URL[])Conversions.unwrapArray(classPathUrls, URL.class))); }