Example usage for org.eclipse.jdt.core IJavaElement FIELD

List of usage examples for org.eclipse.jdt.core IJavaElement FIELD

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IJavaElement
  6. FIELD

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IJavaElement FIELD.

Prototype

int FIELD

To view the source code for org.eclipse.jdt.core IJavaElement FIELD.

Click Source Link

Document

Constant representing a field.

Usage

From source file:org.eclipse.objectteams.otdt.debug.ui.internal.actions.OTToggleBreakpointAdapter.java

License:Open Source License

public void toggleBreakpoints(IWorkbenchPart part, ISelection selection) throws CoreException {
    ISelection sel = translateToMembers(part, selection);
    if (sel instanceof IStructuredSelection) {
        IMember member = (IMember) ((IStructuredSelection) sel).getFirstElement();
        int mtype = member.getElementType();
        if (mtype == IJavaElement.FIELD || mtype == IJavaElement.METHOD || mtype == IJavaElement.INITIALIZER) {
            // remove line breakpoint if present first
            if (selection instanceof ITextSelection) {
                ITextSelection ts = (ITextSelection) selection;
                IType declaringType = member.getDeclaringType();
                IResource resource = BreakpointUtils.getBreakpointResource(declaringType);
                IJavaLineBreakpoint breakpoint = JDIDebugModel.lineBreakpointExists(resource,
                        getQualifiedName(declaringType), ts.getStartLine() + 1);
                if (breakpoint != null) {
                    deleteBreakpoint(breakpoint, part, null);
                    return;
                }/*from w  w w.  jav a2s. c  o m*/
                CompilationUnit unit = parseCompilationUnit(getTextEditor(part));
                //ObjectTeams: (visibility) OTValidBreakpointLocationLocator instead of ValidBreakpointLocationLocator
                OTValidBreakpointLocationLocator loc = new OTValidBreakpointLocationLocator(unit,
                        ts.getStartLine() + 1, true, true);
                unit.accept(loc);
                if (loc.getLocationType() == OTValidBreakpointLocationLocator.LOCATION_METHOD) {
                    toggleMethodBreakpoints(part, sel);
                } else if (loc.getLocationType() == OTValidBreakpointLocationLocator.LOCATION_FIELD) {
                    toggleWatchpoints(part, ts);
                } else if (loc.getLocationType() == OTValidBreakpointLocationLocator.LOCATION_LINE) {
                    toggleLineBreakpoints(part, ts);
                }
                // carp}
            }
        } else if (member.getElementType() == IJavaElement.TYPE) {
            toggleClassBreakpoints(part, sel);
        } else {
            //fall back to old behavior, always create a line breakpoint
            toggleLineBreakpoints(part, selection, true, null);
        }
    }
}

From source file:org.eclipse.objectteams.otdt.tests.AbstractJavaModelTests.java

License:Open Source License

/**
 * Select a field in a compilation unit identified with the nth occurence in the source of a given selection.
 * @param unit/*  w  w  w  .  j  a  v  a2 s . c om*/
 * @param selection
 * @param occurences
 * @return IField
 * @throws JavaModelException
 */
protected IField selectField(ICompilationUnit unit, String selection, int occurences)
        throws JavaModelException {
    return (IField) selectJavaElement(unit, selection, occurences, IJavaElement.FIELD);
}

From source file:org.eclipse.pde.api.tools.ui.internal.completion.APIToolsJavadocCompletionProposalComputer.java

License:Open Source License

/**
 * Computes all of the Javadoc completion proposals
 * //from www. j  a  va 2s  .  co  m
 * @param jcontext
 * @param corecontext
 * @return the complete list of Javadoc completion proposals or an empty
 *         list, never <code>null</code>
 * @since 1.0.500
 */
List<ICompletionProposal> computeJavadocProposals(JavaContentAssistInvocationContext jcontext,
        CompletionContext corecontext) {
    ICompilationUnit cunit = jcontext.getCompilationUnit();
    if (cunit != null) {
        try {
            int offset = jcontext.getInvocationOffset();
            IJavaElement element = cunit.getElementAt(offset);
            if (!isVisible(element)) {
                return Collections.EMPTY_LIST;
            }
            ImageDescriptor imagedesc = jcontext.getLabelProvider()
                    .createImageDescriptor(org.eclipse.jdt.core.CompletionProposal
                            .create(org.eclipse.jdt.core.CompletionProposal.JAVADOC_BLOCK_TAG, offset));
            fImageHandle = (imagedesc == null ? null : imagedesc.createImage());
            int type = getType(element);
            int member = IApiJavadocTag.MEMBER_NONE;
            switch (element.getElementType()) {
            case IJavaElement.METHOD: {
                IMethod method = (IMethod) element;
                member = IApiJavadocTag.MEMBER_METHOD;
                if (method.isConstructor()) {
                    member = IApiJavadocTag.MEMBER_CONSTRUCTOR;
                }
                break;
            }
            case IJavaElement.FIELD: {
                member = IApiJavadocTag.MEMBER_FIELD;
                break;
            }
            default:
                break;
            }
            IApiJavadocTag[] tags = ApiPlugin.getJavadocTagManager().getTagsForType(type, member);
            int tagcount = tags.length;
            if (tagcount > 0) {
                ArrayList<ICompletionProposal> list = null;
                collectExistingTags(element, jcontext);
                String completiontext = null;
                int tokenstart = corecontext.getTokenStart();
                int length = offset - tokenstart;
                for (int i = 0; i < tagcount; i++) {
                    if (!acceptTag(tags[i], element)) {
                        continue;
                    }
                    completiontext = tags[i].getCompleteTag(type, member);
                    if (appliesToContext(jcontext.getDocument(), completiontext, tokenstart,
                            (length > 0 ? length : 1))) {
                        if (list == null) {
                            list = new ArrayList<ICompletionProposal>(tagcount - i);
                        }
                        list.add(new APIToolsJavadocCompletionProposal(corecontext, completiontext,
                                tags[i].getTagName(), fImageHandle));
                    }
                }
                if (list != null) {
                    return list;
                }
            }
        } catch (JavaModelException e) {
            fErrorMessage = e.getMessage();
        }
    }
    return Collections.EMPTY_LIST;
}

From source file:org.eclipse.pde.api.tools.ui.internal.completion.APIToolsJavadocCompletionProposalComputer.java

License:Open Source License

/**
 * Returns if the given {@link IJavaElement} is externally visible <br>
 * <br>//from   w  ww  .j a va  2s .co  m
 * Changes to the logic here must also be made in the {@link TagValidator}
 * to ensure the visibility is computed equally.
 * 
 * @see TagValidator
 * @param element
 * @return <code>true</code> if the given element is visible
 *         <code>false</code> otherwise
 * @throws JavaModelException if a model lookup fails
 */
boolean isVisible(IJavaElement element) throws JavaModelException {
    if (element != null) {
        switch (element.getElementType()) {
        case IJavaElement.FIELD:
        case IJavaElement.METHOD: {
            IMember member = (IMember) element;
            int flags = member.getFlags();
            IType type = member.getDeclaringType();
            if (Flags.isPublic(flags) || Flags.isProtected(flags) || (type != null && type.isInterface())) {
                return isVisible(type);
            }
            break;
        }
        case IJavaElement.TYPE: {
            IType type = (IType) element;
            int flags = type.getFlags();
            if (type.isLocal() && !type.isAnonymous() || Flags.isPrivate(flags)) {
                return false;
            }
            if (type.isMember()) {
                if ((Flags.isPublic(flags) && Flags.isStatic(flags)) || Flags.isPublic(flags)
                        || Flags.isProtected(flags) || type.isInterface()) {
                    return isVisible(type.getDeclaringType());
                }
            } else {
                return Flags.isPublic(flags) || type.isInterface();
            }
            break;
        }
        default: {
            break;
        }

        }
    }
    return false;
}

From source file:org.eclipse.pde.api.tools.ui.internal.JavaElementActionFilter.java

License:Open Source License

/**
 * @see org.eclipse.ui.IActionFilter#testAttribute(Object, String, String)
 *///from w w  w . j  a v  a  2 s . c o  m
@Override
public boolean testAttribute(Object target, String name, String value) {
    if (name.equals("JavaElementActionFilter")) { //$NON-NLS-1$
        if (target instanceof IJavaElement) {
            IJavaElement javaElement = (IJavaElement) target;
            if (value.equals("isEnabled")) { //$NON-NLS-1$
                while (javaElement != null) {
                    switch (javaElement.getElementType()) {
                    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
                        IPackageFragmentRoot root = (IPackageFragmentRoot) javaElement;
                        return !root.isArchive();
                    case IJavaElement.PACKAGE_FRAGMENT:
                    case IJavaElement.COMPILATION_UNIT:
                    case IJavaElement.CLASS_FILE:
                    case IJavaElement.TYPE:
                        javaElement = javaElement.getParent();
                        break;
                    case IJavaElement.ANNOTATION:
                    case IJavaElement.FIELD:
                    case IJavaElement.IMPORT_CONTAINER:
                    case IJavaElement.IMPORT_DECLARATION:
                    case IJavaElement.INITIALIZER:
                    case IJavaElement.JAVA_MODEL:
                    case IJavaElement.LOCAL_VARIABLE:
                    case IJavaElement.METHOD:
                    case IJavaElement.PACKAGE_DECLARATION:
                    case IJavaElement.TYPE_PARAMETER:
                        return false;
                    case IJavaElement.JAVA_PROJECT:
                        return true;
                    default:
                        break;
                    }
                }
                return true;
            }
        }
    }
    return false;
}

From source file:org.eclipse.recommenders.internal.rcp.JavaElementSelections.java

License:Open Source License

public static JavaElementSelectionLocation resolveSelectionLocationFromJavaElement(final IJavaElement element) {
    ensureIsNotNull(element);/*ww w. j  a  v  a 2  s  .c  o  m*/

    switch (element.getElementType()) {
    case IJavaElement.CLASS_FILE:
    case IJavaElement.COMPILATION_UNIT:
    case IJavaElement.PACKAGE_DECLARATION:
    case IJavaElement.IMPORT_DECLARATION:
    case IJavaElement.IMPORT_CONTAINER:
    case IJavaElement.TYPE:
        return TYPE_DECLARATION;
    case IJavaElement.METHOD:
    case IJavaElement.INITIALIZER:
        return METHOD_DECLARATION;
    case IJavaElement.FIELD:
        return FIELD_DECLARATION;
    case IJavaElement.LOCAL_VARIABLE:
        // shouldn't happen in a viewer selection, right?
        return METHOD_BODY;
    case IJavaElement.JAVA_MODEL:
    case IJavaElement.PACKAGE_FRAGMENT:
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
    case IJavaElement.ANNOTATION:
    default:
        return JavaElementSelectionLocation.UNKNOWN;
    }
}

From source file:org.eclipse.xtext.common.types.ui.query.QueryParticipant.java

License:Open Source License

private boolean isHandled(QuerySpecification query) {
    switch (query.getLimitTo()) {
    case IJavaSearchConstants.REFERENCES:
    case IJavaSearchConstants.ALL_OCCURRENCES: {
        break;// ww  w  .  ja va  2  s.  c  om
    }
    default: {
        return false;
    }
    }
    if (query instanceof ElementQuerySpecification) {
        IJavaElement element = ((ElementQuerySpecification) query).getElement();
        return element.getElementType() == IJavaElement.TYPE || element.getElementType() == IJavaElement.FIELD
                || element.getElementType() == IJavaElement.METHOD;
    }
    //      if (query instanceof PatternQuerySpecification) {
    //         PatternQuerySpecification patternQuery = (PatternQuerySpecification) query;
    //         switch (patternQuery.getSearchFor()) {
    //            case IJavaSearchConstants.UNKNOWN:
    //            case IJavaSearchConstants.TYPE:
    //            case IJavaSearchConstants.CLASS:
    //            case IJavaSearchConstants.CLASS_AND_INTERFACE:
    //            case IJavaSearchConstants.CLASS_AND_ENUM: {
    //               return true;
    //            }
    //         }
    //      }
    return false;
}

From source file:org.eclipse.xtext.common.types.ui.refactoring.JdtRenameRefactoringProcessorFactory.java

License:Open Source License

public JavaRenameProcessor createRenameProcessor(IJavaElement element) {
    try {//from   www .j  a  va2  s.com
        switch (element.getElementType()) {
        case IJavaElement.TYPE:
            return new RenameTypeProcessor((IType) element);
        case IJavaElement.FIELD:
            if (((IField) element).getDeclaringType().isEnum())
                return new RenameEnumConstProcessor((IField) element);
            else
                return new RenameFieldProcessor((IField) element);
        case IJavaElement.METHOD:
            if (((IMethod) element).isConstructor())
                break;
            if (Flags.isStatic(((IMethod) element).getFlags())
                    || Flags.isPrivate(((IMethod) element).getFlags()))
                return new RenameNonVirtualMethodProcessor((IMethod) element);
            else
                return new RenameVirtualMethodProcessor((IMethod) element);
        case IJavaElement.TYPE_PARAMETER:
            return new RenameTypeParameterProcessor((ITypeParameter) element);
        case IJavaElement.LOCAL_VARIABLE:
            return new RenameLocalVariableProcessor((ILocalVariable) element);

        }
    } catch (JavaModelException exc) {
        LOG.error("Error creating refactoring processor for " + element.getElementName(), exc);
    }
    return null;
}

From source file:org.eclipse.xtext.common.types.ui.refactoring.JvmRenameRefactoringProvider.java

License:Open Source License

/**
 * Copied from {@link org.eclipse.jdt.internal.ui.refactoring.reorg.RenameLinkedMode}. There does not seem to be a
 * clean way to initialize a JDT refactoring from the outside.
 *//*from  w w w . jav a  2 s. c om*/
public RenameJavaElementDescriptor createRenameDescriptor(IJavaElement javaElement, String newName)
        throws JavaModelException {
    String contributionId;
    // see RefactoringExecutionStarter#createRenameSupport(..):
    int elementType = javaElement.getElementType();
    switch (elementType) {
    case IJavaElement.JAVA_PROJECT:
        contributionId = IJavaRefactorings.RENAME_JAVA_PROJECT;
        break;
    case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        contributionId = IJavaRefactorings.RENAME_SOURCE_FOLDER;
        break;
    case IJavaElement.PACKAGE_FRAGMENT:
        contributionId = IJavaRefactorings.RENAME_PACKAGE;
        break;
    case IJavaElement.COMPILATION_UNIT:
        contributionId = IJavaRefactorings.RENAME_COMPILATION_UNIT;
        break;
    case IJavaElement.TYPE:
        contributionId = IJavaRefactorings.RENAME_TYPE;
        break;
    case IJavaElement.METHOD:
        final IMethod method = (IMethod) javaElement;
        if (method.isConstructor())
            return createRenameDescriptor(method.getDeclaringType(), newName);
        else
            contributionId = IJavaRefactorings.RENAME_METHOD;
        break;
    case IJavaElement.FIELD:
        IField field = (IField) javaElement;
        if (field.isEnumConstant())
            contributionId = IJavaRefactorings.RENAME_ENUM_CONSTANT;
        else
            contributionId = IJavaRefactorings.RENAME_FIELD;
        break;
    case IJavaElement.TYPE_PARAMETER:
        contributionId = IJavaRefactorings.RENAME_TYPE_PARAMETER;
        break;
    case IJavaElement.LOCAL_VARIABLE:
        contributionId = IJavaRefactorings.RENAME_LOCAL_VARIABLE;
        break;
    default:
        return null;
    }

    RenameJavaElementDescriptor descriptor = (RenameJavaElementDescriptor) RefactoringCore
            .getRefactoringContribution(contributionId).createDescriptor();
    descriptor.setJavaElement(javaElement);
    descriptor.setNewName(newName);
    if (elementType != IJavaElement.PACKAGE_FRAGMENT_ROOT)
        descriptor.setUpdateReferences(true);

    IDialogSettings javaSettings = JavaPlugin.getDefault().getDialogSettings();
    IDialogSettings refactoringSettings = javaSettings.getSection(RefactoringWizardPage.REFACTORING_SETTINGS); //TODO: undocumented API
    if (refactoringSettings == null) {
        refactoringSettings = javaSettings.addNewSection(RefactoringWizardPage.REFACTORING_SETTINGS);
    }

    switch (elementType) {
    case IJavaElement.METHOD:
    case IJavaElement.FIELD:
        descriptor.setDeprecateDelegate(refactoringSettings.getBoolean(DelegateUIHelper.DELEGATE_DEPRECATION));
        descriptor.setKeepOriginal(refactoringSettings.getBoolean(DelegateUIHelper.DELEGATE_UPDATING));
    }
    switch (elementType) {
    case IJavaElement.TYPE:
        //         case IJavaElement.COMPILATION_UNIT: // TODO
        descriptor.setUpdateSimilarDeclarations(
                refactoringSettings.getBoolean(RenameRefactoringWizard.TYPE_UPDATE_SIMILAR_ELEMENTS));
        int strategy;
        try {
            strategy = refactoringSettings.getInt(RenameRefactoringWizard.TYPE_SIMILAR_MATCH_STRATEGY);
        } catch (NumberFormatException e) {
            strategy = RenamingNameSuggestor.STRATEGY_EXACT;
        }
        descriptor.setMatchStrategy(strategy);
    }
    switch (elementType) {
    case IJavaElement.PACKAGE_FRAGMENT:
        descriptor.setUpdateHierarchy(
                refactoringSettings.getBoolean(RenameRefactoringWizard.PACKAGE_RENAME_SUBPACKAGES));
    }
    switch (elementType) {
    case IJavaElement.PACKAGE_FRAGMENT:
    case IJavaElement.TYPE:
        String fileNamePatterns = refactoringSettings.get(RenameRefactoringWizard.QUALIFIED_NAMES_PATTERNS);
        if (fileNamePatterns != null && fileNamePatterns.length() != 0) {
            descriptor.setFileNamePatterns(fileNamePatterns);
            boolean updateQualifiedNames = refactoringSettings
                    .getBoolean(RenameRefactoringWizard.UPDATE_QUALIFIED_NAMES);
            descriptor.setUpdateQualifiedNames(updateQualifiedNames);
            //               fShowPreview|= updateQualifiedNames;
        }
    }
    switch (elementType) {
    case IJavaElement.PACKAGE_FRAGMENT:
    case IJavaElement.TYPE:
    case IJavaElement.FIELD:
        boolean updateTextualOccurrences = refactoringSettings
                .getBoolean(RenameRefactoringWizard.UPDATE_TEXTUAL_MATCHES);
        descriptor.setUpdateTextualOccurrences(updateTextualOccurrences);
        //            fShowPreview|= updateTextualOccurrences;
    }
    switch (elementType) {
    case IJavaElement.FIELD:
        descriptor
                .setRenameGetters(refactoringSettings.getBoolean(RenameRefactoringWizard.FIELD_RENAME_GETTER));
        descriptor
                .setRenameSetters(refactoringSettings.getBoolean(RenameRefactoringWizard.FIELD_RENAME_SETTER));
    }
    return descriptor;
}

From source file:org.eclipse.xtext.common.types.ui.refactoring.participant.JdtRenameParticipant.java

License:Open Source License

protected EClass getExpectedJvmType(IJavaElement javaElement) {
    try {//from   w w  w  . jav  a  2s.  c om
        switch (javaElement.getElementType()) {
        case IJavaElement.TYPE:
            if (((IType) javaElement).isEnum())
                return TypesPackage.Literals.JVM_ENUMERATION_TYPE;
            else
                return TypesPackage.Literals.JVM_TYPE;
        case IJavaElement.METHOD:
            if (((IMethod) javaElement).isConstructor())
                return TypesPackage.Literals.JVM_CONSTRUCTOR;
            else
                return TypesPackage.Literals.JVM_OPERATION;
        case IJavaElement.FIELD:
            if (((IField) javaElement).isEnumConstant())
                return TypesPackage.Literals.JVM_ENUMERATION_LITERAL;
            else
                return TypesPackage.Literals.JVM_FIELD;
        default:
            return null;
        }
    } catch (JavaModelException exc) {
        throw new WrappedException(exc);
    }
}