Zu Reflections & Annotations

[hdi]

Hallo Forum!

Long time no see

Vorwort: Ich bin ja was Annotations und Reflections angeht beschämenderweise nach wie vor ein ganz schöner Noob, einfach da ich das bisher in meiner Arbeit kaum gebraucht habe. Aber ich denke bei meinem derzeitigen Projekt komme ich da nicht drumherum.

Ich frag einfach mal ganz blöd:

Object obj = something.method();

Gibt es eine Möglichkeit, innerhalb von method() herauszufinden, dass:
1) der zurückgegebene Wert in eine Variable abgespeichert wird
2) diese Variable "obj" heißt

Ich könnte mir vorstellen, dass sowas vllt mit Annotations und Reflections geht? Oder nicht? Falls nein, geht das denn irgendwie, zB mit bestimmten Frameworks?

Wenn ihr noch Background braucht zu meinem Projekt, lasst es mich wissen.

edit: Achso, in obigem Code wäre obj wohl eine lokale Variable.

Vielen Dank
lg Thomas

 

[anti-held]

Ich denke nicht.

Was willst du denn damit bezwecken?
Vill kann man das auch anders lösen.

 

[hdi]

Ich arbeite gerade an einem Framework zur Visualisierung von Algorithmen. Ich hätte gerne die Info, dass das Ergebnis der Methode in "obj" gespeichert wird, damit ich eine Visualisierung machen kann, die deckungsgleich ist mit dem Source Code. Dass in der Visualisierung also irgendwo der Name "obj" auftaucht. Natürlich könnte ich dem Methodenaufruf einen String übergeben, aber schöner wäre es, das aus dem Source Code selbst rausparsen zu können.

Mal eine andere Frage:

@MyAnnotation(string="whatever")
something.method();

Wenn die Klasse, in der dieser Code steht, gar nichts mit dem Typ von something zu tun hat, dann komm ich an diese Annotation innerhalb der method() auch nicht ran, oder?

Also generell: Ich würde gerne verschiedenste Meta-Infos aus dem Code parsen, während er ausgeführt wird. z.B. für jeden Aufruf von method(), in was für eine Variable der zurückgegebene Wert gespeichert wird oder - wie in dem Snippet hier jetzt - die Info aus einer Annotation, die an jeden Aufruf der Methode geheftet ist.

Lieg ich da mit Reflections und Annotations grundsätzlich falsch? Aber ich dachte für sowas sind Annotations schon da.

Oder kann es sein, dass ich hier wohl eher so in Richtung Java Debugging Interface denken muss?

 

[anti-held]

Ich verstehe leider nicht genau wofür du das brauchen könntest.
Nenne doch ein Beispiel.

Hast du ein Paket, von welchem du die Methoden überprüfen willst?
Bzw. was soll dann überprüft werden?

 

[hdi]

Okay, mal ein konkretes Bsp. Angenommen du hast irgendeinen Algorithmus, in dem u.a. folgende Zeile vorkommt:

int max = array[0];

Ich will diesen Schritt visualisieren. Ich muss dafür also diese Anweisung in irgendein Format für mich bringen, das für eine Visualisierung geeignet ist. Wie auch immer das dann aussieht, ich benötige die Information:

- über das Array und seine Fächer, damit ich das zeichnen kann
- über die Variable max, und dass sie das Fach 0 indexiert, damit ich in meiner Zeichnung einen Pfeil auf das erste Fach mit dem Array machen kann, mit der Beschriftung "max"

So, mein Ansatz im Moment ist dass ich eine Library zur Verfügung stelle, mit der man seine Algorithmen schreibt. Ganz einfach weil ich dort dann diesen ganzen Code einbauen kann, der diese Infos scannt und in mein Visualisierungs-Format bringt. Also würdest du dann obige Zeile code mit meiner Library zB so schreiben:

ArrayReference<Integer> max = array.getElement(0);

Diese getElement-Methode entspricht jetzt quasi der "method" in meinem abstrakten Beispiel. Immer, wenn diese Methode aufgerufen wird, muss ich mir die o.g. Daten zusammensammeln die ich für die Visualisierung brauche.

Und damit eben das ganze zum Source Code passt, und man das nicht redundant schreiben muss, würde ich hier gerne einen Weg finden, wie ich zur Laufzeit bei Ausführung der getElement()-Methode irgendwie Zugriff auf den Caller der Methode habe, um dort zu kucken wie das abgespeichert wird, und auch ob da Annotationen dranhängen.

Zum Beispiel wäre es gut, wenn man an den eigentlichen Code noch Pseudo-Code hängen kann, den ich dann auch in der Visualisierung anzeigen kann. Darauf zielte meine zweite Frage mit den Annotations ab:

@PseudoCode(code=int max=array[0])
ArrayReference<Integer> max = array.getElement(0);

Und so sollte das funktionieren für den ganzen Algorithmus. Sowas wie

if(array[i] > max)

schreibst du dann unter Verwendung meiner Lib z.B. als

if(array.getElement(i).greater(max))

und auch hier wäre dann die Methode "greater" der Punkt, an dem ich die eigentliche Algorithmus-Logik um meine Visualisierungs-Infos anreichere.

Das ist so grob das Konzept. Und ich frage mich jetzt eben ob mir da Reflections und Annotations dienen können.

 

[hdi]

Hat noch jemand eine Idee? Kennt niemand irgendeine Art Framework dass zur Laufzeit an Variablen-Namen rankommt? Oder lautet die Antwort tatsächlich:

Oder kann es sein, dass ich hier wohl eher so in Richtung Java Debugging Interface denken muss?

Falls jemandem irgendetwas zu meinem Problem einfällt, ich bin für jeden Tipp dankbar!

lg Thomas

 

[anti-held]

Es ist möglich, durch den StackTrace auf die Methode zu kommen, von der aus aufgerufen worden ist.

			for(StackTraceElement elem: Thread.currentThread().getStackTrace()){
				System.out.println(elem.getClassName() + ", " + elem.getMethodName() + ", " + elem.getLineNumber());
			}

So könntest du auf die Zeile im Code kommen die du suchst.
Und wenn du zusätzlich den Quellcode hast, kannst du auch dann den Variablennamen herauslesen.

Eine bessere Möglichkeit fällt mir nicht ein. Sry

 

[KSG9|sebastian]

Ich glaub ein Ansatz passt irgendwie nicht so recht. Variablennamen gibt es zur Laufzeit nicht, den Sourcecode zu parsen würde ich die Finger davon lassen.

Beschreib mal etwas mehr high-level was du machen willst.

 

[hdi]

Naja wie ich es oben erklärt hatte, ich will einen Algorithmus visualisieren, und zur ordentlichen grafischen Darstellung müsste ich gewisse Dinge in der Visualisierung, wie beispielsweise Pfeile oder Links etc, mit Namen beschriften. Und diese Namen sollten optimalerweise zum Source Code passen, damit der Betrachter der Visualisierung die Grafik gut dem Code zuordnen kann.

Also zB hat man im Algorithmus eine Anweisung:

int max = array[0]

Neben der eigentlichen Visualisierung zeige ich den Code und markiere diese Zeile dort, damit man nachvollziehen kann was der Algo gerade tut. Und in der Grafik zeichne ich in diesem Schritt mein Array und eine Markierung auf das erste Fach, die mit "max" beschriftet ist.

Die Idee ist also, diesen Bezeichner irgendwie direkt aus dem Source Code rauszubekommen, damit der Coder des Algorithmus nicht über irgendwelche Methodenaufrufe oder zusätzliche Parameter explizit sagen muss, dass diese Referenz auf das Array mit "max" beschriftet werden soll. Denn der Algorithmus-Code selbst sollte möglichst unabhängig von der Visualisierung sein. Man sollte da also möglichst wenig "Metacode" für die Visualisierung einbauen müssen als Anwender.

 

[KSG9|sebastian]

Der User gibt doch keinen Code ein sondern eine Formel?!

Ich versteh den Sinn deines Frameworks nicht so recht. Kann dir nur sagen das es nicht möglich ist die Namen von lokalen Variablen rauszufinden.

Gruß Sebastian

 

[hdi]

Der User gibt doch keinen Code ein sondern eine Formel?!

Nein, der User = der Programmierer eines Algorithmus. Der Sinn des Frameworks liegt darin, es einem Programmierer leichter zu machen, einen Algorithmus mit Visualisierung zu implementieren. Hauptanwendungsfeld ist die Lehre, zB Profs an der Uni, die ihren Studenten klarmachen wollen wie gewisse Sortieralgorithmen oder Baumstrukturen arbeiten. Ich möchte ein Framework schreiben, mit dem solche Algorithmen (so gut es geht) automatisiert visualisiert werden können.

Kann dir nur sagen das es nicht möglich ist die Namen von lokalen Variablen rauszufinden.

Blöd ;(

Aber danke für die Antwort