Java PairFunction.fun方法代码示例

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
@NotNull
public static <E> JBIterable<E> generate(@Nullable final E first1, @Nullable final E first2, @NotNull final PairFunction<? super E, ? super E, ? extends E> generator) {
  if (first1 == null) return empty();
  return new JBIterable<E>() {
    @Override
    public Iterator<E> iterator() {
      return new JBIterator<E>() {
        E cur1 = first1;
        E cur2 = first2;

        @Override
        public E nextImpl() {
          E result = cur1;
          cur1 = cur2;
          cur2 = generator.fun(result, cur2);
          if (result == null) return stop();
          return result;
        }
      };
    }
  };
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
public GutteredLanguageConsole(@NotNull String title,
                               @NotNull Project project,
                               @NotNull Language language,
                               @Nullable GutterContentProvider gutterContentProvider,
                               @Nullable final PairFunction<VirtualFile, Project, PsiFile> psiFileFactory) {
  super(new Helper(project, new LightVirtualFile(title, language, "")) {
    @NotNull
    @Override
    public PsiFile getFile() {
      return psiFileFactory == null ? super.getFile() : psiFileFactory.fun(virtualFile, project);
    }

  });

  this.gutterContentProvider = gutterContentProvider == null ? new BasicGutterContentProvider() : gutterContentProvider;
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
public static PsiReference[] getReferencesForAttributeValue(@Nullable XmlAttributeValue element,
                                                            PairFunction<String, Integer, PsiReference> refFun) {
  if (element == null) {
    return PsiReference.EMPTY_ARRAY;
  }
  String text = element.getText();
  String urls = StringUtil.unquoteString(text);
  StringTokenizer tokenizer = new StringTokenizer(urls);
  List<PsiReference> result = new ArrayList<PsiReference>();
  while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    int index = text.indexOf(token);
    PsiReference ref = refFun.fun(token, index);
    if (ref != null) {
      result.add(ref);
    }
  }
  return result.toArray(new PsiReference[result.size()]);
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
@Nullable
private static PsiType getQualifierCastType(PsiJavaReference javaReference, CompletionParameters parameters) {
  if (javaReference instanceof PsiReferenceExpression) {
    final PsiReferenceExpression refExpr = (PsiReferenceExpression)javaReference;
    final PsiExpression qualifier = refExpr.getQualifierExpression();
    if (qualifier != null) {
      final Project project = qualifier.getProject();
      PsiType type = null;
      final PairFunction<PsiExpression, CompletionParameters, PsiType> evaluator = refExpr.getContainingFile().getCopyableUserData(DYNAMIC_TYPE_EVALUATOR);
      if (evaluator != null) {
        type = evaluator.fun(qualifier, parameters);
      }
      if (type == null) {
        type = GuessManager.getInstance(project).getControlFlowExpressionType(qualifier);
      }
      return type;
    }
  }
  return null;
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
public static PsiReference[] getReferencesForAttributeValue(@Nullable XmlAttributeValue element,
                                                            PairFunction<String, Integer, PsiReference> refFun) {
  if (element == null) {
    return PsiReference.EMPTY_ARRAY;
  }
  String text = element.getText();
  String urls = StringUtil.stripQuotesAroundValue(text);
  StringTokenizer tokenizer = new StringTokenizer(urls);
  List<PsiReference> result = new ArrayList<PsiReference>();
  while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    int index = text.indexOf(token);
    PsiReference ref = refFun.fun(token, index);
    if (ref != null) {
      result.add(ref);
    }
  }
  return result.toArray(new PsiReference[result.size()]);
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
@Nullable
public static Object calcBinary(IElementType elementType, Object p1, Object p2)
{
	Couple<Class> key = Couple.<Class>of(p1.getClass(), p2.getClass());

	Map<IElementType, PairFunction<Object, Object, Object>> map = ourOperators.get(key);
	if(map == null)
	{
		return null;
	}

	PairFunction<Object, Object, Object> function = map.get(elementType);
	if(function == null)
	{
		return null;
	}
	return function.fun(p1, p2);
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
private <T> void jumpTo(@Nonnull final T commitId,
                        @Nonnull final PairFunction<GraphTableModel, T, Integer> rowGetter,
                        @Nonnull final SettableFuture<Boolean> future) {
  if (future.isCancelled()) return;

  GraphTableModel model = getTable().getModel();

  int row = rowGetter.fun(model, commitId);
  if (row >= 0) {
    myMainFrame.getGraphTable().jumpToRow(row);
    future.set(true);
  }
  else if (model.canRequestMore()) {
    model.requestToLoadMore(() -> jumpTo(commitId, rowGetter, future));
  }
  else if (!myVisiblePack.isFull()) {
    invokeOnChange(() -> jumpTo(commitId, rowGetter, future));
  }
  else {
    commitNotFound(commitId.toString());
    future.set(false);
  }
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
public static PsiReference[] getReferencesForAttributeValue(@Nullable XmlAttributeValue element, PairFunction<String, Integer, PsiReference> refFun)
{
	if(element == null)
	{
		return PsiReference.EMPTY_ARRAY;
	}
	String text = element.getText();
	String urls = StringUtil.unquoteString(text);
	StringTokenizer tokenizer = new StringTokenizer(urls);
	List<PsiReference> result = new ArrayList<>();
	while(tokenizer.hasMoreTokens())
	{
		String token = tokenizer.nextToken();
		int index = text.indexOf(token);
		PsiReference ref = refFun.fun(token, index);
		if(ref != null)
		{
			result.add(ref);
		}
	}
	return result.toArray(new PsiReference[result.size()]);
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
@Nullable
private static PsiType getQualifierCastType(PsiJavaReference javaReference, CompletionParameters parameters)
{
	if(javaReference instanceof PsiReferenceExpression)
	{
		final PsiReferenceExpression refExpr = (PsiReferenceExpression) javaReference;
		final PsiExpression qualifier = refExpr.getQualifierExpression();
		if(qualifier != null)
		{
			final Project project = qualifier.getProject();
			PsiType type = null;
			final PairFunction<PsiExpression, CompletionParameters, PsiType> evaluator = refExpr.getContainingFile().getCopyableUserData(DYNAMIC_TYPE_EVALUATOR);
			if(evaluator != null)
			{
				type = evaluator.fun(qualifier, parameters);
			}
			if(type == null)
			{
				type = GuessManager.getInstance(project).getControlFlowExpressionType(qualifier);
			}
			return type;
		}
	}
	return null;
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
/**
 * @return true if completed, false if "too complex"
 */
private boolean runDfa(boolean forward, PairFunction<Instruction, BitSet, BitSet> handleState) {
  Set<Instruction> entryPoints = ContainerUtil.newHashSet();
  if (forward) {
    entryPoints.add(myInstructions[0]);
  } else {
    entryPoints.addAll(ContainerUtil.findAll(myInstructions, FilteringIterator.instanceOf(ReturnInstruction.class)));
  }

  Queue<InstructionState> queue = new Queue<InstructionState>(10);
  for (Instruction i : entryPoints) {
    queue.addLast(new InstructionState(i, new BitSet()));
  }

  int limit = myForwardMap.size() * 20;
  Set<InstructionState> processed = ContainerUtil.newHashSet();
  while (!queue.isEmpty()) {
    int steps = processed.size();
    if (steps > limit) {
      return false;
    }
    if (steps % 1024 == 0) {
      ProgressManager.checkCanceled();
    }
    InstructionState state = queue.pullFirst();
    Instruction instruction = state.first;
    Collection<Instruction> nextInstructions = forward ? myForwardMap.get(instruction) : myBackwardMap.get(instruction);
    BitSet nextVars = handleState.fun(instruction, state.second);
    for (Instruction next : nextInstructions) {
      InstructionState nextState = new InstructionState(next, nextVars);
      if (processed.add(nextState)) {
        queue.addLast(nextState);
      }
    }
  }
  return true;
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
public static <T> void join(StringBuilder builder, List<T> list, PairFunction<StringBuilder, T, Void> function, String dem)
{
	for(int i = 0; i < list.size(); i++)
	{
		if(i != 0)
		{
			builder.append(dem);
		}

		T t = list.get(i);
		function.fun(builder, t);
	}
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
@Nonnull
public static <T extends ArchiveHandler> T getHandler(@Nonnull ArchiveFileSystem vfs,
                                                      @Nonnull String localPath,
                                                      @Nonnull PairFunction<String, ArchiveFileSystemBase, T> producer) {
  checkSubscription();

  ArchiveHandler handler;

  synchronized (ourLock) {
    Pair<ArchiveFileSystem, ArchiveHandler> record = ourHandlers.get(localPath);
    if (record == null) {
      handler = producer.fun(localPath, (ArchiveFileSystemBase)vfs);
      record = Pair.create(vfs, handler);
      ourHandlers.put(localPath, record);

      final String finalRootPath = localPath;
      forEachDirectoryComponent(localPath, containingDirectoryPath -> {
        Set<String> handlers = ourDominatorsMap.get(containingDirectoryPath);
        if (handlers == null) {
          ourDominatorsMap.put(containingDirectoryPath, handlers = ContainerUtil.newTroveSet());
        }
        handlers.add(finalRootPath);
      });
    }
    handler = record.second;
  }

  @SuppressWarnings("unchecked") T t = (T)handler;
  return t;
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
private <T> void jumpTo(@NotNull final T commitId,
                        @NotNull final PairFunction<GraphTableModel, T, Integer> rowGetter,
                        @NotNull final SettableFuture<Boolean> future) {
  if (future.isCancelled()) return;

  GraphTableModel model = getModel();
  if (model == null) {
    invokeOnChange(new Runnable() {
      @Override
      public void run() {
        jumpTo(commitId, rowGetter, future);
      }
    });
    return;
  }

  int row = rowGetter.fun(model, commitId);
  if (row >= 0) {
    myMainFrame.getGraphTable().jumpToRow(row);
    future.set(true);
  }
  else if (model.canRequestMore()) {
    model.requestToLoadMore(new Runnable() {
      @Override
      public void run() {
        jumpTo(commitId, rowGetter, future);
      }
    });
  }
  else if (!myVisiblePack.isFull()) {
    invokeOnChange(new Runnable() {
      @Override
      public void run() {
        jumpTo(commitId, rowGetter, future);
      }
    });
  }
  else {
    commitNotFound(commitId.toString());
    future.set(false);
  }
}
 

import com.intellij.util.PairFunction; //导入方法依赖的package包/类
/**
 * @return true if completed, false if "too complex"
 */
private boolean runDfa(boolean forward, PairFunction<Instruction, BitSet, BitSet> handleState)
{
	Set<Instruction> entryPoints = ContainerUtil.newHashSet();
	if(forward)
	{
		entryPoints.add(myInstructions[0]);
	}
	else
	{
		entryPoints.addAll(ContainerUtil.findAll(myInstructions, FilteringIterator.instanceOf(ReturnInstruction.class)));
	}

	Queue<InstructionState> queue = new Queue<>(10);
	for(Instruction i : entryPoints)
	{
		queue.addLast(new InstructionState(i, new BitSet()));
	}

	int limit = myForwardMap.size() * 20;
	Set<InstructionState> processed = ContainerUtil.newHashSet();
	while(!queue.isEmpty())
	{
		int steps = processed.size();
		if(steps > limit)
		{
			return false;
		}
		if(steps % 1024 == 0)
		{
			ProgressManager.checkCanceled();
		}
		InstructionState state = queue.pullFirst();
		Instruction instruction = state.first;
		Collection<Instruction> nextInstructions = forward ? myForwardMap.get(instruction) : myBackwardMap.get(instruction);
		BitSet nextVars = handleState.fun(instruction, state.second);
		for(Instruction next : nextInstructions)
		{
			InstructionState nextState = new InstructionState(next, nextVars);
			if(processed.add(nextState))
			{
				queue.addLast(nextState);
			}
		}
	}
	return true;
}