Java ContainerUtil.or方法代码示例

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean isFlagCheck(PsiElement element) {
  PsiStatement statement = PsiTreeUtil.getParentOfType(element, PsiStatement.class);
  if (!(statement instanceof PsiIfStatement)) return false;

  PsiExpression condition = ((PsiIfStatement)statement).getCondition();
  if (!PsiTreeUtil.isAncestor(condition, element, false)) return false;

  if (isCompileTimeFlagReference(condition)) return true;

  Collection<PsiReferenceExpression> refs = PsiTreeUtil.findChildrenOfType(condition, PsiReferenceExpression.class);
  return ContainerUtil.or(refs, new Condition<PsiReferenceExpression>() {
    @Override
    public boolean value(PsiReferenceExpression ref) {
      return isCompileTimeFlagReference(ref);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@Override
public boolean isAvailable(@NotNull final Project project, Editor editor, PsiFile file) {
  final PsiElement leaf = file.findElementAt(editor.getCaretModel().getOffset());
  final PsiModifierListOwner owner = getAnnotationOwner(leaf);
  if (owner != null && isSourceCode(owner)) {
    boolean hasSrcInferredAnnotation = ContainerUtil.or(findSignatureNonCodeAnnotations(owner, true), new Condition<PsiAnnotation>() {
      @Override
      public boolean value(PsiAnnotation annotation) {
        return AnnotationUtil.isInferredAnnotation(annotation);
      }
    });
    if (hasSrcInferredAnnotation) {
      setText((CodeInsightSettings.getInstance().SHOW_SOURCE_INFERRED_ANNOTATIONS ? "Hide" : "Show") + " annotations inferred from source code");
      return true;
    }
  }
  
  return false;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public void check(@NotNull final File file) {
  boolean parentAlreadyRegistered = ContainerUtil.or(myParentPaths, new Condition<File>() {
    @Override
    public boolean value(@NotNull File parentCandidate) {
      return VfsUtilCore.isAncestor(parentCandidate, file, true);
    }
  });

  if (!parentAlreadyRegistered) {
    ContainerUtil.retainAll(myParentPaths, new Condition<File>() {
      @Override
      public boolean value(@NotNull File childCandidate) {
        return !VfsUtilCore.isAncestor(file, childCandidate, true);
      }
    });

    myParentPaths.add(file);
  }
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
static boolean checkListForPaths(@NotNull final String workingCopyRoot,
                                 @NotNull final String sourceBranch,
                                 @NotNull LogHierarchyNode node) {
  // TODO: Such filtering logic is not clear enough so far (and probably not correct for all cases - for instance when we perform merge
  // TODO: from branch1 to branch2 and have revision which contain merge changes from branch3 to branch1.
  // TODO: In this case paths of child log entries will not contain neither urls from branch1 nor from branch2 - and checkEntry() method
  // TODO: will return true => so such revision will not be used (and displayed) further.

  // TODO: Why do we check entries recursively - we have a revision - set of changes in the "merge from" branch? Why do we need to check
  // TODO: where they came from - we want avoid some circular merges or what? Does subversion itself perform such checks or not?
  boolean isLocalChange = ContainerUtil.or(node.getChildren(), new Condition<LogHierarchyNode>() {
    @Override
    public boolean value(@NotNull LogHierarchyNode child) {
      return checkForSubtree(child, workingCopyRoot, sourceBranch);
    }
  });

  return isLocalChange || checkForEntry(node.getMe(), workingCopyRoot, sourceBranch);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean containsImport(List<String> importedNames, final String pkg) {
  return ContainerUtil.or(importedNames, new Condition<String>() {
    @Override
    public boolean value(String s) {
      return s.startsWith(pkg + '.') || s.equals(pkg);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public boolean is(@NotNull StatusType... types) {
  return ContainerUtil.or(types, new Condition<StatusType>() {
    @Override
    public boolean value(StatusType type) {
      return is(type);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public boolean isProperty(@NotNull StatusType... types) {
  return ContainerUtil.or(types, new Condition<StatusType>() {
    @Override
    public boolean value(StatusType type) {
      return isProperty(type);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private static boolean checkThatChangesAreUnderSvn(@Nullable Change[] changes) {
  boolean result = false;

  if (changes != null) {
    result = ContainerUtil.or(changes, new Condition<Change>() {
      @Override
      public boolean value(Change change) {
        return isUnderSvn(change.getBeforeRevision()) || isUnderSvn(change.getAfterRevision());
      }
    });
  }

  return result;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
private SvnMergeInfoCache.MergeCheckResult processMergeinfoProperty(final String pathWithRevisionNumber,
                                                                    final long revisionAsked,
                                                                    @NotNull PropertyValue value,
                                                                    final String trunkRelativeUrl,
                                                                    final boolean self) throws SvnBindException {
  SvnMergeInfoCache.MergeCheckResult result;
  Map<String, SVNMergeRangeList> mergedPathsMap = parseMergeInfo(value);
  String mergedPathAffectingTrunkUrl = ContainerUtil.find(mergedPathsMap.keySet(), new Condition<String>() {
    @Override
    public boolean value(String path) {
      return trunkRelativeUrl.startsWith(path);
    }
  });

  if (mergedPathAffectingTrunkUrl != null) {
    SVNMergeRangeList mergeRangeList = mergedPathsMap.get(mergedPathAffectingTrunkUrl);

    fillMergedRevisions(pathWithRevisionNumber, mergeRangeList);

    boolean isAskedRevisionMerged = ContainerUtil.or(mergeRangeList.getRanges(), new Condition<SVNMergeRange>() {
      @Override
      public boolean value(@NotNull SVNMergeRange range) {
        return isInRange(range, revisionAsked) && (range.isInheritable() || self);
      }
    });

    result = SvnMergeInfoCache.MergeCheckResult.getInstance(isAskedRevisionMerged);
  }
  else {
    myPathMergedMap.put(pathWithRevisionNumber, Collections.<Long>emptySet());
    result = SvnMergeInfoCache.MergeCheckResult.NOT_MERGED;
  }

  return result;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public boolean process(@NotNull String workingCopyRelativePath, @NotNull Map<String, SVNMergeRangeList> mergedPathsMap) {
  boolean processed = false;
  final boolean isCurrentPath = workingCopyRelativePath.equals(mySourceRelativePath);

  if (mergedPathsMap.isEmpty()) {
    myIsMerged = false;
    processed = true;
  }
  else {
    String mergedPathAffectingSourcePath = ContainerUtil.find(mergedPathsMap.keySet(), new Condition<String>() {
      @Override
      public boolean value(String path) {
        return SVNPathUtil.isAncestor(myRepositoryRelativeSourcePath, SvnUtil.ensureStartSlash(path));
      }
    });

    if (mergedPathAffectingSourcePath != null) {
      SVNMergeRangeList mergeRangeList = mergedPathsMap.get(mergedPathAffectingSourcePath);

      processed = true;
      myIsMerged = ContainerUtil.or(mergeRangeList.getRanges(), new Condition<SVNMergeRange>() {
        @Override
        public boolean value(@NotNull SVNMergeRange range) {
          return BranchInfo.isInRange(range, myRevisionNumber) && (range.isInheritable() || isCurrentPath);
        }
      });
    }
  }

  return processed;
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
private boolean hasSwitchedRoots() {
  final File currentRoot = myMergeContext.getWcInfo().getRootInfo().getIoFile();

  return ContainerUtil.or(myMergeContext.getVcs().getAllWcInfos(), new Condition<WCInfo>() {
    @Override
    public boolean value(WCInfo info) {
      return NestedCopyType.switched.equals(info.getType()) && FileUtil.isAncestor(currentRoot, info.getRootInfo().getIoFile(), true);
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public static boolean hasMoreImportantReference(@NotNull PsiReference[] references, @NotNull PropertyReference propertyReference) {
  return propertyReference.isSoft() && ContainerUtil.or(references, new Condition<PsiReference>() {
    @Override
    public boolean value(PsiReference reference) {
      return !reference.isSoft();
    }
  });
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
@NotNull
public static PsiClassType[] getImplementsListTypes(GrTypeDefinition grType) {
  final Collection<PsiClassType> result = ContainerUtil.newLinkedHashSet();
  final PsiClassType[] implementsTypes = getReferenceListTypes(grType.getImplementsClause());
  final PsiClassType[] extendsTypes = getReferenceListTypes(grType.getExtendsClause());
  result.addAll(Arrays.asList(implementsTypes));
  result.addAll(AstTransformContributor.runContributorsForImplementsTypes(grType));
  if (!grType.isInterface() && !ContainerUtil.or(implementsTypes, IS_GROOVY_OBJECT) && !ContainerUtil.or(extendsTypes, IS_GROOVY_OBJECT)) {
    result.add(getGroovyObjectType(grType));
  }
  return result.toArray(new PsiClassType[result.size()]);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public void finishLookup(char completionChar, @Nullable final LookupElement item) {
  //noinspection deprecation,unchecked
  if (item == null ||
      item instanceof EmptyLookupItem ||
      item.getObject() instanceof DeferredUserLookupValue &&
      item.as(LookupItem.CLASS_CONDITION_KEY) != null &&
      !((DeferredUserLookupValue)item.getObject()).handleUserSelection(item.as(LookupItem.CLASS_CONDITION_KEY), myProject)) {
    doHide(false, true);
    fireItemSelected(null, completionChar);
    return;
  }

  if (myDisposed) { // DeferredUserLookupValue could close us in any way
    return;
  }

  final PsiFile file = getPsiFile();
  boolean writableOk = file == null || FileModificationService.getInstance().prepareFileForWrite(file);
  if (myDisposed) { // ensureFilesWritable could close us by showing a dialog
    return;
  }

  if (!writableOk) {
    doHide(false, true);
    fireItemSelected(null, completionChar);
    return;
  }

  final String prefix = itemPattern(item);
  boolean plainMatch = ContainerUtil.or(item.getAllLookupStrings(), new Condition<String>() {
    @Override
    public boolean value(String s) {
      return StringUtil.containsIgnoreCase(s, prefix);
    }
  });
  if (!plainMatch) {
    FeatureUsageTracker.getInstance().triggerFeatureUsed(CodeCompletionFeatures.EDITING_COMPLETION_CAMEL_HUMPS);
  }

  myFinishing = true;
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    public void run() {
      myEditor.getDocument().startGuardedBlockChecking();
      try {
        insertLookupString(item, getPrefixLength(item));
      }
      finally {
        myEditor.getDocument().stopGuardedBlockChecking();
      }
    }
  });

  if (myDisposed) { // any document listeners could close us
    return;
  }

  doHide(false, true);

  fireItemSelected(item, completionChar);
}
 

import com.intellij.util.containers.ContainerUtil; //导入方法依赖的package包/类
public static boolean hasGroovyCompatibleModules(Project project, final Condition<Module> condition) {
  return ContainerUtil.or(ModuleManager.getInstance(project).getModules(), isGroovyCompatibleModule(condition));
}