/** * Creates a mutable {@link LinkedList} instance containing the given initial elements. * * @param initial * the initial elements that the list should contain, in order. May not be <code>null</code> but may * contain <code>null</code> values. * @return a new {@link LinkedList} containing those elements */ @SafeVarargs @Pure public static <T> LinkedList<T> newLinkedList(T... initial) { if (initial.length > 0) return Lists.newLinkedList(Arrays.asList(initial)); return newLinkedList(); }
public LinkedList<RuleFailedException> failureAsList(final RuleFailedException e) { LinkedList<RuleFailedException> _xblockexpression = null; { final LinkedList<RuleFailedException> list = CollectionLiterals.<RuleFailedException>newLinkedList(e); RuleFailedException ex = e.previous; while ((ex != null)) { { String _message = ex.getMessage(); boolean _tripleNotEquals = (_message != null); if (_tripleNotEquals) { list.add(ex); } ex = ex.previous; } } _xblockexpression = list; } return _xblockexpression; }
protected List<ConfigOverride> createConfiguration() { final LinkedList<ConfigOverride> result = CollectionLiterals.<ConfigOverride>newLinkedList(); ConfigOverride _config = ConfigOverride.config("server.applicationConnectors[0].port", "0"); result.add(_config); ConfigOverride _config_1 = ConfigOverride.config("server.adminConnectors[0].port", "0"); result.add(_config_1); return result; }
/** * Collects all fields declared in super types that are accessible from the * passed type. * * @return a list of all accessible fields declared in super classes */ public List<JvmField> getAllAccessibleSuperTypeFields(final JvmDeclaredType type) { final LinkedList<JvmField> result = CollectionLiterals.<JvmField>newLinkedList(); final Consumer<JvmDeclaredType> _function = (JvmDeclaredType it) -> { this.collectAccessibleFields(it, type, result); }; this.getSuperClasses(type).forEach(_function); return result; }
protected Injector createInjector() { final LinkedList<com.google.inject.Module> modules = CollectionLiterals.<com.google.inject.Module>newLinkedList(); this.collectModules(modules); return Guice.createInjector(AbstractTest.mixin(((com.google.inject.Module[])Conversions.unwrapArray(modules, com.google.inject.Module.class)))); }
public List<? extends SymbolInformation> getSymbols(final IResourceDescription resourceDescription, final String query, final IReferenceFinder.IResourceAccess resourceAccess, final CancelIndicator cancelIndicator) { final LinkedList<SymbolInformation> symbols = CollectionLiterals.<SymbolInformation>newLinkedList(); Iterable<IEObjectDescription> _exportedObjects = resourceDescription.getExportedObjects(); for (final IEObjectDescription description : _exportedObjects) { { this.operationCanceledManager.checkCanceled(cancelIndicator); boolean _filter = this.filter(description, query); if (_filter) { final Procedure1<SymbolInformation> _function = (SymbolInformation symbol) -> { symbols.add(symbol); }; this.createSymbol(description, resourceAccess, _function); } } } return symbols; }
@Override public List<MessageIssue> validate(final Message message) { final ArrayList<MessageIssue> result = CollectionLiterals.<MessageIssue>newArrayList(); try { LinkedList<Object> _newLinkedList = CollectionLiterals.<Object>newLinkedList(); this.validate(message, result, _newLinkedList); } catch (final Throwable _t) { if (_t instanceof Exception) { final Exception e = (Exception)_t; StringConcatenation _builder = new StringConcatenation(); _builder.append("Error during message validation: "); String _message = e.getMessage(); _builder.append(_message, ""); MessageIssue _messageIssue = new MessageIssue(_builder.toString()); result.add(_messageIssue); } else if (_t instanceof NoClassDefFoundError) { final NoClassDefFoundError e_1 = (NoClassDefFoundError)_t; String _message_1 = e_1.getMessage(); boolean _endsWith = _message_1.endsWith("Nullable"); boolean _not = (!_endsWith); if (_not) { throw e_1; } } else { throw Exceptions.sneakyThrow(_t); } } return result; }
public List<? extends SymbolInformation> getSymbols(final String query, final IReferenceFinder.IResourceAccess resourceAccess, final IResourceDescriptions indexData, final CancelIndicator cancelIndicator) { final LinkedList<SymbolInformation> result = CollectionLiterals.<SymbolInformation>newLinkedList(); Iterable<IResourceDescription> _allResourceDescriptions = indexData.getAllResourceDescriptions(); for (final IResourceDescription resourceDescription : _allResourceDescriptions) { { this.operationCanceledManager.checkCanceled(cancelIndicator); final IResourceServiceProvider resourceServiceProvider = this._registry.getResourceServiceProvider(resourceDescription.getURI()); DocumentSymbolService _get = null; if (resourceServiceProvider!=null) { _get=resourceServiceProvider.<DocumentSymbolService>get(DocumentSymbolService.class); } final DocumentSymbolService documentSymbolService = _get; if ((documentSymbolService != null)) { List<? extends SymbolInformation> _symbols = documentSymbolService.getSymbols(resourceDescription, query, resourceAccess, cancelIndicator); Iterables.<SymbolInformation>addAll(result, _symbols); } } } return result; } }
final LinkedList<Pair<StepContent, Optional<JvmTypeReference>>> result = CollectionLiterals.<Pair<StepContent, Optional<JvmTypeReference>>>newLinkedList(); final InteractionType interaction = this._tclModelUtil.getInteraction(step); if ((interaction != null)) {
/** * @return all {@link JvmType} of all fixtures that are referenced. */ private Set<JvmType> getFixtureTypes(final SetupAndCleanupProvider element) { final LinkedList<TestStepContext> contexts = CollectionLiterals.<TestStepContext>newLinkedList(); if ((element instanceof TestCase)) { final Function1<SpecificationStepImplementation, EList<TestStepContext>> _function = (SpecificationStepImplementation it) -> { return it.getContexts(); }; Iterable<TestStepContext> _filterNull = IterableExtensions.<TestStepContext>filterNull(Iterables.<TestStepContext>concat(ListExtensions.<SpecificationStepImplementation, EList<TestStepContext>>map(((TestCase)element).getSteps(), _function))); Iterables.<TestStepContext>addAll(contexts, _filterNull); } boolean _isEmpty = element.getSetup().isEmpty(); boolean _not = (!_isEmpty); if (_not) { EList<TestStepContext> _contexts = IterableExtensions.<TestSetup>head(element.getSetup()).getContexts(); Iterables.<TestStepContext>addAll(contexts, _contexts); } boolean _isEmpty_1 = element.getCleanup().isEmpty(); boolean _not_1 = (!_isEmpty_1); if (_not_1) { EList<TestStepContext> _contexts_1 = IterableExtensions.<TestCleanup>head(element.getCleanup()).getContexts(); Iterables.<TestStepContext>addAll(contexts, _contexts_1); } final Function1<TestStepContext, Set<JvmType>> _function_1 = (TestStepContext it) -> { return this.getTestStepFixtureTypes(it); }; return IterableExtensions.<JvmType>toSet(Iterables.<JvmType>concat(ListExtensions.<TestStepContext, Set<JvmType>>map(contexts, _function_1))); }
protected GuiceBundle<T> createGuiceBundle() { final LinkedList<com.google.inject.Module> modules = CollectionLiterals.<com.google.inject.Module>newLinkedList(); this.collectModules(modules); final GuiceBundle.Builder<T> builder = GuiceBundle.<T>newBuilder(); builder.addModule(DropwizardApplication.mixin(((com.google.inject.Module[])Conversions.unwrapArray(modules, com.google.inject.Module.class)))); builder.setConfigClass(this.getConfigurationClass()); return builder.build(); }
final JvmDeclaredType inferredType = this.associations.getInferredType(element); if (inferredType instanceof JvmGenericType) { final LinkedList<JvmTypeReference> inferredSuperTypes = CollectionLiterals.newLinkedList(); inferredSuperTypes.addAll(inferredType.getSuperTypes()); final boolean isExpectingInterface = expectedType.isInterface();