Okay, hab es geändert. Es geht immer noch um den Logger, den ich jetzt selber schreibe zu gedenke…
class Log {
private static final ArrayList<ArrayList<Object[]>> LI = new ArrayList<>();
static void log(String name, Object obj, boolean single) {
Object[] oa = new Object[]{name, obj};
if (single || !lastName().equals(name)) { // Tabellen sind immer Single
ArrayList<Object[]> l = new ArrayList<>();
l.add(oa);
LI.add(l);
} else {
LI.get(LI.size() - 1).add(oa);
}
}
static String lastName() {
if (LI.isEmpty()) {
return "empty";
}
return (String) LI.get(LI.size() - 1).get(0)[0];
}
static void printLog() {
System.out.println(body(join(each(LI, new Function<ArrayList<Object[]>, DomContent>() {
@Override
public DomContent apply(ArrayList<Object[]> t) {
if (t.get(0)[0].equals("Tabelle")) {
return table(tbody(each(((Tabelle) t.get(0)[1]).rows, new Function<Reihe, DomContent>() {
@Override
public DomContent apply(Reihe t) {
return tr(each(t.tds, new Function<WebElement, DomContent>() {
@Override
public DomContent apply(WebElement t) {
return td(t.getText());
}
}), td(String.valueOf(t.tds.size())));
}
})));
} else {
return join(each(t, new Function<Object[], DomContent>() {
@Override
public DomContent apply(Object[] t) {
return join(b((String) t[0]), t[1].toString());
}
}), br());
}
}
})), hr()).renderFormatted());
}
}
Dass der Compiler es auf „Richtigkeit“ überprüfen kann, ist schon ein kleines Wunder. Aber sieht jemand hierin ein Problem?
Das Problem ist, Log.printLog(); wird zum Schluss der Anwendung aufgerufen, .getText() basiert aber auf einem JNI-Aufruf, dh an der Stelle können wir uns nicht mehr auf den GC verlassen, und Teile des Objekts, auf dem .getText() aufgerufen wird, existiert zu dem Zeitpunkt nicht mehr. Oder anders, die Referenz wurde schon aufgeräumt.
Das zweite Problem ist die Liste von Listen von Feldern. Ich brauche eigentlich noch eine Klasse RegularEntryToAppend und eine Klasse TableEntryToAppend und eine Oberklasse (Abstract)EntryToAppend, aber das ist alles zu komplex, bzw ich will nicht so viele Klassen habn.
Hat jemand eine andere Idee?
Was wäre hieran richtig oder falsch??:
abstract class AbstractEntryToAppend {
abstract String getName();
abstract String getValue(); // Nur Nicht-Tabelle hat value....
abstract String[][] getTable(); // Nur Tabelle hat table....
}
class RegularEntryToAppend extends AbstractEntryToAppend {
String name, value;
RegularEntryToAppend(String name, Object value) {
this.name = name;
this.value = value.toString();
}
@Override
String getName() {
return name;
}
@Override
String[][] getTable() {
return null;
}
@Override
String getValue() {
return value;
}
}
class TableEntryToAppend extends AbstractEntryToAppend {
String[][] table;
public TableEntryToAppend(Tabelle tabelle) {
//....
}
@Override
String getName() {
return "Tabelle";
}
@Override
String[][] getTable() {
return table;
}
@Override
String getValue() {
return null;
}
}
, dass es an der Berechnung liegt — 1,3 Mrd. etwas berechnen, sollte nicht das Problem sein - oder?