# Eclipse: Bessere DetailFormatter / LogicalStructure



## Thomas Darimont (12. November 2009)

Eclipse DetailFormatter / LogicalStructure

Hallo,

wie ihr ja sicherlich wisst bietet der Debugger der Eclipse IDE die Möglichkeit eigene
DetailFormatter für Variablen zu definieren.

(Rechts-click auf eine Variable in der Debug View -> New Detail Formatter...)
Damit kann man die textuelle Darstellung in der Wertansicht beeinflussen.

Beispiel:

```
package de.tutorials;

import java.util.HashMap;
import java.util.Map;

public class DetailFormatter {
  public static void main(String[] args) {
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("a", 1);
    map.put("b", 2);
    map.put("c", 3);
    System.out.println(map);
  }
}
```




Klickt man die Variable map an, so sieht man in der textuellen Wert Darstellung folgenden Text:

```
{b=2, c=3, a=1}
```

Klickt man nun auf einen der Map-Einträge so sieht man:

```
b=2
```

Mit einem eigenen DetailFormatter kann man diesen Text manipulieren.
Beispielsweise erzeugt folgender DetailFormatter für 
java.util.HashMap$Entry

```
return getKey() + ": " + getValue();
```

Die Darstellung:

```
b: 2
```

Mehr dazu gibts hier:
http://blog.jcake.com/2008/03/05/eclipse-debugger-part-i-detailed-formatters/

Das ist zwar schon ganz schön hilfreich. Will man die dargestellte Struktur des Variablen Inhalts
ändern kann man via Java -> Debug -> Logical Structures eigene Darstellungsweisen für Datenstrukturen definieren.

Mehr dazu gibts hier:
http://blog.jcake.com/2008/03/09/eclipse-debugger-part-ii-logical-structures/

Wer neben Eclipse auch noch Visual Studio .Net kennt weiß, dass es dort mit den 
DebugVisualizern auch eine Möglichkeit gibt eigene Darstellungen für Werte / 
Datenstrukturen zu definieren.

Hier mal ein Beispiel für die Debug Darstellung eines Dictionary's (entspricht einer
HashMap in Java).




Wie man hier sehen kann sieht man bei einem Dictionary-Eintrag sofort das
Schlüsselwert-Paar welches sich dahinter versteckt

Bsp.: {[A,1]}

Ich finde diese Funktionalität ziemlich nützlich, da man so auf einen Blick den Inhalt einer
Map erkennen kann.

Will man dies mit Eclipse DetailFormattern / LogicalStructures nachbauen sieht man das man mit
den Hausmitteln schnell an seine Grenzen stößt...

mit folgender LogicalStructure-Definition bekommt man dieses Ergebnis:

```
List<String> keyValueMaps = new ArrayList<String>();
Iterator iter = entrySet().iterator();

while(iter.hasNext()){
  Map.Entry entry = (Map.Entry)iter.next();
  if(entry != null){
    keyValueMaps.add("{["+entry.getKey()+","+entry.getValue()+"]}");  
  }
}

return keyValueMaps;
```




Leider ist der Mechanismus so gebaut, dass die Rückgabe der LogicalStructure auch direkt zum 
drill-down in der Datenstruktur verwendet wird und nicht nur zu Darstellung...




Leider geht folgendes nicht:

```
List<Map.Entry> entries = new ArrayList<Map.Entry>();
    Iterator iter = entrySet().iterator();

    while(iter.hasNext()){
      final Map.Entry entry = (Map.Entry)iter.next();
      if(entry != null){
        entries.add(new Map.Entry(){
          Object key = entry.getKey();
          Object value = entry.getValue();
          
          public Object getKey(){
           return this.key;
          }
          
          public Object setValue(Object value){
            Object oldValue = this.value;
            this.value = value;
            return oldValue;
          }
          
          public Object getValue(){
            return this.value;
          }
          
          public String toString(){
            return "{["+this.key+","+this.value+"]}";
          }
        });
      }
    }

    return entries;
```
 
	Ergebnis:

```
Errors[1]	Constructor of a local type cannot be used in an evaluation expression
```

Ich müsste das mal weiter untersuchen... vielleicht könnte man über ein Fragment Bundle mit
dem org.eclipse.jdt.debug.ui Bundle als Host entsprechende Klassen / statische Methoden für
die LogicalStructure zur Verfügung stellen mit der "anständige" Visualizer möglich wären.

Mal schauen, was org.eclipse.jdt.internal.debug.eval.ast.engine.ASTInstructionCompiler noch
so alles mitmacht... ;-)

Hat jemand vielleicht noch eine andere Idee, wie man mit wenig Aufwand die Map Darstellung wie gewünscht ändern könnte?

Gruß Tom


----------



## kabel2 (12. November 2009)

Nope, mir jedenfalls war das unbekannt. Vielen Dank für den Hinweis!

Es ist ja unglaublich intuitiv, dass DetailFormatter direkt eingegeben werden können, für die Logical Structures allerdings ein Gang nach Canossa (Preferences) gemacht werden muß.
Ich jedenfalls hab gerade locker 10 Minuten gesucht...

Es werden auch keine im Source definierte Klassen gefunden, und Klassendefinitionen im Skript sind nicht erlaubt.

EDIT: <Unsinn gelöscht>

Das Problem ist, dass die Value-Spalte eine Variable vom Typ String anders anzeigt.
Wenn man da die Anzeige des DetailFormatters verwenden würde...


----------

