@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 protected Promise<List<Node>> getChildrenImpl() { List<Node> children = new ArrayList<>(); children.addAll(commands); return promiseProvider.resolve(children); } }
@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); } }
@Override public Promise<List<Node>> intercept(Node parent, List<Node> children) { List<Node> nodes = new ArrayList<>(); for (Node node : children) { if (!node.isLeaf()) { nodes.add(node); } } return promises.resolve(nodes); }
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()); }); }
@Override protected Promise<List<Node>> getChildrenImpl() { return promiseProvider.resolve( symbol .getChildren() .stream() .map(child -> new SymbolNode(symbolIcons, promiseProvider, delegate, child)) .collect(Collectors.toList())); }
/** * Returns promise that resolves preview URL for the given process. Returns promise that rejects * with an error if preview URL isn't available. */ private Promise<String> getPreviewUrlByName(String name) { return commandManager .getCommand(name) .map(CommandImpl::getPreviewURL) .filter(it -> !it.isEmpty()) .map(s -> macroProcessorProvider.get().expandMacros(s)) .orElseGet(() -> promiseProvider.resolve(messages.previewsNotAvailableError())); }
/** {@inheritDoc} */ @Override public Promise<String> expand() { return promises.resolve(appContext.getWorkspace().getNamespace()); } }
private Promise<Node> doExpand(Node node) { projectExplorer.getTree().setExpanded(node, true); return promises.resolve(null); }
private Promise<Void> doProcessDeleteChanges(List<FileChange> changes) { List<FileChange> deleteChanges = getDeleteFileChanges(changes); if (deleteChanges.isEmpty()) { return ProjectTreeChangeHandler.this.promises.resolve(null); } List<ResourceDelta> deleteResourceDeltas = getDeleteResourceDeltas(deleteChanges); return synchronizeChanges(deleteResourceDeltas); }
@Override public Promise<List<? extends Breakpoint>> getAllBreakpoints() { if (!isConnected()) { promiseProvider.reject("Debugger is not connected"); } return service .getAllBreakpoints(debugSessionDto.getId()) .thenPromise( breakpoints -> promiseProvider.resolve( breakpoints.stream().map(BreakpointImpl::new).collect(Collectors.toList()))); }
/** {@inheritDoc} */ @Override public Promise<String> expand() { final EditorPartPresenter editor = getActiveEditor(); if (editor == null) { return promises.resolve(""); } final Path absolutePath = appContext.getProjectsRoot().append(editor.getEditorInput().getFile().getLocation()); return promises.resolve(absolutePath.toString()); } }
/** Collects current IDE state {@link #collectAppStateData()} and saves on server side. */ public Promise<Void> persistState() { JsonObject newAppState = collectAppStateData(); if (appState == null || !appState.toJson().equals(newAppState.toJson())) { appState = newAppState; return appStateService.saveState(newAppState.toJson()); } else { return promises.resolve(null); } }
private Promise<Void> doProcessSingleChange(FileChange change) { if (isFileInRootDirectory(change)) { return promises.resolve(null); } return isNullOrEmpty(change.getPath()) ? synchronizeChanges() : synchronizeChanges(getResourceDelta(change)); }
private Promise<Void> onExternalDeltaAdded(final ResourceDelta delta) { return findResource(delta.getToPath()) .thenPromise( resource -> { if (resource.isPresent()) { eventBus.fireEvent( new ResourceChangedEvent( new ResourceDeltaImpl(resource.get(), ADDED | DERIVED))); } return promises.resolve(null); }); }
private Promise<Void> onExternalDeltaRemoved(final ResourceDelta delta) { final Optional<Resource> resourceOptional = store.getResource(delta.getFromPath()); if (resourceOptional.isPresent()) { final Resource resource = resourceOptional.get(); store.dispose(resource.getLocation(), true); eventBus.fireEvent( new ResourceChangedEvent(new ResourceDeltaImpl(resource, REMOVED | DERIVED))); } return promises.resolve(null); }
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)); }
/** Updates the commands. */ Promise<List<CommandImpl>> fetchCommands() { return workspaceServiceClient .getWorkspace(appContext.getWorkspaceId()) .thenPromise( workspace -> { updateWorkspace().apply(workspace); return promiseProvider.resolve(getCommands()); }); }