Thomas Darimont
Erfahrenes Mitglied
Hallo!
hier mal ein kleines Beispiel wie man unter Eclipse mit dem JDT Methodenabschlusskommentare hinter die Methoden bekommt:
(Ich möchte nur anmerken dass ich absolut kein Freund dieser Kommentierweise bin!)
... ja ja ich weis, dass ist ein übler Hack aber die ASTRewrite API wollte ich mir heute Abend nicht mehr antun ;-)
Aus:
Wird dann folgendes:
Leider funktioniert das ganze noch nicht für Methoden von anonymen Klassen..., scheinbar muss man dann noch die IMethods (und die IFields) auf definierte Typen prüfen könnte man rekursiv in einem Runtsch machen, mal schauen...
Gruß Tom
hier mal ein kleines Beispiel wie man unter Eclipse mit dem JDT Methodenabschlusskommentare hinter die Methoden bekommt:
(Ich möchte nur anmerken dass ich absolut kein Freund dieser Kommentierweise bin!)
Java:
/**
*
*/
package de.tutorials.jdt.srcmanipulation.core;
import java.util.Set;
import java.util.TreeSet;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IWorkbenchWindow;
/**
* @author Tom
*
*/
public class SourceCodeManipulator {
public static void addMethodEndComments(ICompilationUnit compilationUnit,
Shell shell, IWorkbenchWindow window) {
try {
IType[] types = compilationUnit.getAllTypes();
ASTParser astParser = ASTParser.newParser(AST.JLS3);
astParser.setSource(compilationUnit);
ASTNode astNode = astParser.createAST(new NullProgressMonitor());
astNode.accept(new ASTVisitor(false){
});
IBuffer buffer = compilationUnit.getBuffer();
StringBuilder sourceCodeBuffer = new StringBuilder(buffer
.getContents());
Set<MethodEndComment> methodEndComments = new TreeSet<MethodEndComment>();
for (int i = 0; i < types.length; i++) {
IType type = types[i];
IMethod[] methods = type.getMethods();
for (int j = 0; j < methods.length; j++) {
IMethod method = methods[j];
System.out.println("Current Method: "
+ method.getElementName());
ISourceRange sourceRange = method.getSourceRange();
MethodEndComment methodEndComment = new MethodEndComment(
sourceRange.getOffset() + sourceRange.getLength(),
method.getElementName());
methodEndComments.add(methodEndComment);
}
}
int currentDelta = 0;
for (MethodEndComment methodEndComment : methodEndComments) {
sourceCodeBuffer.insert(currentDelta
+ methodEndComment.getStartOffset(), methodEndComment
.buildMethodEndComment());
currentDelta += methodEndComment.getLength();
}
buffer.replace(0, buffer.getLength(), sourceCodeBuffer.toString());
} catch (JavaModelException e) {
e.printStackTrace();
}
}
static class MethodEndComment implements Comparable<MethodEndComment> {
private static final String END = "//END: ";
int startOffset;
String methodName;
public MethodEndComment(int startOffset, String methodName) {
super();
this.startOffset = startOffset;
this.methodName = methodName;
}
private String buildMethodEndComment() {
return END + this.methodName;
}
/**
* @return the length
*/
public int getLength() {
return buildMethodEndComment().length();
}
/**
* @return the methodName
*/
public String getMethodName() {
return methodName;
}
/**
* @param methodName
* the methodName to set
*/
public void setMethodName(String methodName) {
this.methodName = methodName;
}
/**
* @return the startOffset
*/
public int getStartOffset() {
return startOffset;
}
/**
* @param startOffset
* the startOffset to set
*/
public void setStartOffset(int startOffset) {
this.startOffset = startOffset;
}
public String toString() {
return this.buildMethodEndComment() + " for: " + this.methodName
+ "@" + this.startOffset;
}
public int compareTo(MethodEndComment otherMethodEndComment) {
return this.startOffset - otherMethodEndComment.startOffset;
}
}
}... ja ja ich weis, dass ist ein übler Hack aber die ASTRewrite API wollte ich mir heute Abend nicht mehr antun ;-)
Aus:
Java:
/**
*
*/
package de.tutorials.test;
/**
* @author Tom
*
*/
public class Foo {
static class XYZ{
void operationABC(){
};
}
public Foo(){
}
public static void main(String[] args) {
operationXXX();
}
static void operationXXX() {
}
void operationYYY() {
}
class ABC{
void operationUVW(){
}
}
}Wird dann folgendes:
Java:
/**
*
*/
package de.tutorials.test;
/**
* @author Tom
*
*/
public class Foo {
static class XYZ{
void operationABC(){
}//END: operationABC;
}
public Foo(){
}//END: Foo
public static void main(String[] args) {
operationXXX();
}//END: main
static void operationXXX() {
}//END: operationXXX
void operationYYY() {
}//END: operationYYY
class ABC{
void operationUVW(){
}//END: operationUVW
}
}Leider funktioniert das ganze noch nicht für Methoden von anonymen Klassen..., scheinbar muss man dann noch die IMethods (und die IFields) auf definierte Typen prüfen könnte man rekursiv in einem Runtsch machen, mal schauen...
Gruß Tom
