public List<ShelvedChangeList> importChangeLists( final Collection<VirtualFile> files, final Consumer<VcsException> exceptionConsumer) { final List<ShelvedChangeList> result = new ArrayList<ShelvedChangeList>(files.size()); try { final FilesProgress filesProgress = new FilesProgress(files.size(), "Processing "); for (VirtualFile file : files) { filesProgress.updateIndicator(file); final String description = file.getNameWithoutExtension().replace('_', ' '); final File patchPath = getPatchPath(description); final ShelvedChangeList list = new ShelvedChangeList( patchPath.getPath(), description, new SmartList<ShelvedBinaryFile>(), file.getTimeStamp()); try { final List<TextFilePatch> patchesList = loadPatches(myProject, file.getPath(), new CommitContext()); if (!patchesList.isEmpty()) { FileUtil.copy(new File(file.getPath()), patchPath); // add only if ok to read patch myShelvedChangeLists.add(list); result.add(list); } } catch (IOException e) { exceptionConsumer.consume(new VcsException(e)); } catch (PatchSyntaxException e) { exceptionConsumer.consume(new VcsException(e)); } } } finally { notifyStateChanged(); } return result; }
public static void selectSdkHome( @NotNull final SdkType sdkType, @NotNull final Consumer<String> consumer) { final FileChooserDescriptor descriptor = sdkType.getHomeChooserDescriptor(); if (ApplicationManager.getApplication().isUnitTestMode()) { Sdk sdk = ProjectJdkTable.getInstance().findMostRecentSdkOfType(sdkType); if (sdk == null) throw new RuntimeException("No SDK of type " + sdkType + " found"); consumer.consume(sdk.getHomePath()); return; } FileChooser.chooseFiles( descriptor, null, getSuggestedSdkRoot(sdkType), chosen -> { final String path = chosen.get(0).getPath(); if (sdkType.isValidSdkHome(path)) { consumer.consume(path); return; } final String adjustedPath = sdkType.adjustSelectedSdkHome(path); if (sdkType.isValidSdkHome(adjustedPath)) { consumer.consume(adjustedPath); } }); }
@Override protected void createActions(Consumer<AnAction> actionConsumer) { actionConsumer.consume(myPresetUserAction); actionConsumer.consume(myAllAction); actionConsumer.consume(mySelectMe); actionConsumer.consume(mySelect); }
public static boolean isJsonSchema( @NotNull JsonSchemaExportedDefinitions definitions, @NotNull VirtualFile key, @NotNull final String string, Consumer<String> errorConsumer) throws IOException { final JsonSchemaReader reader = new JsonSchemaReader(key); java.io.StringReader stringReader = new java.io.StringReader(string); try { reader.read(stringReader, null); } catch (Exception e) { LOG.info(e); errorConsumer.consume(e.getMessage()); return false; } // have two stages so that just syntax errors do not clear cache stringReader = new java.io.StringReader(string); try { reader.read(stringReader, definitions); } catch (Exception e) { LOG.info(e); errorConsumer.consume(e.getMessage()); throw e; } return true; }
private static void addBreakContinue(Consumer<LookupElement> result, PsiElement position) { PsiLoopStatement loop = PsiTreeUtil.getParentOfType(position, PsiLoopStatement.class); LookupElement br = createKeyword(position, PsiKeyword.BREAK); LookupElement cont = createKeyword(position, PsiKeyword.CONTINUE); TailType tailType; if (psiElement() .insideSequence( true, psiElement(PsiLabeledStatement.class), or( psiElement(PsiFile.class), psiElement(PsiMethod.class), psiElement(PsiClassInitializer.class))) .accepts(position)) { tailType = TailType.HUMBLE_SPACE_BEFORE_WORD; } else { tailType = TailType.SEMICOLON; } br = TailTypeDecorator.withTail(br, tailType); cont = TailTypeDecorator.withTail(cont, tailType); if (loop != null && new InsideElementFilter(new ClassFilter(PsiStatement.class)) .isAcceptable(position, loop)) { result.consume(br); result.consume(cont); } if (psiElement().inside(PsiSwitchStatement.class).accepts(position)) { result.consume(br); } }
private void processReference(String prefix, SReference ref, Consumer<SReference> consumer) { if (!(ref instanceof StaticReference)) return; SNodeId target = ref.getTargetNodeId(); if (!(target instanceof Foreign)) return; String targetNodeIdStr = target.toString(); boolean found = false; int idx = targetNodeIdStr.indexOf(prefix); while (idx >= 0) { if (idx == 0) { found = true; break; } char c = targetNodeIdStr.charAt(idx - 1); if (c == '.' || Character.isLetterOrDigit(c)) { idx = targetNodeIdStr.indexOf(prefix, idx + 1); continue; } found = true; break; } if (found) { consumer.consume(ref); } }
@Nullable private <T extends RefElement> T getFromRefTableOrCache( final PsiElement element, @NotNull NullableFactory<T> factory, @Nullable Consumer<T> whenCached) { PsiAnchor psiAnchor = createAnchor(element); T result; synchronized (myRefTable) { //noinspection unchecked result = (T) myRefTable.get(psiAnchor); if (result != null) return result; if (!isValidPointForReference()) { // LOG.assertTrue(true, "References may become invalid after process is finished"); return null; } result = factory.create(); if (result == null) return null; myRefTable.put(psiAnchor, result); mySortedRefs = null; if (whenCached != null) { whenCached.consume(result); } } return result; }
private void processListenerProperties(@NotNull PsiMethod method) { if (!method.getName().startsWith("add") || method.getParameterList().getParametersCount() != 1) return; final PsiParameter parameter = method.getParameterList().getParameters()[0]; final PsiType type = parameter.getType(); if (!(type instanceof PsiClassType)) return; final PsiClassType classType = (PsiClassType) type; final PsiClass listenerClass = classType.resolve(); if (listenerClass == null) return; final PsiMethod[] listenerMethods = listenerClass.getMethods(); if (!InheritanceUtil.isInheritorOrSelf(listenerClass, myEventListener, true)) return; for (PsiMethod listenerMethod : listenerMethods) { final String name = listenerMethod.getName(); if (myPropertyNames.add(name)) { LookupElementBuilder builder = LookupElementBuilder.create( generatePropertyResolveResult(name, listenerMethod, null, null), name) .withIcon(JetgroovyIcons.Groovy.Property); myConsumer.consume(builder); } } }
private void walk( @NotNull Collection<Integer> startNodes, final boolean goDown, @NotNull final Consumer<Integer> consumer) { synchronized (myTempFlags) { myTempFlags.setAll(false); for (int start : startNodes) { if (start < 0) continue; if (myTempFlags.get(start)) continue; myTempFlags.set(start, true); consumer.consume(start); myDfsUtil.nodeDfsIterator( start, new DfsUtil.NextNode() { @Override public int fun(int currentNode) { for (int downNode : myGraph.getNodes( currentNode, goDown ? LiteLinearGraph.NodeFilter.DOWN : LiteLinearGraph.NodeFilter.UP)) { if (!myTempFlags.get(downNode)) { myTempFlags.set(downNode, true); consumer.consume(downNode); return downNode; } } return NODE_NOT_FOUND; } }); } } }
public static void updateModel( @NotNull final Module module, @NotNull Consumer<ModifiableRootModel> task) { final ModifiableRootModel model = ApplicationManager.getApplication() .runReadAction( new Computable<ModifiableRootModel>() { @Override public ModifiableRootModel compute() { return ModuleRootManager.getInstance(module).getModifiableModel(); } }); try { task.consume(model); doWriteAction( new Runnable() { @Override public void run() { model.commit(); } }); } catch (RuntimeException e) { model.dispose(); throw e; } catch (Error e) { model.dispose(); throw e; } }
private static void addUnfinishedMethodTypeParameters( PsiElement position, final Consumer<LookupElement> result) { final ProcessingContext context = new ProcessingContext(); if (psiElement() .inside( psiElement(PsiTypeElement.class) .afterLeaf( psiElement() .withText(">") .withParent( psiElement(PsiTypeParameterList.class) .withParent(PsiErrorElement.class) .save("typeParameterList")))) .accepts(position, context)) { final PsiTypeParameterList list = (PsiTypeParameterList) context.get("typeParameterList"); PsiElement current = list.getParent().getParent(); if (current instanceof PsiField) { current = current.getParent(); } if (current instanceof PsiClass) { for (PsiTypeParameter typeParameter : list.getTypeParameters()) { result.consume(new JavaPsiClassReferenceElement(typeParameter)); } } } }
@Override public void setSelected(AnActionEvent e, boolean state) { if (state) { myTodoFilterConsumer.consume(myFilter); // setTodoFilter(myFilter); } }
@NotNull private static <T> PairConsumer<T, Runnable> wrappingProcessor( @NotNull final Consumer<T> processor) { return (item, runnable) -> { runSafely(() -> processor.consume(item)); runnable.run(); }; }
@Nullable public static Runnable fillCompletionVariants( final JavaSmartCompletionParameters parameters, final Consumer<LookupElement> result) { final PsiElement element = parameters.getPosition(); if (JavaSmartCompletionContributor.INSIDE_TYPECAST_EXPRESSION.accepts(element)) return null; if (JavaKeywordCompletion.isAfterPrimitiveOrArrayType(element)) return null; final int offset = parameters.getParameters().getOffset(); final PsiJavaCodeReferenceElement reference = PsiTreeUtil.findElementOfClassAtOffset( element.getContainingFile(), offset, PsiJavaCodeReferenceElement.class, false); if (reference != null) { final ElementFilter filter = getReferenceFilter(element, false); for (final LookupElement item : completeFinalReference(element, reference, filter, parameters)) { result.consume(item); } final boolean secondTime = parameters.getParameters().getInvocationCount() >= 2; final Set<LookupElement> base = JavaSmartCompletionContributor.completeReference( element, reference, filter, false, true, parameters.getParameters(), PrefixMatcher.ALWAYS_TRUE); for (final LookupElement item : new LinkedHashSet<LookupElement>(base)) { ExpressionLookupItem access = ArrayMemberAccess.getSingleArrayElementAccess(element, item); if (access != null) { base.add(access); PsiType type = access.getType(); if (type != null && parameters.getExpectedType().isAssignableFrom(type)) { result.consume(access); } } } if (secondTime) { return new SlowerTypeConversions(base, element, reference, parameters, result); } } return null; }
private static <T> Throwable accepts(final Consumer<T> condition, final T actual) { try { condition.consume(actual); return null; } catch (Throwable e) { return e; } }
private void restoreContext(Context context) { setDataInternal(context.element, context.text, context.viewRect); if (myNavigateCallback != null) { final PsiElement element = context.element.getElement(); if (element != null) { myNavigateCallback.consume(element); } } }
@Override public void consume(final String t) { // User requested execution (enter clicked) synchronized (myConsumerSemaphore) { if (myCurrentConsumer != null) { myCurrentConsumer.consume(t); } } }
public static void getLocalCommittedChanges( final Project project, final VirtualFile root, final Consumer<GitSimpleHandler> parametersSpecifier, final Consumer<GitCommittedChangeList> consumer, boolean skipDiffsForMerge) throws VcsException { GitSimpleHandler h = new GitSimpleHandler(project, root, GitCommand.LOG); h.setSilent(true); h.addParameters( "--pretty=format:%x04%x01" + GitChangeUtils.COMMITTED_CHANGELIST_FORMAT, "--name-status"); parametersSpecifier.consume(h); String output = h.run(); LOG.debug("getLocalCommittedChanges output: '" + output + "'"); StringScanner s = new StringScanner(output); final StringBuilder sb = new StringBuilder(); boolean firstStep = true; while (s.hasMoreData()) { final String line = s.line(); final boolean lineIsAStart = line.startsWith("\u0004\u0001"); if ((!firstStep) && lineIsAStart) { final StringScanner innerScanner = new StringScanner(sb.toString()); sb.setLength(0); consumer.consume( GitChangeUtils.parseChangeList( project, root, innerScanner, skipDiffsForMerge, h, false, false)); } sb.append(lineIsAStart ? line.substring(2) : line).append('\n'); firstStep = false; } if (sb.length() > 0) { final StringScanner innerScanner = new StringScanner(sb.toString()); sb.setLength(0); consumer.consume( GitChangeUtils.parseChangeList( project, root, innerScanner, skipDiffsForMerge, h, false, false)); } if (s.hasMoreData()) { throw new IllegalStateException("More input is avaialble: " + s.line()); } }
public void processFrameworks(Consumer<Framework> consumer) { ensureFrameworksLoaded(); for (List<FrameworkInfo> frameworkInfos : myFrameworks.values()) { for (FrameworkInfo frameworkInfo : frameworkInfos) { Framework framework = frameworkInfo.getFramework(); if (framework != null) { consumer.consume(framework); } } } }
private void doAction(final MyAction action) { LOG.debug("doAction: START " + action.name()); final MyExitAction[] exitActions; List<Runnable> toBeCalled = null; synchronized (myLock) { final MyState oldState = myState; myState = myState.transition(action); if (oldState.equals(myState)) return; exitActions = MyTransitionAction.getExit(oldState, myState); LOG.debug("doAction: oldState: " + oldState.name() + ", newState: " + myState.name()); if (LOG.isDebugEnabled() && exitActions != null) { final String debugExitActions = StringUtil.join( exitActions, new Function<MyExitAction, String>() { @Override public String fun(MyExitAction exitAction) { return exitAction.name(); } }, " "); LOG.debug("exit actions: " + debugExitActions); } if (exitActions != null) { for (MyExitAction exitAction : exitActions) { if (MyExitAction.markStart.equals(exitAction)) { myWaitingFinishListeners.addAll(myWaitingStartListeners); myWaitingStartListeners.clear(); } else if (MyExitAction.markEnd.equals(exitAction)) { toBeCalled = new ArrayList<Runnable>(myWaitingFinishListeners); myWaitingFinishListeners.clear(); } } } } if (exitActions != null) { for (MyExitAction exitAction : exitActions) { if (MyExitAction.submitRequestToExecutor.equals(exitAction)) { myAlarm.consume(myWorker); // myAlarm.addRequest(myWorker, ourDelay); // ApplicationManager.getApplication().executeOnPooledThread(myWorker); } } } if (toBeCalled != null) { for (Runnable runnable : toBeCalled) { runnable.run(); } } LOG.debug("doAction: END " + action.name()); }
static void addCollectConversion( PsiReferenceExpression ref, Collection<ExpectedTypeInfo> expectedTypes, Consumer<LookupElement> consumer) { final PsiExpression qualifier = ref.getQualifierExpression(); PsiType component = qualifier == null ? null : PsiUtil.substituteTypeParameter( qualifier.getType(), JAVA_UTIL_STREAM_STREAM, 0, true); if (component == null) return; JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject()); GlobalSearchScope scope = ref.getResolveScope(); PsiClass list = facade.findClass(JAVA_UTIL_LIST, scope); PsiClass set = facade.findClass(JAVA_UTIL_SET, scope); if (facade.findClass(JAVA_UTIL_STREAM_COLLECTORS, scope) == null || list == null || set == null) return; boolean hasList = false; boolean hasSet = false; for (ExpectedTypeInfo info : expectedTypes) { PsiType type = info.getDefaultType(); PsiClass expectedClass = PsiUtil.resolveClassInClassTypeOnly(type); PsiType expectedComponent = PsiUtil.extractIterableTypeParameter(type, true); if (expectedClass == null || expectedComponent == null || !TypeConversionUtil.isAssignable(expectedComponent, component)) continue; if (!hasList && InheritanceUtil.isInheritorOrSelf(list, expectedClass, true)) { hasList = true; consumer.consume(new MyLookupElement("toList", type)); } if (!hasSet && InheritanceUtil.isInheritorOrSelf(set, expectedClass, true)) { hasSet = true; consumer.consume(new MyLookupElement("toSet", type)); } } }
private void processProperty( @NotNull PsiMethod method, @NotNull GroovyResolveResult resolveResult) { if (myIsMap) return; final LookupElementBuilder lookup = createPropertyLookupElement(method, resolveResult, myMatcher); if (lookup != null) { if (myPropertyNames.add(lookup.getLookupString())) { myConsumer.consume(lookup); } } else if (myEventListener != null) { processListenerProperties(method); } }
private void processPropertyFromField( @NotNull GrField field, @NotNull GroovyResolveResult resolveResult) { if (field.getGetters().length != 0 || field.getSetter() != null || !myPropertyNames.add(field.getName()) || myIsMap) return; for (LookupElement element : GroovyCompletionUtil.createLookupElements(resolveResult, false, myMatcher, null)) { myConsumer.consume( ((LookupElementBuilder) element).withIcon(JetgroovyIcons.Groovy.Property)); } }
public void processUncheckedNodes( @NotNull final Consumer<DetectedFrameworkTreeNodeBase> consumer) { TreeUtil.traverse( getRoot(), node -> { if (node instanceof DetectedFrameworkTreeNodeBase) { final DetectedFrameworkTreeNodeBase frameworkNode = (DetectedFrameworkTreeNodeBase) node; if (!frameworkNode.isChecked()) { consumer.consume(frameworkNode); } } return true; }); }
private static void addClassLiteralLookupElement( @Nullable final PsiType type, final Consumer<LookupElement> resultSet, final PsiFile context) { if (type instanceof PsiClassType && PsiUtil.resolveClassInType(type) != null && !((PsiClassType) type).hasParameters() && !(((PsiClassType) type).resolve() instanceof PsiTypeParameter)) { try { resultSet.consume( AutoCompletionPolicy.NEVER_AUTOCOMPLETE.applyPolicy( new ClassLiteralLookupElement((PsiClassType) type, context))); } catch (IncorrectOperationException ignored) { } } }
@Override protected boolean exec() { myStatus = Status.STARTED; try { myAction.run(); complete(null); // complete manually before calling callback } catch (Throwable throwable) { completeExceptionally(throwable); } finally { myStatus = Status.EXECUTED; if (myOnDoneCallback != null) { myOnDoneCallback.consume(this); } } return true; }
private static void chooseAndPerform( Editor editor, List<TestFramework> frameworks, final Consumer<TestFramework> consumer) { if (frameworks.size() == 1) { consumer.consume(frameworks.get(0)); return; } final JList list = new JBList(frameworks.toArray(new TestFramework[frameworks.size()])); list.setCellRenderer( new DefaultListCellRenderer() { @Override public Component getListCellRendererComponent( JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { Component result = super.getListCellRendererComponent(list, "", index, isSelected, cellHasFocus); if (value == null) return result; TestFramework framework = (TestFramework) value; setIcon(framework.getIcon()); setText(framework.getName()); return result; } }); PopupChooserBuilder builder = new PopupChooserBuilder(list); builder.setFilteringEnabled( new Function<Object, String>() { @Override public String fun(Object o) { return ((TestFramework) o).getName(); } }); builder .setTitle("Choose Framework") .setItemChoosenCallback( new Runnable() { @Override public void run() { consumer.consume((TestFramework) list.getSelectedValue()); } }) .setMovable(true) .createPopup() .showInBestPositionFor(editor); }
public static void selectContentDescriptor( final @NotNull Editor editor, @NotNull Collection<RunContentDescriptor> consoles, String selectDialogTitle, final Consumer<RunContentDescriptor> descriptorConsumer) { if (consoles.size() == 1) { RunContentDescriptor descriptor = consoles.iterator().next(); descriptorConsumer.consume(descriptor); descriptorToFront(editor, descriptor); } else if (consoles.size() > 1) { final JList list = new JBList(consoles); final Icon icon = DefaultRunExecutor.getRunExecutorInstance().getIcon(); list.setCellRenderer( new ListCellRendererWrapper<RunContentDescriptor>(list.getCellRenderer()) { @Override public void customize( final JList list, final RunContentDescriptor value, final int index, final boolean selected, final boolean hasFocus) { setText(value.getDisplayName()); setIcon(icon); } }); final PopupChooserBuilder builder = new PopupChooserBuilder(list); builder.setTitle(selectDialogTitle); builder .setItemChoosenCallback( new Runnable() { @Override public void run() { final Object selectedValue = list.getSelectedValue(); if (selectedValue instanceof RunContentDescriptor) { RunContentDescriptor descriptor = (RunContentDescriptor) selectedValue; descriptorConsumer.consume(descriptor); descriptorToFront(editor, descriptor); } } }) .createPopup() .showInBestPositionFor(editor); } }
@Override public ChannelPipeline getPipeline() throws Exception { ChannelPipeline pipeline = pipeline( new HttpRequestDecoder(), new HttpChunkAggregator(1048576), new HttpResponseEncoder()); for (Consumer<ChannelPipeline> consumer : pipelineConsumers.compute()) { try { consumer.consume(pipeline); } catch (Throwable e) { LOG.error(e); } } pipeline.addLast("defaultHandler", defaultHandler); return pipeline; }
public DomUIFactoryImpl() { final Function<DomElement, TableCellEditor> booleanCreator = new Function<DomElement, TableCellEditor>() { @Override public TableCellEditor fun(final DomElement domElement) { return new BooleanTableCellEditor(); } }; registerCustomCellEditor(Boolean.class, booleanCreator); registerCustomCellEditor(boolean.class, booleanCreator); registerCustomCellEditor( String.class, new Function<DomElement, TableCellEditor>() { @Override public TableCellEditor fun(final DomElement domElement) { return new DefaultCellEditor(removeBorder(new JTextField())); } }); Consumer<DomUIFactory>[] extensions = Extensions.getExtensions(EXTENSION_POINT_NAME); for (Consumer<DomUIFactory> extension : extensions) { extension.consume(this); } }