@Override protected Promise<List<Node>> getChildrenImpl() { return promiseProvider.resolve(packages); } }
private Promise<ProfileDto> loadProfile() { return getUserProfile() .catchError( (Operation<PromiseError>) arg -> { throw new OperationException("Unable to load user's profile: " + arg.getCause()); }); }
/** Returns an operation which shows an error notification with the given title. */ private Operation<PromiseError> showErrorNotification(String title) { return err -> { notificationManager.notify(title, err.getMessage(), FAIL, EMERGE_MODE); throw new OperationException(err.getMessage()); }; }
protected Promise<Void> initAppContext() { return getWorkspaceToStart() .then( (Function<WorkspaceImpl, Void>) workspace -> { ((AppContextImpl) appContext).setWorkspace(workspace); ((AppContextImpl) appContext).setStartAppActions(getStartUpActions()); return null; }) .catchError( (Operation<PromiseError>) err -> { throw new OperationException("Can not get workspace: " + err.getCause()); }); }
/** * Tries to set-up Super DevMode for the current IDE GWT app and shows an appropriate message to * the user. */ private void setUpSuperDevModeWithUI(String codeServerURL) { setUpSuperDevMode(codeServerURL) .then(showSuccessMessage(codeServerURL)) .catchError(handleStartRecompilationError(codeServerURL)); }
Promise<Optional<Container>> getContainer(final Path absolutePath) { return findResource(absolutePath) .thenPromise( optResource -> { if (optResource.isPresent()) { Resource resource = optResource.get(); checkState(resource instanceof Container, "Not a container"); return promises.resolve(of((Container) resource)); } return promises.resolve(absent()); }); }
/** Updates the commands. */ Promise<List<CommandImpl>> fetchCommands() { return workspaceServiceClient .getWorkspace(appContext.getWorkspaceId()) .thenPromise( workspace -> { updateWorkspace().apply(workspace); return promiseProvider.resolve(getCommands()); }); }
private Promise<Node> logError(PromiseError error) { Log.info(getClass(), error.getMessage()); return promises.resolve(null); }
private void onFailure(PromiseError error) { if (actionCompletedCallBack != null) { actionCompletedCallBack.onFailure(error.getCause()); } } }
@Override public void apply(PromiseError arg) throws OperationException { notificationManager.notify( "Problems with getting classpath", arg.getMessage(), FAIL, EMERGE_MODE); } });
private Promise<Map<String, String>> loadPreferences() { return preferencesManager .loadPreferences() .catchError( (Operation<PromiseError>) arg -> { throw new OperationException( messages.unableToLoadPreference() + ": " + arg.getCause()); }); }
private Promise<Void> doProcessMultipleChanges(List<FileChange> changes) { Promise<Void> multipleChainPromise = ProjectTreeChangeHandler.this.promises.resolve(null); List<FileChange> preProcessedChanges = skipFilesInTheRootDirectory(changes); multipleChainPromise = multipleChainPromise.thenPromise(ignored -> doProcessDeleteChanges(preProcessedChanges)); multipleChainPromise = multipleChainPromise.thenPromise(ignored -> doProcessUpdateChanges(preProcessedChanges)); return multipleChainPromise; }
@Override protected Promise<List<Node>> getChildrenImpl() { return promiseProvider.resolve(children); }
private Promise<Optional<Resource>> findResourceForExternalOperation(final Path absolutePath) { Promise<Void> derived = promises.resolve(null); for (int i = absolutePath.segmentCount() - 1; i > 0; i--) { final Path pathToCache = absolutePath.removeLastSegments(i); derived = derived.thenPromise(arg -> loadAndRegisterResources(pathToCache)); } return derived.thenPromise(ignored -> findResource(absolutePath)); }
private Promise<Void> onCatchErrorPromise(PromiseError ignored) { return ProjectTreeChangeHandler.this.promises.resolve(null); }
private Promise<Optional<Resource>> findResource(final Path absolutePath) { String[] segments = absolutePath.segments(); Promise<Optional<Resource>> chain = promises.resolve(null); for (int i = 0; i <= segments.length; i++) { Path pathToRetrieve = absolutePath.removeLastSegments(segments.length - i); chain = chain.thenPromise(ignored -> doFindResource(pathToRetrieve)); } return chain; }
private Promise<Void> resolvePromise(Object ignored) { return ProjectTreeChangeHandler.this.promises.resolve(null); }
@Override protected Promise<List<Node>> getChildrenImpl() { // Todo: current server side returns result of evaluation expression like simple string line, // so we have no children. return promiseProvider.resolve(emptyList()); }
@Override public Promise<List<Node>> intercept(Node parent, List<Node> children) { if (parent instanceof ResourceNode) { return transform((ResourceNode) parent, children); } else { return promises.resolve(children); } }
/** {@inheritDoc} */ @Override public Promise<Resource[]> apply(Resource[] children) throws FunctionException { if (children.length == 0 && !forceUpdate) { return getChildren(true); } return promiseProvider.resolve(children); } });