public boolean containsComment() { int _size = IterableExtensions.size(Iterables.<CommentInfo>filter(this.leafs, CommentInfo.class)); return (_size > 0); }
/** * return Iterable exluding the last element */ public <T extends Object> Iterable<T> butLast(final Iterable<T> includingLast) { int _size = IterableExtensions.size(includingLast); int _minus = (_size - 1); return IterableExtensions.<T>take(includingLast, _minus); }
/** * Calculates the correct package path for a selected fqn */ public String getPackagePath(final String fqn) { String _xblockexpression = null; { final Iterable<String> split = Splitter.on(".").split(fqn); int _size = IterableExtensions.size(split); int _minus = (_size - 1); _xblockexpression = IterableExtensions.join(IterableExtensions.<String>take(split, _minus), "/"); } return _xblockexpression; }
public Boolean apply(final EObject item) { boolean _xifexpression = false; EList<EObject> _eContents = item.eContents(); boolean _notEquals = (!Objects.equal(_eContents, null)); if (_notEquals) { EList<EObject> _eContents_1 = item.eContents(); Iterable<SetOfGuiElements> _filter = Iterables.<SetOfGuiElements>filter(_eContents_1, SetOfGuiElements.class); int _size = IterableExtensions.size(_filter); boolean _greaterThan = (_size > 0); _xifexpression = _greaterThan; } else { _xifexpression = false; } return Boolean.valueOf(_xifexpression); } };
public Boolean apply(final EObject item) { boolean _xifexpression = false; EList<EObject> _eContents = item.eContents(); boolean _notEquals = (!Objects.equal(_eContents, null)); if (_notEquals) { EList<EObject> _eContents_1 = item.eContents(); Iterable<CustomizeableField> _filter = Iterables.<CustomizeableField>filter(_eContents_1, CustomizeableField.class); int _size = IterableExtensions.size(_filter); boolean _greaterThan = (_size > 0); _xifexpression = _greaterThan; } else { _xifexpression = false; } return Boolean.valueOf(_xifexpression); } };
/** * Calculates the correct package path for a selected fqn */ public String getPackagePath(final String fqn) { String _xblockexpression = null; { Splitter _on = Splitter.on("."); final Iterable<String> split = _on.split(fqn); int _size = IterableExtensions.size(split); int _minus = (_size - 1); Iterable<String> _take = IterableExtensions.<String>take(split, _minus); _xblockexpression = IterableExtensions.join(_take, "/"); } return _xblockexpression; }
public boolean hasMethodWithArguments(final FInterface interfaceType) { EList<FMethod> _methods = interfaceType.getMethods(); for (final FMethod method : _methods) { int _size = IterableExtensions.size(this._methodUtil.getInputParameters(method)); boolean _greaterThan = (_size > 0); if (_greaterThan) { return true; } } return false; }
public void visitAll(final Iterable<? extends ASTNode> iterable, final String separator) { final Procedure2<ASTNode, Integer> _function = (ASTNode node, Integer counter) -> { node.accept(this); if (((separator != null) && ((counter).intValue() < (IterableExtensions.size(iterable) - 1)))) { this.appendToBuffer(separator); } }; IterableExtensions.forEach(iterable, _function); }
public boolean isOpenInWindow(final Command command) { CommandImplementation _implementation = command==null?(CommandImplementation)null:command.getImplementation(); EList<Statement> _statements = _implementation==null?(EList<Statement>)null:_implementation.getStatements(); Iterable<InvokeStatement> _filter = _statements==null?(Iterable<InvokeStatement>)null:Iterables.<InvokeStatement>filter(_statements, InvokeStatement.class); final Function1<InvokeStatement,Boolean> _function = new Function1<InvokeStatement,Boolean>() { public Boolean apply(final InvokeStatement s) { TargetPageRole _targetPageRole = s.getTargetPageRole(); String _string = _targetPageRole.toString(); boolean _equals = _string.equals("window"); return Boolean.valueOf(_equals); } }; Iterable<InvokeStatement> _filter_1 = _filter==null?(Iterable<InvokeStatement>)null:IterableExtensions.<InvokeStatement>filter(_filter, _function); int _size = _filter_1==null?0:IterableExtensions.size(_filter_1); return (_size > 0); }
@Check public void checkOnlyOneEntityId(final Entity entity) { int _size = IterableExtensions.size(Iterables.<EntityId>filter(DddCollectionExtensions.<AbstractElement>nullSafe(entity.getElements()), EntityId.class)); boolean _greaterThan = (_size > 1); if (_greaterThan) { this.error( "Only one \'entity-id\' can be defined inside an entity", entity, DomainDrivenDesignDslPackage.Literals.ABSTRACT_ENTITY__ELEMENTS, DomainDrivenDesignDslValidator.MULTIPLE_ENTITY_ID_ELEMENTS); } }
@Check public void checkOnlyOneAggregateId(final Aggregate aggregate) { int _size = IterableExtensions.size(Iterables.<AggregateId>filter(DddCollectionExtensions.<AbstractElement>nullSafe(aggregate.getElements()), AggregateId.class)); boolean _greaterThan = (_size > 1); if (_greaterThan) { this.error( "Only one \'aggregate-id\' can be defined inside an aggregate", aggregate, DomainDrivenDesignDslPackage.Literals.ABSTRACT_ENTITY__ELEMENTS, DomainDrivenDesignDslValidator.MULTIPLE_AGGREGATE_ID_ELEMENTS); } }
public boolean isSingleSyntheticDefaultConstructor(final JvmConstructor it) { return ((((it.getParameters().isEmpty() && (this._iLogicalContainerProvider.getAssociatedExpression(it) == null)) && (this.getCompilationStrategy(it) == null)) && (this.getCompilationTemplate(it) == null)) && (IterableExtensions.size(Iterables.<JvmConstructor>filter(it.getDeclaringType().getMembers(), JvmConstructor.class)) == 1)); }
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); }
/** * add a list of additional class path entries to this project (if it has the java nature) */ public void addClasspathEntries(final IProject project, final Iterable<IClasspathEntry> entriesToAdd) { try { boolean _hasJavaNature = this.hasJavaNature(project); if (_hasJavaNature) { final IJavaProject javaProject = JavaCore.create(project); final IClasspathEntry[] existingClasspath = javaProject.getRawClasspath(); int _length = existingClasspath.length; int _size = IterableExtensions.size(entriesToAdd); int _plus = (_length + _size); final IClasspathEntry[] newClasspathEntries = new IClasspathEntry[_plus]; final IClasspathEntry[] result = IterableExtensions.<IClasspathEntry>toList(Iterables.<IClasspathEntry>concat(entriesToAdd, ((Iterable<? extends IClasspathEntry>)Conversions.doWrapArray(existingClasspath)))).<IClasspathEntry>toArray(newClasspathEntries); javaProject.setRawClasspath(result, NullProgressMonitor.class.getDeclaredConstructor().newInstance()); } } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
private IMethodBinding internalFindOverride(final IMethodBinding method, final ITypeBinding superType, final boolean onlyPrimarylevel) { final Function1<IMethodBinding, Boolean> _function = (IMethodBinding it) -> { return Boolean.valueOf(method.overrides(it)); }; final Iterable<IMethodBinding> superClassOverride = IterableExtensions.<IMethodBinding>filter(((Iterable<IMethodBinding>)Conversions.doWrapArray(superType.getDeclaredMethods())), _function); int _size = IterableExtensions.size(superClassOverride); boolean _equals = (_size == 1); if (_equals) { return ((IMethodBinding[])Conversions.unwrapArray(superClassOverride, IMethodBinding.class))[0]; } else { if ((!onlyPrimarylevel)) { return this.findOverride(method, superType); } else { return null; } } }
public void assertSingleCommit(final Git git, final int numberOfCommitsBefore, final DiffEntry.ChangeType expectedChangeType, final String path) { try { final int numberOfCommitsAfter = IterableExtensions.size(git.log().call()); this._assertionHelper.assertEquals(numberOfCommitsAfter, (numberOfCommitsBefore + 1)); this.assertContainsChange(git, this.getLastCommit(git), expectedChangeType, path); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } }
protected boolean _isMultiParamInOwnLine(final XConstructorCall fc, final FormattableDocument doc) { final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(fc, ")"); HiddenLeafs _hiddenLeafsBefore = null; if (closingBracket!=null) { _hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket); } boolean _tripleNotEquals = (_hiddenLeafsBefore != null); if (_tripleNotEquals) { int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines(); return (_newLines > 0); } final Iterable<XExpression> params = this.explicitParams(fc.getArguments()); return ((IterableExtensions.size(params) > 1) && this.isEachExpressionInOwnLine(params)); }
protected boolean _isMultiParamInOwnLine(final XMemberFeatureCall fc, final FormattableDocument doc) { final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(fc, ")"); HiddenLeafs _hiddenLeafsBefore = null; if (closingBracket!=null) { _hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket); } boolean _tripleNotEquals = (_hiddenLeafsBefore != null); if (_tripleNotEquals) { int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines(); return (_newLines > 0); } final Iterable<XExpression> params = this.explicitParams(fc.getMemberCallArguments()); return ((IterableExtensions.size(params) > 1) && this.isEachExpressionInOwnLine(params)); }
protected boolean _isMultiParamInOwnLine(final XFeatureCall fc, final FormattableDocument doc) { final ILeafNode closingBracket = this._nodeModelAccess.nodeForKeyword(fc, ")"); HiddenLeafs _hiddenLeafsBefore = null; if (closingBracket!=null) { _hiddenLeafsBefore=this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket); } boolean _tripleNotEquals = (_hiddenLeafsBefore != null); if (_tripleNotEquals) { int _newLines = this._hiddenLeafAccess.getHiddenLeafsBefore(closingBracket).getNewLines(); return (_newLines > 0); } final Iterable<XExpression> params = this.explicitParams(fc.getFeatureCallArguments()); return ((IterableExtensions.size(params) > 1) && this.isEachExpressionInOwnLine(params)); }
@Override public void apply(final MutableMethodDeclaration it) { Iterable<? extends MutableParameterDeclaration> _parameters = it.getParameters(); int _size = IterableExtensions.size(_parameters); switch (_size) { case 0: ParamterlessMethodMemoizer _paramterlessMethodMemoizer = new ParamterlessMethodMemoizer(it, context); _paramterlessMethodMemoizer.generate(); break; case 1: SingleParameterMethodMemoizer _singleParameterMethodMemoizer = new SingleParameterMethodMemoizer(it, context); _singleParameterMethodMemoizer.generate(); break; default: MultipleParameterMethodMemoizer _multipleParameterMethodMemoizer = new MultipleParameterMethodMemoizer(it, context); _multipleParameterMethodMemoizer.generate(); break; } } };