Java IJavaElement.METHOD屬性代碼示例

private void processType(ITypeVisitor visitor, BinaryTypeName btn,
    IType type, IProgressMonitor monitor) throws JavaModelException {
  final String binaryname = btn.toString();
  monitor.subTask(binaryname);
  visitor.visit(type, binaryname);
  for (final IJavaElement child : type.getChildren()) {
    if (monitor.isCanceled()) {
      break;
    }
    switch (child.getElementType()) {
    case IJavaElement.TYPE:
      IType nestedtype = (IType) child;
      processType(visitor, btn.nest(nestedtype), nestedtype, monitor);
      break;
    case IJavaElement.METHOD:
    case IJavaElement.INITIALIZER:
    case IJavaElement.FIELD:
      processAnonymousInnerTypes(visitor, btn, (IMember) child, monitor);
      break;
    }
  }
}
 

private void collectCodeLenses(ITypeRoot unit, IJavaElement[] elements, List<ICodeLens> lenses,
		IProgressMonitor monitor) throws JavaModelException {
	for (IJavaElement element : elements) {
		if (monitor.isCanceled()) {
			return;
		}
		if (element.getElementType() == IJavaElement.TYPE) {
			collectCodeLenses(unit, ((IType) element).getChildren(), lenses, monitor);
		} else if (element.getElementType() != IJavaElement.METHOD || JDTUtils.isHiddenGeneratedElement(element)) {
			continue;
		}

		// if (preferenceManager.getPreferences().isReferencesCodeLensEnabled()) {
		ICodeLens lens = getCodeLens(REFERENCES_TYPE, element, unit);
		lenses.add(lens);
		// }
		// if (preferenceManager.getPreferences().isImplementationsCodeLensEnabled() &&
		// element instanceof IType) {
		if (element instanceof IType) {
			IType type = (IType) element;
			if (type.isInterface() || Flags.isAbstract(type.getFlags())) {
				lens = getCodeLens(IMPLEMENTATION_TYPE, element, unit);
				lenses.add(lens);
			}
		}
	}
}
 

private static IMethod getIMethodFromMethodWrapper(MethodWrapper m) {
	try {
		IMember im = m.getMember();
		if (im.getElementType() == IJavaElement.METHOD) {
			return (IMethod) m.getMember();
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	return null;
}
 

/**
 * Returns currently selected method or <code>null</code>
 * @param editor
 * @return method or <code>null</code>
 * 
 */
public IMethod getCurrentSelectedJavaMethod(ITextEditor editor) {
	if (editor==null){
		return null;
	}
	
	IEditorInput editorInput = editor.getEditorInput();
	if (editorInput==null){
		return null;
	}
	IJavaElement elem = JavaUI.getEditorInputJavaElement(editorInput);
	if (elem instanceof ICompilationUnit) {
	    ITextSelection sel = (ITextSelection) editor.getSelectionProvider().getSelection();
	    IJavaElement selected;
		try {
			selected = ((ICompilationUnit) elem).getElementAt(sel.getOffset());
		} catch (JavaModelException e) {
			JunitUtil.logError("Was not able to get element at selection",e);
			return null;
		}
		if (selected==null){
			return null;
		}
	    if (selected.getElementType() == IJavaElement.METHOD) {
	         return (IMethod) selected;
	    }
	}
	return null;
}
 

public ICoverageNode getCoverageFor(IJavaElement element) {
  final ICoverageNode coverage = coveragemap.get(element);
  if (coverage != null) {
    return coverage;
  }
  if (IJavaElement.METHOD == element.getElementType()) {
    resolveMethods((IType) element.getParent());
    return coveragemap.get(element);
  }
  return null;
}
 

private void collectChildren(ITypeRoot unit, IJavaElement[] elements, ArrayList<SymbolInformation> symbols,
		IProgressMonitor monitor)
		throws JavaModelException {
	for(IJavaElement element : elements ){
		if (monitor.isCanceled()) {
			return;
		}
		if(element instanceof IParent){
			collectChildren(unit, filter(((IParent) element).getChildren()), symbols, monitor);
		}
		int type = element.getElementType();
		if (type != IJavaElement.TYPE && type != IJavaElement.FIELD && type != IJavaElement.METHOD) {
			continue;
		}

		Location location = JDTUtils.toLocation(element);
		if (location != null) {
			SymbolInformation si = new SymbolInformation();
			String name = JavaElementLabels.getElementLabel(element, JavaElementLabels.ALL_DEFAULT);
			si.setName(name == null ? element.getElementName() : name);
			si.setKind(mapKind(element));
			if (element.getParent() != null) {
				si.setContainerName(element.getParent().getElementName());
			}
			location.setUri(ResourceUtils.toClientUri(location.getUri()));
			si.setLocation(location);
			if (!symbols.contains(si)) {
				symbols.add(si);
			}
		}
	}
}
 

private boolean isInitializer(IJavaElement element) {
	if (element.getElementType() == IJavaElement.METHOD) {
		String name = element.getElementName();
		if ((name != null && name.indexOf('<') >= 0)) {
			return true;
		}
	}
	return false;
}
 

public static SymbolKind mapKind(IJavaElement element) {
	switch (element.getElementType()) {
	case IJavaElement.ANNOTATION:
		return SymbolKind.Property; // TODO: find a better mapping
	case IJavaElement.CLASS_FILE:
	case IJavaElement.COMPILATION_UNIT:
		return SymbolKind.File;
	case IJavaElement.FIELD:
		return SymbolKind.Field;
	case IJavaElement.IMPORT_CONTAINER:
	case IJavaElement.IMPORT_DECLARATION:
		return SymbolKind.Module;
	case IJavaElement.INITIALIZER:
		return SymbolKind.Constructor;
	case IJavaElement.LOCAL_VARIABLE:
	case IJavaElement.TYPE_PARAMETER:
		return SymbolKind.Variable;
	case IJavaElement.METHOD:
		return SymbolKind.Method;
	case IJavaElement.PACKAGE_DECLARATION:
		return SymbolKind.Package;
	case IJavaElement.TYPE:
		try {
			return ( ((IType)element).isInterface() ? SymbolKind.Interface : SymbolKind.Class);
		} catch (JavaModelException e) {
			return SymbolKind.Class;
		}
	}
	return SymbolKind.String;
}
 

private String getKind(IMember member) {
	switch (member.getElementType()) {
	case IJavaElement.METHOD:
		return KIND_METHOD;
	case IJavaElement.INITIALIZER:
		return KIND_INITIALIZER;
	case IJavaElement.FIELD:
		return KIND_FIELD;
	case IJavaElement.TYPE:
		IType type = (IType) member;
		try {
			if (type.isAnnotation()) {
				return KIND_ANNOTATION;
			}
			if (type.isInterface()) {
				return KIND_INTERFACE;
			}
			if (type.isEnum()) {
				return KIND_ENUM;
			}
			if (type.isClass()) {
				return KIND_CLASS;
			}
		} catch (JavaModelException e) {
			return KIND_TYPE;
		}
		return KIND_TYPE;
	default:
		return null;
	}
}
 

/**
 * Appends the label for a Java element with the flags as defined by this class.
 *
 * @param element the element to render
 * @param flags the rendering flags.
 */
public void appendElementLabel(IJavaElement element, long flags) {
	int type= element.getElementType();
	IPackageFragmentRoot root= null;

	if (type != IJavaElement.JAVA_MODEL && type != IJavaElement.JAVA_PROJECT && type != IJavaElement.PACKAGE_FRAGMENT_ROOT) {
		root= JavaModelUtil.getPackageFragmentRoot(element);
	}
	if (root != null && getFlag(flags, JavaElementLabels.PREPEND_ROOT_PATH)) {
		appendPackageFragmentRootLabel(root, JavaElementLabels.ROOT_QUALIFIED);
		fBuilder.append(JavaElementLabels.CONCAT_STRING);
	}

	switch (type) {
	case IJavaElement.METHOD:
		appendMethodLabel((IMethod) element, flags);
		break;
	case IJavaElement.FIELD:
		appendFieldLabel((IField) element, flags);
		break;
	case IJavaElement.LOCAL_VARIABLE:
		appendLocalVariableLabel((ILocalVariable) element, flags);
		break;
	case IJavaElement.TYPE_PARAMETER:
		appendTypeParameterLabel((ITypeParameter) element, flags);
		break;
	case IJavaElement.INITIALIZER:
		appendInitializerLabel((IInitializer) element, flags);
		break;
	case IJavaElement.TYPE:
		appendTypeLabel((IType) element, flags);
		break;
	case IJavaElement.CLASS_FILE:
		appendClassFileLabel((IClassFile) element, flags);
		break;
	case IJavaElement.COMPILATION_UNIT:
		appendCompilationUnitLabel((ICompilationUnit) element, flags);
		break;
	case IJavaElement.PACKAGE_FRAGMENT:
		appendPackageFragmentLabel((IPackageFragment) element, flags);
		break;
	case IJavaElement.PACKAGE_FRAGMENT_ROOT:
		appendPackageFragmentRootLabel((IPackageFragmentRoot) element, flags);
		break;
	case IJavaElement.IMPORT_CONTAINER:
	case IJavaElement.IMPORT_DECLARATION:
	case IJavaElement.PACKAGE_DECLARATION:
		appendDeclarationLabel(element, flags);
		break;
	case IJavaElement.JAVA_PROJECT:
	case IJavaElement.JAVA_MODEL:
		fBuilder.append(element.getElementName());
		break;
	default:
		fBuilder.append(element.getElementName());
	}

	if (root != null && getFlag(flags, JavaElementLabels.APPEND_ROOT_PATH)) {
		fBuilder.append(JavaElementLabels.CONCAT_STRING);
		appendPackageFragmentRootLabel(root, JavaElementLabels.ROOT_QUALIFIED);
	}
}
 

/**
 * Gets a reader for an IMember's Javadoc comment content from the source
 * attachment. and renders the tags in HTML. Returns <code>null</code> if
 * the member does not contain a Javadoc comment or if no source is
 * available.
 *
 * @param member
 *            the member to get the Javadoc of.
 * @param allowInherited
 *            for methods with no (Javadoc) comment, the comment of the
 *            overridden class is returned if <code>allowInherited</code> is
 *            <code>true</code>
 * @param useAttachedJavadoc
 *            if <code>true</code> Javadoc will be extracted from attached
 *            Javadoc if there's no source
 * @return a reader for the Javadoc comment content in HTML or
 *         <code>null</code> if the member does not contain a Javadoc
 *         comment or if no source is available
 * @throws JavaModelException
 *             is thrown when the elements Javadoc can not be accessed
 * @since 3.2
 */
static Reader getHTMLContentReader(IMember member, boolean allowInherited, boolean useAttachedJavadoc)
		throws JavaModelException {
	Reader contentReader= internalGetContentReader(member);
	if (contentReader != null) {
		return contentReader;
	}

	if (useAttachedJavadoc && member.getOpenable().getBuffer() == null) { // only if no source available
		String s= member.getAttachedJavadoc(null);
		if (s != null) {
			return new StringReader(s);
		}
	}

	if (allowInherited && (member.getElementType() == IJavaElement.METHOD)) {
		return findDocInHierarchy((IMethod) member, useAttachedJavadoc);
	}

	return null;
}