Java PatternCondition类代码示例

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
@Override
public boolean isInContext(@NotNull PsiFile file, int offset) {
  if (!super.isInContext(file, offset)) {
    return false;
  }
  final ElementPattern<PsiElement> illegalPattern = or(psiElement().inside(JsonStringLiteral.class),
                                                       psiElement().inside(psiElement(JsonValue.class)
                                                                             .with(new PatternCondition<PsiElement>("insidePropertyKey") {
                                                                               @Override
                                                                               public boolean accepts(@NotNull PsiElement element,
                                                                                                      ProcessingContext context) {
                                                                                 return JsonPsiUtil.isPropertyKey(element);
                                                                               }
                                                                             })));
  return !illegalPattern.accepts(file.findElementAt(offset));
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyMethodCallPattern withArguments(final ElementPattern<? extends GrExpression>... arguments) {
  return with(new PatternCondition<GrCallExpression>("withArguments") {
    @Override
    public boolean accepts(@NotNull GrCallExpression callExpression, ProcessingContext context) {
      final GrArgumentList argumentList = callExpression.getArgumentList();
      if (argumentList == null) return false;
      final GrExpression[] actualArguments = argumentList.getExpressionArguments();
      if (arguments.length != actualArguments.length) {
        return false;
      }
      for (int i = 0; i < actualArguments.length; i++) {
        if (!arguments[i].accepts(actualArguments[i], context)) {
          return false;
        }
      }
      return true;
    }
  });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
private AppEngineFlexPattern withAppEngineFlexYamlContent() {
  return with(
      new PatternCondition<FileContent>("with-appengine-java-flexible") {
        @Override
        public boolean accepts(@NotNull FileContent fileContent, ProcessingContext context) {
          // checks for flex engine file names and then checks for required configuration line
          // inside.
          boolean nameMatch = APP_ENGINE_FLEX_CONFIG_FILES.contains(fileContent.getFileName());
          if (nameMatch) {
            Scanner scanner = new Scanner(fileContent.getContentAsText().toString());
            while (scanner.hasNextLine()) {
              if (scanner.nextLine().startsWith(APP_ENGINE_FLEX_REQUIRED_YAML_CONTENT)) {
                return true;
              }
            }
          }
          return false;
        }
      });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
/**
 * "@foobar"
 */
private static PsiElementPattern.Capture<BladePsiDirectiveParameter> getDirectiveNamePattern(@NotNull final String[] directives) {
    return PlatformPatterns.psiElement(BladePsiDirectiveParameter.class).withParent(
        PlatformPatterns.psiElement(BladePsiDirective.class).with(new PatternCondition<BladePsiDirective>("Directive Name") {
            @Override
            public boolean accepts(@NotNull BladePsiDirective bladePsiDirective, ProcessingContext processingContext) {
                for (String directive : directives) {
                    if(("@" + directive).equals(bladePsiDirective.getName())) {
                        return true;
                    }
                }

                return false;
            }
        })
    );
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public void testThatRoutePermissionCompletesAndNavigates() {
    assertCompletionContains(YAMLFileType.YML, "" +
            "config.import_full:\n" +
            "  requirements:\n" +
            "    _permission: '<caret>'",
        "synchronize configuration"
    );

    assertNavigationMatch(YAMLFileType.YML, "" +
            "config.import_full:\n" +
            "  requirements:\n" +
            "    _permission: 'synchronize<caret> configuration'",
        PlatformPatterns.psiElement(YAMLKeyValue.class).with(new PatternCondition<YAMLKeyValue>("key") {
            @Override
            public boolean accepts(@NotNull YAMLKeyValue yamlKeyValue, ProcessingContext processingContext) {
                return "synchronize configuration".equals(yamlKeyValue.getKeyText());
            }
        })
    );
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public void testYamlServiceLineMarker() {
    myFixture.configureByText(YAMLFileType.YML,
        "services:\n" +
            "  foo:\n" +
            "    class: Service\\YamlBar"
    );

    assertLineMarker(PhpPsiElementFactory.createPsiFileFromText(getProject(), "<?php\n" +
        "namespace Service{\n" +
        "    class YamlBar{}\n" +
        "}"
    ), new LineMarker.TargetAcceptsPattern("Navigate to definition", PlatformPatterns.psiElement(YAMLKeyValue.class).with(new PatternCondition<YAMLKeyValue>("KeyText") {
        @Override
        public boolean accepts(@NotNull YAMLKeyValue yamlKeyValue, ProcessingContext processingContext) {
            return yamlKeyValue.getKeyText().equals("foo");
        }
    })));
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public void testYamlServiceLineMarkerForClassName() {
    myFixture.configureByText(YAMLFileType.YML,
        "services:\n" +
            "  Service\\YamlBar: ~\n"
    );

    assertLineMarker(PhpPsiElementFactory.createPsiFileFromText(getProject(), "<?php\n" +
        "namespace Service{\n" +
        "    class YamlBar{}\n" +
        "}"
    ), new LineMarker.TargetAcceptsPattern("Navigate to definition", PlatformPatterns.psiElement(YAMLKeyValue.class).with(new PatternCondition<YAMLKeyValue>("KeyText") {
        @Override
        public boolean accepts(@NotNull YAMLKeyValue yamlKeyValue, ProcessingContext processingContext) {
            return yamlKeyValue.getKeyText().equals("Service\\YamlBar");
        }
    })));
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public <T extends PsiModifierListOwner> void registerTopLevelSem(SemRegistrar registrar, final ElementPattern<? extends T> parentPattern, final JamMemberMeta<T,?> parentMeta) {
  final boolean isPackage = parentMeta instanceof JamPackageMeta;
  final PsiAnnotationPattern annoPattern = myAnnoNamePattern.withSuperParent(
      2, isPackage ? PACKAGE_STATEMENT.with(new PatternCondition<PsiPackageStatement>("package") {
      @Override
      public boolean accepts(@NotNull PsiPackageStatement psiPackageStatement, ProcessingContext context) {
        return parentPattern.accepts(psiPackageStatement.getPackageReference().resolve(), context);
      }
    }) : parentPattern);
  registrar.registerSemElementProvider(myMetaKey, annoPattern, annotation -> {
    final PsiElement parent = annotation.getParent().getParent();
    final T element = (isPackage && parent instanceof PsiPackageStatement? (T)((PsiPackageStatement)parent).getPackageReference().resolve() : (T)parent);
    if (element != null && SemService.getSemService(annotation.getProject()).getSemElement(parentMeta.getMetaKey(), element) == parentMeta) {
      return this;
    }
    return null;
  });

  registerChildren(registrar, annoPattern);
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
private static PsiJavaElementPattern.Capture<PsiLiteralExpression> getElementPattern(String annotationParamName) {
  return PsiJavaPatterns.literalExpression().
    annotationParam(annotationParamName, PsiJavaPatterns.psiAnnotation().with(new PatternCondition<PsiAnnotation>("isTestNGAnnotation") {
      @Override
      public boolean accepts(@NotNull PsiAnnotation annotation, ProcessingContext context) {
        return TestNGUtil.isTestNGAnnotation(annotation);
      }
    }));
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyBinaryExpressionPattern left(@NotNull final ElementPattern pattern) {
  return with(new PatternCondition<GrBinaryExpression>("left") {
    @Override
    public boolean accepts(@NotNull final GrBinaryExpression psiBinaryExpression, final ProcessingContext context) {
      return pattern.accepts(psiBinaryExpression.getLeftOperand(), context);
    }
  });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyBinaryExpressionPattern right(@NotNull final ElementPattern pattern) {
  return with(new PatternCondition<GrBinaryExpression>("right") {
    @Override
    public boolean accepts(@NotNull final GrBinaryExpression psiBinaryExpression, final ProcessingContext context) {
      return pattern.accepts(psiBinaryExpression.getRightOperand(), context);
    }
  });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyBinaryExpressionPattern operation(final ElementPattern pattern) {
  return with(new PatternCondition<GrBinaryExpression>("operation") {
    @Override
    public boolean accepts(@NotNull final GrBinaryExpression psiBinaryExpression, final ProcessingContext context) {
      return pattern.accepts(psiBinaryExpression.getOperationTokenType(), context);
    }
  });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyNamedArgumentPattern withLabel(@NotNull final String label) {
  return with(new PatternCondition<GrNamedArgument>("left") {
    @Override
    public boolean accepts(@NotNull GrNamedArgument namedArgument, final ProcessingContext context) {
      return label.equals(namedArgument.getLabelName());
    }
  });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyNamedArgumentPattern withExpression(@NotNull final ElementPattern pattern) {
  return with(new PatternCondition<GrNamedArgument>("left") {
    @Override
    public boolean accepts(@NotNull GrNamedArgument namedArgument, final ProcessingContext context) {
      return pattern.accepts(namedArgument.getExpression(), context);
    }
  });
}
 

import com.intellij.patterns.PatternCondition; //导入依赖的package包/类
public GroovyNamedArgumentPattern isParameterOfMethodCall(@Nullable final ElementPattern<? extends GrCall> methodCall) {
  return with(new PatternCondition<GrNamedArgument>("left") {
    @Override
    public boolean accepts(@NotNull GrNamedArgument namedArgument, final ProcessingContext context) {
      GrCall call = PsiUtil.getCallByNamedParameter(namedArgument);

      return call != null && (methodCall == null || methodCall.accepts(call, context));
    }
  });
}