Java Field类代码示例

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
/**
 * Checks if filter kind matches instance of concrete element
 *
 * @param element PHP element to check
 *
 * @return true if pointcut can match this named element
 */
private boolean canMatchElement(PhpNamedElement element) {
    if (element instanceof Method) {
        return filterKind.contains(KindFilter.KIND_METHOD);
    }

    if (element instanceof Field) {
        return filterKind.contains(KindFilter.KIND_PROPERTY);
    }

    if (element instanceof PhpClass) {
        return filterKind.contains(KindFilter.KIND_CLASS);
    }

    return false;
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
public static Set<String> getAnnotations(Project project, String className) {

        HashSet<String> map = new HashSet<>();

        PhpClass phpClass = PhpElementsUtil.getClass(project, className);
        if(phpClass == null) {
            return map;
        }

        for(Field field: phpClass.getFields()) {
            if(!field.isConstant()) {
                map.add(field.getName());
            }
        }

        return map;
    }
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@NotNull
@Override
public Collection<LookupElement> getLookupElements() {
    String modelNameInScope = DoctrineMetadataUtil.findModelNameInScope(getElement());
    if(modelNameInScope == null) {
        return Collections.emptyList();
    }

    Set<String> unique = new HashSet<>();

    Collection<LookupElement> lookupElements = new ArrayList<>();
    for (PhpClass phpClass : PhpElementsUtil.getClassesInterface(getProject(), modelNameInScope)) {
        for (Field field : phpClass.getFields()) {
            if(field.isConstant() || unique.contains(field.getName())) {
                continue;
            }

            String name = field.getName();
            unique.add(name);
            lookupElements.add(LookupElementBuilder.create(name).withIcon(field.getIcon()).withTypeText(phpClass.getPresentableFQN(), true));
        }
    }

    return lookupElements;
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {

    List<PsiElement> psiElements = new ArrayList<>();

    String content = ((StringLiteralExpression) getElement()).getContents();
    for(Field field: constraintPhpClass.getFields()) {
        String name = field.getName();
        if(!field.isConstant() && field.getModifier().isPublic() && content.equals(name)) {
            psiElements.add(field);
        }
    }

    return PsiElementResolveResult.createResults(psiElements);
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@NotNull
@Override
public Object[] getVariants() {

    List<LookupElement> lookupElements = new ArrayList<>();

    for(Field field: constraintPhpClass.getFields()) {
        if(!field.isConstant() && field.getModifier().isPublic()) {

            LookupElementBuilder lookupElement = LookupElementBuilder.create(field.getName()).withIcon(Symfony2Icons.SYMFONY);

            String defaultValue = PhpElementsUtil.getStringValue(field.getDefaultValue());
            if(defaultValue != null) {
                lookupElement = lookupElement.withTypeText(defaultValue, true);
            }

            lookupElements.add(lookupElement);
        }
    }

    return lookupElements.toArray();
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
/**
 *
 * "phpNamedElement.variableName", "phpNamedElement.getVariableName" will resolve php type eg method
 *
 * @param phpNamedElement php class method or field
 * @param variableName variable name shortcut property possible
 * @return matched php types
 */
public static Collection<? extends PhpNamedElement> getTwigPhpNameTargets(PhpNamedElement phpNamedElement, String variableName) {

    Collection<PhpNamedElement> targets = new ArrayList<>();
    if(phpNamedElement instanceof PhpClass) {

        for(Method method: ((PhpClass) phpNamedElement).getMethods()) {
            String methodName = method.getName();
            if(method.getModifier().isPublic() && (methodName.equalsIgnoreCase(variableName) || isPropertyShortcutMethodEqual(methodName, variableName))) {
                targets.add(method);
            }
        }

        for(Field field: ((PhpClass) phpNamedElement).getFields()) {
            String fieldName = field.getName();
            if(field.getModifier().isPublic() && fieldName.equalsIgnoreCase(variableName)) {
                targets.add(field);
            }
        }

    }

    return targets;
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
public void testFormDataFieldPropertyPathReferencesForProperty() {
    for (String s : new String[]{"var", "varBar", "var_bar", "var_Bar"}) {
        assertReferenceMatchOnParent(PhpFileType.INSTANCE, "<?php\n" +
            "\n" +
            "class FormType\n" +
            "{\n" +
            "    protected $foo = 'DateTime';\n" +
            "    public function buildForm(\\Symfony\\Component\\Form\\FormBuilderInterface $builder, array $options) {\n" +
            "        $builder->add('" + s + "<caret>');\n" +
            "    }\n" +
            "    public function setDefaultOptions(OptionsResolverInterface $resolver)\n" +
            "    {\n" +
            "        $resolver->setDefaults(array(\n" +
            "            'data_class' => \\Form\\DataClass\\Model::class,\n" +
            "        ));\n" +
            "    }\n" +
            "}", PlatformPatterns.psiElement(Field.class)
        );
    }
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
public void testThatArgumentConstantProvidesReferences() {
    assertReferenceMatch(XmlFileType.INSTANCE, "" +
            "<?xml version=\"1.0\"?>\n" +
            "<container>\n" +
            "    <services>\n" +
            "        <service>\n" +
            "            <argument type=\"constant\">Foo\\Bar::FO<caret>O</argument>\n" +
            "        </service>\n" +
            "    </services>\n" +
            "</container>\n",
        PlatformPatterns.psiElement(Field.class).withName("FOO")
    );

    assertReferenceMatch(XmlFileType.INSTANCE, "" +
            "<?xml version=\"1.0\"?>\n" +
            "<container>\n" +
            "    <services>\n" +
            "        <service>\n" +
            "            <argument type=\"constant\">CONS<caret>T_FOO</argument>\n" +
            "        </service>\n" +
            "    </services>\n" +
            "</container>\n",
        PlatformPatterns.psiElement()
    );
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@Override
public void getPropertyValueCompletions(AnnotationPropertyParameter annotationPropertyParameter, AnnotationCompletionProviderParameter completionParameter) {

    String propertyName = annotationPropertyParameter.getPropertyName();
    if(propertyName == null) {
        return;
    }

    if(propertyName.equals("name") && PhpLangUtil.equalsClassNames(annotationPropertyParameter.getPhpClass().getPresentableFQN(), "Doctrine\\ORM\\Mapping\\Column")) {
        PhpDocComment phpDocComment = PsiTreeUtil.getParentOfType(annotationPropertyParameter.getElement(), PhpDocComment.class);
        if(phpDocComment != null) {
            PhpPsiElement classField = phpDocComment.getNextPsiSibling();
            if(classField != null && classField.getNode().getElementType() == PhpElementTypes.CLASS_FIELDS) {
                Field field = PsiTreeUtil.getChildOfType(classField, Field.class);
                if(field != null) {
                    String name = field.getName();
                    if(StringUtils.isNotBlank(name)) {
                        completionParameter.getResult().addElement(LookupElementBuilder.create(underscore(name)));
                    }
                }
            }
        }
    }

}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@Override
public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {

    if(!DoctrineUtil.isDoctrineOrmInVendor(project)) {
        return false;
    }

    PsiElement parent = element.getParent();
    if(parent == null || parent.getNode().getElementType() != PhpElementTypes.CLASS_FIELDS) {
        return false;
    }

    Field field = PsiTreeUtil.getChildOfType(parent, Field.class);
    return field != null && !DoctrineUtil.isOrmColumnProperty(field);

}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
/**
 * Add static field targets for @Route(name=ClassName::<FOO>)
 *
 * @param psiElement DOC_IDENTIFIER after DOC_STATIC
 * @param targets Goto targets
 */
private void addStaticClassConstTargets(PsiElement psiElement, List<PsiElement> targets) {

    String constName = psiElement.getText();

    PsiElement docStatic = psiElement.getPrevSibling();
    if(docStatic != null && PhpDocUtil.isDocStaticElement(docStatic)) {
        PsiElement docIdentifier = docStatic.getPrevSibling();
        if(docIdentifier != null && docIdentifier.getNode().getElementType() == PhpDocTokenTypes.DOC_IDENTIFIER) {
            String className = docIdentifier.getText();
            PhpClass phpClass = PhpElementsUtil.getClassByContext(psiElement, className);
            if(phpClass != null) {
                Field field = phpClass.findFieldByName(constName, true);
                if(field != null) {
                    targets.add(field);
                }
            }
        }
    }

}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
public void testThatPropertyProvidesNavigation() {
    assertNavigationMatch(PhpFileType.INSTANCE, "<?php\n" +
            "namespace Bar;\n" +
            "use Foo\\Bar;\n" +
            "\n" +
            "class Foo\n" +
            "{\n" +
            "  /** @Bar(f<caret>oo=\"bar\") */" +
            "}\n",
        PlatformPatterns.psiElement(Field.class).withName("foo")
    );

    assertNavigationMatch(PhpFileType.INSTANCE, "<?php\n" +
            "namespace Bar;\n" +
            "use Foo\\Bar;\n" +
            "\n" +
            "class Foo\n" +
            "{\n" +
            "  /** @Foo(bla=\"\", foo={@Bar(f<caret>oo=\"bar\")}) */" +
            "}\n",
        PlatformPatterns.psiElement(Field.class).withName("foo")
    );
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
static void reportTimestamps(
    @NotNull final ProblemsHolder problemsHolder,
    @NotNull final PhpClass phpClass
) {
    final Field fieldTimestamps = PhpClassUtil.findPropertyDeclaration(phpClass, "timestamps");

    if (fieldTimestamps == null) {
        return;
    }

    final PsiElement fieldTimestampsDefaultValue = fieldTimestamps.getDefaultValue();

    if (!(fieldTimestampsDefaultValue instanceof PhpExpression)) {
        return;
    }

    final PsiElement fieldTimestampsDefaultValueResolved = PsiElementUtil.resolve(fieldTimestampsDefaultValue);

    if (!(fieldTimestampsDefaultValueResolved instanceof ConstantReference)) {
        return;
    }

    if (!"true".equals(fieldTimestampsDefaultValueResolved.getText())) {
        return;
    }

    final PsiElement issueReceptor = getReportableElement(phpClass, fieldTimestamps);

    if (issueReceptor == null) {
        return;
    }

    validatePropertyAnnotation(problemsHolder, phpClass, issueReceptor, "created_at", null);
    validatePropertyAnnotation(problemsHolder, phpClass, issueReceptor, "updated_at", null);
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@Nullable
@Override
public PsiElement[] getGotoDeclarationTargets(@Nullable PsiElement psiElement, int i, Editor editor) {
    if (psiElement == null) {
        return PsiElement.EMPTY_ARRAY;
    }
    if (!PlatformPatterns
            .psiElement(StringLiteralExpression.class)
            .withLanguage(PhpLanguage.INSTANCE)
            .accepts(psiElement.getContext())
            ) {
        return PsiElement.EMPTY_ARRAY;
    }
    Field field = (Field)PsiUtil.findParent(psiElement, Field.class);
    if (field == null) {
        return PsiElement.EMPTY_ARRAY;
    }
    String text = field.getText();
    // PhpStorm already has completion based on strings that contain class names, so
    // we only need to check for the components and helpers properties:
    if (text.contains("$components")) {
        return PsiUtil.getClassesAsArray(psiElement, psiElement.getText() + "Component");
    }
    if (text.contains("$helpers")) {
        return PsiUtil.getClassesAsArray(psiElement, psiElement.getText() + "Helper");
    }
    return PsiElement.EMPTY_ARRAY;
}
 

import com.jetbrains.php.lang.psi.elements.Field; //导入依赖的package包/类
@NotNull
@Override
public ResolveResult[] multiResolve(boolean b) {
    PhpIndex phpIndex = PhpIndex.getInstance(getElement().getProject());
    List<String> parts = StringUtil.split(
        PhpLangUtil.toFQN(
            StringUtil.unquoteString(getElement().getText())
        ),
        "::"
    );

    if (parts.size() != 2) {
        return new ResolveResult[0];
    }

    String className = parts.get(0);
    String constantName = parts.get(1);

    List<ResolveResult> fields = new ArrayList<ResolveResult>();
    Collection<PhpClass> classesAndInterfaces = new ArrayList<>();
    classesAndInterfaces.addAll(phpIndex.getClassesByFQN(className));
    classesAndInterfaces.addAll(phpIndex.getInterfacesByFQN(className));

    for (PhpClass phpClass: classesAndInterfaces) {
        for(Field field: phpClass.getFields()) {
            if (field.isConstant() && field.getName().equals(constantName)) {
                fields.add(new PsiElementResolveResult(field));
            }
        }
    }

    return fields.toArray(new ResolveResult[fields.size()]);
}