@Override public ExecutorService get() { ExecutorService _newCachedThreadPool = Executors.newCachedThreadPool(); final Procedure1<ExecutorService> _function = new Procedure1<ExecutorService>() { @Override public void apply(final ExecutorService it) { DatatypeServlet.this.executorServices.add(it); } }; return ObjectExtensions.<ExecutorService>operator_doubleArrow(_newCachedThreadPool, _function); } };
private ComposeData getComposeData(final Composite composite) { boolean _matched = false; if (!_matched) { if (composite instanceof IComposite) { final IComposite _iComposite = (IComposite)composite; _matched=true; ComposeData _elvis = null; Content _content = _iComposite.getContent(); ComposeData _composeLayout = _content==null?(ComposeData)null:_content.getComposeLayout(); if (_composeLayout != null) { _elvis = _composeLayout; } else { _elvis = ObjectExtensions.<ComposeData>operator_elvis(_composeLayout, null); } return _elvis; } } if (!_matched) { if (composite instanceof ITabPage) { final ITabPage _iTabPage = (ITabPage)composite; _matched=true; return _iTabPage.getComposeLayout(); } } return null; }
@Override public ExecutorService get() { ExecutorService _newCachedThreadPool = Executors.newCachedThreadPool(); final Procedure1<ExecutorService> _function = new Procedure1<ExecutorService>() { @Override public void apply(final ExecutorService it) { InformationModelServlet.this.executorServices.add(it); } }; return ObjectExtensions.<ExecutorService>operator_doubleArrow(_newCachedThreadPool, _function); } };
@Inject public void initialize(final Provider<IDValueConverter> idValueConverterProvider, final ElkGraphGrammarAccess grammarAccess) { IDValueConverter _get = idValueConverterProvider.get(); final Procedure1<IDValueConverter> _function = new Procedure1<IDValueConverter>() { @Override public void apply(final IDValueConverter it) { it.setRule(grammarAccess.getIDRule()); } }; IDValueConverter _doubleArrow = ObjectExtensions.<IDValueConverter>operator_doubleArrow(_get, _function); this.idValueConverter = _doubleArrow; }
@Inject public void initialize(final Provider<IDValueConverter> idValueConverterProvider, final ElkGraphGrammarAccess grammarAccess) { IDValueConverter _get = idValueConverterProvider.get(); final Procedure1<IDValueConverter> _function = new Procedure1<IDValueConverter>() { @Override public void apply(final IDValueConverter it) { it.setRule(grammarAccess.getIDRule()); } }; IDValueConverter _doubleArrow = ObjectExtensions.<IDValueConverter>operator_doubleArrow(_get, _function); this.idValueConverter = _doubleArrow; }
@Override public Resource createResource(final URI uri) { JavaResource _get = this.resourceProvider.get(); final Procedure1<JavaResource> _function = (JavaResource it) -> { it.setURI(uri); }; return ObjectExtensions.<JavaResource>operator_doubleArrow(_get, _function); } }
public <M extends Object, R extends Object> TextBox asTextBoxIn(final Function1<M, R> binding, final Panel panel) { TextBox _textBox = new TextBox(panel); final Procedure1<TextBox> _function = new Procedure1<TextBox>() { @Override public void apply(final TextBox it) { ArenaXTendFactory.this._arenaTypeSafeBindingExtensions.<M, R>bindValue(it, binding); } }; return ObjectExtensions.<TextBox>operator_doubleArrow(_textBox, _function); }
public static Mask mask(final int sourceArity, final int... sourceIndices) { Mask _createMask = RecipesHelper.FACTORY.createMask(); final Procedure1<Mask> _function = new Procedure1<Mask>() { @Override public void apply(final Mask it) { it.setSourceArity(sourceArity); EList<Integer> _sourceIndices = it.getSourceIndices(); Iterables.<Integer>addAll(_sourceIndices, ((Iterable<? extends Integer>)Conversions.doWrapArray(sourceIndices))); } }; return ObjectExtensions.<Mask>operator_doubleArrow(_createMask, _function); }
public static <T extends Object> CreationSettings<T> createMockCreationSettings(final Class<T> typeToMock) { CreationSettings<T> _creationSettings = new CreationSettings<T>(); final Procedure1<CreationSettings<T>> _function = new Procedure1<CreationSettings<T>>() { @Override public void apply(final CreationSettings<T> it) { it.setTypeToMock(typeToMock); } }; return ObjectExtensions.<CreationSettings<T>>operator_doubleArrow(_creationSettings, _function); } }
public static Mask mask(final int sourceArity, final Iterable<Integer> sourceIndices) { Mask _createMask = RecipesHelper.FACTORY.createMask(); final Procedure1<Mask> _function = new Procedure1<Mask>() { @Override public void apply(final Mask it) { it.setSourceArity(sourceArity); EList<Integer> _sourceIndices = it.getSourceIndices(); Iterables.<Integer>addAll(_sourceIndices, sourceIndices); } }; return ObjectExtensions.<Mask>operator_doubleArrow(_createMask, _function); }
protected boolean addIssue(final RefactoringIssueAcceptor.Severity severity, final String message) { ServerRefactoringIssueAcceptor.Issue _issue = new ServerRefactoringIssueAcceptor.Issue(); final Procedure1<ServerRefactoringIssueAcceptor.Issue> _function = (ServerRefactoringIssueAcceptor.Issue it) -> { it.severity = severity; it.message = message; }; ServerRefactoringIssueAcceptor.Issue _doubleArrow = ObjectExtensions.<ServerRefactoringIssueAcceptor.Issue>operator_doubleArrow(_issue, _function); return this.issues.add(_doubleArrow); }
public static ProjectionIndexerRecipe projectionIndexerRecipe(final ReteNodeRecipe parent, final Mask mask) { ProjectionIndexerRecipe _createProjectionIndexerRecipe = RecipesHelper.FACTORY.createProjectionIndexerRecipe(); final Procedure1<ProjectionIndexerRecipe> _function = new Procedure1<ProjectionIndexerRecipe>() { @Override public void apply(final ProjectionIndexerRecipe it) { it.setParent(parent); it.setMask(mask); } }; return ObjectExtensions.<ProjectionIndexerRecipe>operator_doubleArrow(_createProjectionIndexerRecipe, _function); }
public static ExpressionDefinition expressionDefinition(final Object evaluator) { ExpressionDefinition _createExpressionDefinition = RecipesHelper.FACTORY.createExpressionDefinition(); final Procedure1<ExpressionDefinition> _function = new Procedure1<ExpressionDefinition>() { @Override public void apply(final ExpressionDefinition it) { it.setEvaluator(evaluator); } }; return ObjectExtensions.<ExpressionDefinition>operator_doubleArrow(_createExpressionDefinition, _function); }
public <M extends Object, R extends Object> Selector<R> asSelectorIn(final Function1<M, R> binding, final Panel panel) { Selector<R> _selector = new Selector<R>(panel); final Procedure1<Selector<R>> _function = new Procedure1<Selector<R>>() { @Override public void apply(final Selector<R> it) { ArenaXTendFactory.this._arenaTypeSafeBindingExtensions.<M, R>bindValue(it, binding); } }; return ObjectExtensions.<Selector<R>>operator_doubleArrow(_selector, _function); }
public <M extends Object, R extends Object> Label asLabelIn(final Function1<M, R> binding, final Panel panel) { Label _label = new Label(panel); final Procedure1<Label> _function = new Procedure1<Label>() { @Override public void apply(final Label it) { ArenaXTendFactory.this._arenaTypeSafeBindingExtensions.<M, R>bindValue(it, binding); } }; return ObjectExtensions.<Label>operator_doubleArrow(_label, _function); }
public static InputRecipe inputRecipe(final Object inputKey, final String inputKeyID, final int arity) { InputRecipe _createInputRecipe = RecipesHelper.FACTORY.createInputRecipe(); final Procedure1<InputRecipe> _function = new Procedure1<InputRecipe>() { @Override public void apply(final InputRecipe it) { it.setInputKey(inputKey); it.setKeyArity(arity); it.setKeyID(inputKeyID); it.setTraceInfo(inputKeyID); } }; return ObjectExtensions.<InputRecipe>operator_doubleArrow(_createInputRecipe, _function); }
/** * Copies the signature of the given base method so that you only have to add a body in most cases. * You are free to modify the default settings, of course, e.g. widening the visibility of the * implementing method. * @return the new implementation method */ public MutableMethodDeclaration addImplementationFor(final MutableClassDeclaration cls, final ResolvedMethod baseMethod, final StringConcatenationClient implementation) { MutableMethodDeclaration _createImplementation = this.createImplementation(cls, baseMethod); final Procedure1<MutableMethodDeclaration> _function = new Procedure1<MutableMethodDeclaration>() { @Override public void apply(final MutableMethodDeclaration it) { it.setBody(implementation); } }; return ObjectExtensions.<MutableMethodDeclaration>operator_doubleArrow(_createImplementation, _function); }
@Override public void execute(final BintrayReleasePlugin plugin) { ExtensionContainer _extensions = it.getExtensions(); BintrayExtension _byType = _extensions.<BintrayExtension>getByType(BintrayExtension.class); final Procedure1<BintrayExtension> _function = new Procedure1<BintrayExtension>() { @Override public void apply(final BintrayExtension it) { it.setUser("oehme"); BintrayExtension.PackageConfig _pkg = it.getPkg(); BintrayExtension.VersionConfig _version = _pkg.getVersion(); BintrayExtension.MavenCentralSyncConfig _mavenCentralSync = _version.getMavenCentralSync(); _mavenCentralSync.setUser("oehme"); } }; ObjectExtensions.<BintrayExtension>operator_doubleArrow(_byType, _function); } };
/** * Mask can be null in case no tuple reordering or trimming is needed */ public static InputFilterRecipe inputFilterRecipe(final ReteNodeRecipe parent, final Object inputKey, final String inputKeyID, final Mask mask) { InputFilterRecipe _createInputFilterRecipe = RecipesHelper.FACTORY.createInputFilterRecipe(); final Procedure1<InputFilterRecipe> _function = new Procedure1<InputFilterRecipe>() { @Override public void apply(final InputFilterRecipe it) { it.setParent(parent); it.setInputKey(inputKey); it.setKeyID(inputKeyID); it.setTraceInfo(inputKeyID); it.setMask(mask); } }; return ObjectExtensions.<InputFilterRecipe>operator_doubleArrow(_createInputFilterRecipe, _function); } }
protected String getMessageWithStackTrace(final Throwable t) { final Function1<Throwable, String> _function = (Throwable it) -> { String _xblockexpression = null; { StringWriter _stringWriter = new StringWriter(); final Procedure1<StringWriter> _function_1 = (StringWriter it_1) -> { PrintWriter _printWriter = new PrintWriter(it_1); final Procedure1<PrintWriter> _function_2 = (PrintWriter it_2) -> { it_2.println(this.getMessageWithoutStackTrace(t)); t.printStackTrace(it_2); it_2.flush(); }; ObjectExtensions.<PrintWriter>operator_doubleArrow(_printWriter, _function_2); }; final StringWriter writer = ObjectExtensions.<StringWriter>operator_doubleArrow(_stringWriter, _function_1); _xblockexpression = writer.toString(); } return _xblockexpression; }; return this.getMessageWithReducedStackTrace(t, _function); }