Java Code Examples for org.eclipse.xtext.xbase.lib.IterableExtensions#filter()

protected void registerMacroAnnotations(final XtendAnnotationTarget candidate, final IAcceptor<Pair<JvmAnnotationType, XAnnotation>> acceptor) {
  final Function1<XAnnotation, Boolean> _function = (XAnnotation it) -> {
    return Boolean.valueOf(this._xAnnotationExtensions.isProcessed(it));
  };
  Iterable<XAnnotation> _filter = IterableExtensions.<XAnnotation>filter(candidate.getAnnotations(), _function);
  for (final XAnnotation annotation : _filter) {
    {
      final JvmAnnotationType activeAnnotationDeclaration = this._xAnnotationExtensions.tryFindAnnotationType(annotation);
      if ((activeAnnotationDeclaration != null)) {
        boolean _isValid = this.isValid(annotation, activeAnnotationDeclaration);
        if (_isValid) {
          Pair<JvmAnnotationType, XAnnotation> _mappedTo = Pair.<JvmAnnotationType, XAnnotation>of(activeAnnotationDeclaration, annotation);
          acceptor.accept(_mappedTo);
        }
      }
    }
  }
}
 

@Override
public void checkConfiguration(final Issues issues) {
  super.checkConfiguration(issues);
  boolean _isSet = this.framework.isSet();
  boolean _not = (!_isSet);
  if (_not) {
    issues.addError("The property \'framework\' is required.");
  }
  final Function1<String, Boolean> _function = (String it) -> {
    return Boolean.valueOf(this.suppressedPatterns.contains(it));
  };
  Iterable<String> _filter = IterableExtensions.<String>filter(this.enabledPatterns, _function);
  for (final String pattern : _filter) {
    issues.addError((("The pattern \'" + pattern) + "\' cannot be enabled and suppressed."));
  }
}
 

protected Iterable<JvmMember> _getMembersToBeCompiled(final JvmEnumerationType type) {
  Iterable<JvmMember> _xblockexpression = null;
  {
    String _identifier = type.getIdentifier();
    String _plus = (_identifier + ".");
    String _plus_1 = (_plus + "valueOf(java.lang.String)");
    String _identifier_1 = type.getIdentifier();
    String _plus_2 = (_identifier_1 + ".");
    String _plus_3 = (_plus_2 + "values()");
    final Set<String> syntheticEnumMethods = Collections.<String>unmodifiableSet(CollectionLiterals.<String>newHashSet(_plus_1, _plus_3));
    final Function1<JvmMember, Boolean> _function = (JvmMember it) -> {
      return Boolean.valueOf((!((it instanceof JvmOperation) && syntheticEnumMethods.contains(it.getIdentifier()))));
    };
    _xblockexpression = IterableExtensions.<JvmMember>filter(type.getMembers(), _function);
  }
  return _xblockexpression;
}
 

protected Iterable<IReferenceDescription> getImportTypeReferences(Iterable<IReferenceDescription> referenceDescriptions) {
	return IterableExtensions.filter(referenceDescriptions, new Functions.Function1<IReferenceDescription, Boolean>() {

		@Override
		public Boolean apply(IReferenceDescription p) {
			return isImportTypeReference(p);
		}
		
	});
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public EList<N4MemberDeclaration> getOwnedMembers() {
	final Function1<N4MemberDeclaration, Boolean> _function = new Function1<N4MemberDeclaration, Boolean>() {
		public Boolean apply(final N4MemberDeclaration it) {
			boolean _isCallableConstructor = it.isCallableConstructor();
			return Boolean.valueOf((!_isCallableConstructor));
		}
	};
	final Iterable<N4MemberDeclaration> methods = IterableExtensions.<N4MemberDeclaration>filter(Iterables.<N4MemberDeclaration>filter(this.getOwnedMembersRaw(), N4MemberDeclaration.class), _function);
	List<N4MemberDeclaration> _list = IterableExtensions.<N4MemberDeclaration>toList(methods);
	return new BasicEList<N4MemberDeclaration>(_list);
}
 

public static Iterable<EClass> subClasses(final EClass it) {
  Iterable<EClass> _xifexpression = null;
  EPackage _ePackage = it.getEPackage();
  boolean _tripleEquals = (_ePackage == null);
  if (_tripleEquals) {
    _xifexpression = CollectionLiterals.<EClass>emptyList();
  } else {
    final Function1<EClass, Boolean> _function = (EClass c) -> {
      return Boolean.valueOf(c.getEAllSuperTypes().contains(it));
    };
    _xifexpression = IterableExtensions.<EClass>filter(Iterables.<EClass>filter(it.getEPackage().getEClassifiers(), EClass.class), _function);
  }
  return _xifexpression;
}
 

public Iterable<? extends MemberDeclaration> getDelegates(final TypeDeclaration it) {
  final Function1<MemberDeclaration, Boolean> _function = (MemberDeclaration it_1) -> {
    AnnotationReference _findAnnotation = it_1.findAnnotation(this.context.findTypeGlobally(Delegate.class));
    return Boolean.valueOf((_findAnnotation != null));
  };
  return IterableExtensions.filter(it.getDeclaredMembers(), _function);
}
 

protected EObject getOriginTarget(EObject target) {
	Iterable<EObject> originTraces = IterableExtensions.filter(tracing.getOriginTraces(target), EObject.class);
	Iterator<EObject> iter = originTraces.iterator();
	if (iter.hasNext()) {
		target = iter.next();
	} else if (target instanceof Property) {
		Type type = ((Property) target).getType();
		if (statechartUtil.isOriginScope(type)) {
			target = statechartUtil.getOriginScope(type);
		}
	}
	return target;
}
 

@Override
protected CharSequence compileRules(final Grammar g, final AntlrOptions options) {
  StringConcatenation _builder = new StringConcatenation();
  {
    List<ParserRule> _allParserRules = GrammarUtil.allParserRules(g);
    List<EnumRule> _allEnumRules = GrammarUtil.allEnumRules(g);
    Iterable<AbstractRule> _plus = Iterables.<AbstractRule>concat(_allParserRules, _allEnumRules);
    Collection<? extends AbstractElement> _allAlternatives = GrammarUtil.getAllAlternatives(g);
    Iterable<EObject> _plus_1 = Iterables.<EObject>concat(_plus, _allAlternatives);
    Collection<? extends AbstractElement> _allGroups = GrammarUtil.getAllGroups(g);
    Iterable<EObject> _plus_2 = Iterables.<EObject>concat(_plus_1, _allGroups);
    Collection<? extends AbstractElement> _allUnorderedGroups = GrammarUtil.getAllUnorderedGroups(g);
    Iterable<EObject> _plus_3 = Iterables.<EObject>concat(_plus_2, _allUnorderedGroups);
    Collection<? extends AbstractElement> _allAssignments = GrammarUtil.getAllAssignments(g);
    final Function1<EObject, Boolean> _function = (EObject it) -> {
      return Boolean.valueOf(this._grammarAccessExtensions.isCalled(GrammarUtil.containingRule(it), g));
    };
    Iterable<EObject> _filter = IterableExtensions.<EObject>filter(Iterables.<EObject>concat(_plus_3, _allAssignments), _function);
    for(final EObject rule : _filter) {
      _builder.newLine();
      CharSequence _compileRule = this.compileRule(rule, g, options);
      _builder.append(_compileRule);
      _builder.newLineIfNotEmpty();
    }
  }
  {
    boolean _isCombinedGrammar = this.isCombinedGrammar();
    if (_isCombinedGrammar) {
      CharSequence _compileTerminalRules = this.compileTerminalRules(g, options);
      _builder.append(_compileTerminalRules);
      _builder.newLineIfNotEmpty();
    }
  }
  return _builder;
}
 

/** Returns all grammars from the hierarchy that are used from rules of this grammar.
 *
 * @param grammar the grammar.
 * @return the used grammars.
 */
protected static List<Grammar> getEffectivelyUsedGrammars(final Grammar grammar) {
	final List<AbstractRule> allRules = GrammarUtil.allRules(grammar);
	final List<Grammar> map = ListExtensions.<AbstractRule, Grammar>map(allRules, it -> GrammarUtil.getGrammar(it));
	final Iterable<Grammar> filter = IterableExtensions.<Grammar>filter(map, it -> Boolean.valueOf(it != grammar));
	final Set<Grammar> set = IterableExtensions.<Grammar>toSet(filter);
	return IterableExtensions.<Grammar>toList(set);
}
 

@Override
protected Iterable<JvmMember> _getMembersToBeCompiled(final JvmGenericType it) {
  Iterable<JvmMember> _xifexpression = null;
  boolean _isLocal = it.isLocal();
  if (_isLocal) {
    final Function1<JvmMember, Boolean> _function = (JvmMember it_1) -> {
      return Boolean.valueOf((it_1 instanceof JvmOperation));
    };
    _xifexpression = IterableExtensions.<JvmMember>filter(it.getMembers(), _function);
  } else {
    _xifexpression = this._getMembersToBeCompiled(((JvmDeclaredType) it));
  }
  return _xifexpression;
}
 

protected Iterable<JvmMember> _getMembersToBeCompiled(final JvmGenericType it) {
  Iterable<JvmMember> _xifexpression = null;
  boolean _isAnonymous = it.isAnonymous();
  if (_isAnonymous) {
    final Function1<JvmMember, Boolean> _function = (JvmMember it_1) -> {
      return Boolean.valueOf((!(it_1 instanceof JvmConstructor)));
    };
    _xifexpression = IterableExtensions.<JvmMember>filter(it.getMembers(), _function);
  } else {
    _xifexpression = this._getMembersToBeCompiled(((JvmDeclaredType) it));
  }
  return _xifexpression;
}
 

protected Iterable<IReferenceDescription> getNotImportTypeReferences(Iterable<IReferenceDescription> referenceDescriptions) {
	return IterableExtensions.filter(referenceDescriptions, new Functions.Function1<IReferenceDescription, Boolean>() {

		@Override
		public Boolean apply(IReferenceDescription p) {
			return !isImportTypeReference(p);
		}
		
	});
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public EList<N4MethodDeclaration> getOwnedMethods() {
	final Function1<N4MethodDeclaration, Boolean> _function = new Function1<N4MethodDeclaration, Boolean>() {
		public Boolean apply(final N4MethodDeclaration it) {
			return Boolean.valueOf(((!it.isConstructor()) && (!it.isCallableConstructor())));
		}
	};
	final Iterable<N4MethodDeclaration> methods = IterableExtensions.<N4MethodDeclaration>filter(Iterables.<N4MethodDeclaration>filter(this.getOwnedMembersRaw(), N4MethodDeclaration.class), _function);
	List<N4MethodDeclaration> _list = IterableExtensions.<N4MethodDeclaration>toList(methods);
	return new BasicEList<N4MethodDeclaration>(_list);
}
 

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public EList<N4MemberDeclaration> getOwnedMembers() {
	final Function1<N4MemberDeclaration, Boolean> _function = new Function1<N4MemberDeclaration, Boolean>() {
		public Boolean apply(final N4MemberDeclaration it) {
			boolean _isCallableConstructor = it.isCallableConstructor();
			return Boolean.valueOf((!_isCallableConstructor));
		}
	};
	final Iterable<N4MemberDeclaration> methods = IterableExtensions.<N4MemberDeclaration>filter(Iterables.<N4MemberDeclaration>filter(this.getOwnedMembersRaw(), N4MemberDeclaration.class), _function);
	List<N4MemberDeclaration> _list = IterableExtensions.<N4MemberDeclaration>toList(methods);
	return new BasicEList<N4MemberDeclaration>(_list);
}
 

private Iterable<Comment> unAssignedComments(final CompilationUnit cu) {
  final Function1<Comment, Boolean> _function = (Comment c) -> {
    return Boolean.valueOf(((!(c.isDocComment() && (c.getParent() != null))) && this.notAssigned(c)));
  };
  return IterableExtensions.<Comment>filter(cu.getCommentList(), _function);
}
 

public Iterable<? extends FieldDeclaration> getDataFields(final ClassDeclaration it) {
  final Function1<FieldDeclaration, Boolean> _function = (FieldDeclaration it_1) -> {
    return Boolean.valueOf(((!it_1.isStatic()) && this.context.isThePrimaryGeneratedJavaElement(it_1)));
  };
  return IterableExtensions.filter(it.getDeclaredFields(), _function);
}
 

public static Iterable<EReference> allContainmentReferences(final EClass it) {
  final Function1<EReference, Boolean> _function = (EReference f) -> {
    return Boolean.valueOf(f.isContainment());
  };
  return IterableExtensions.<EReference>filter(Iterables.<EReference>filter(Ecore2XtextExtensions.inlinedFeatures(it), EReference.class), _function);
}
 

public static Iterable<EStructuralFeature> prefixFeatures(final EClass it) {
  final Function1<EStructuralFeature, Boolean> _function = (EStructuralFeature f) -> {
    return Boolean.valueOf((Ecore2XtextExtensions.needsAssignment(f) && Ecore2XtextExtensions.isPrefixBooleanFeature(f)));
  };
  return IterableExtensions.<EStructuralFeature>filter(it.getEAllStructuralFeatures(), _function);
}
 

protected ISourceAppender appendTypeParameters(final ISourceAppender appendable, final List<JvmTypeParameter> typeParameters) {
  ISourceAppender _xblockexpression = null;
  {
    final Iterator<JvmTypeParameter> iterator = typeParameters.iterator();
    boolean _hasNext = iterator.hasNext();
    if (_hasNext) {
      appendable.append("<");
      do {
        {
          final JvmTypeParameter typeParameter = iterator.next();
          appendable.append(typeParameter.getName());
          final Function1<JvmUpperBound, Boolean> _function = (JvmUpperBound it) -> {
            String _identifier = it.getTypeReference().getIdentifier();
            return Boolean.valueOf((!Objects.equal(_identifier, "java.lang.Object")));
          };
          final Iterable<JvmUpperBound> upperBounds = IterableExtensions.<JvmUpperBound>filter(Iterables.<JvmUpperBound>filter(typeParameter.getConstraints(), JvmUpperBound.class), _function);
          boolean _isEmpty = IterableExtensions.isEmpty(upperBounds);
          boolean _not = (!_isEmpty);
          if (_not) {
            appendable.append(" extends ");
            boolean isFirst = true;
            final StandardTypeReferenceOwner owner = new StandardTypeReferenceOwner(this.services, this.context);
            for (final JvmUpperBound upperBound : upperBounds) {
              {
                if ((!isFirst)) {
                  appendable.append(" & ");
                }
                isFirst = false;
                this.appendType(appendable, owner.toLightweightTypeReference(upperBound.getTypeReference()), "Object");
              }
            }
          }
          boolean _hasNext_1 = iterator.hasNext();
          if (_hasNext_1) {
            appendable.append(",");
          }
        }
      } while(iterator.hasNext());
      appendable.append("> ");
    }
    _xblockexpression = appendable;
  }
  return _xblockexpression;
}