Warning : session_start(): open(/var/lib/php/sessions/sess_4tpss9e6jf1v0nhq44q0f40vvt, O_RDWR) failed: No space left on device (28) in /var/www/tb-usercake/models/config.php on line 51 Warning : session_start(): Failed to read session data: files (path: /var/lib/php/sessions) in /var/www/tb-usercake/models/config.php on line 51 webs;
static Web inputWeb, resultWeb;
static String question;
static JTabbedPane tabs;
public static void main(final String[] args) throws Exception { substance();
cal_lineLength(50);
webs = websFromCALStructures_vis(inputDiagrams);
inputWeb = last(webs);
think();
final CirclesAndLines cal = webToCAL_live_vis(inputWeb,
new VF1() { public void get(Web w) { try { inputWeb = w; think() ; } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "inputWeb = w; think()"; }});
setFrameWidth(700, tabs = showTabbedWebs(
"Instruction", calAutoLayout2(webToCAL_live_vis(first(webs),
new VF1() { public void get(Web w) { try { webs.set(0, w); think() ; } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "webs.set(0, w); think()"; }})),
"Input", /*inputWeb,*/ calAutoLayout2(cal),
"Result", resultWeb != null ? resultWeb : jlabel("Sorry"),
"Computer's Question", second(jFullCenterTextPane(question))));
think();
}
static void think() { { AutoCloseable __1 = tempShowLoadingAnimation(); try {
print("Thinking.");
Web web = first(webs); // Instruction
Web patternWeb; Map patternMap ;Pair> __2= cloneWebWithMap(web); patternWeb = __2.a; patternMap = __2.b;
web_dropRelationsStartingWith(patternWeb, "Then:");
Web thenWeb; Map thenMap ;Pair> __3= cloneWebWithMap(web); thenWeb = __3.a; thenMap = __3.b;
web_unpackRelationsStartingWith(thenWeb, "Then:");
Map match = web_matchAllPerms(patternWeb, inputWeb);
// Clone inputWeb to get resultWeb
Web resultWeb; Map resultMap ;Pair> __4= cloneWebWithMap(inputWeb); resultWeb = __4.a; resultMap = __4.b;
main.resultWeb = resultWeb;
if (match != null) {
// Then add relations from thenWeb
for (WebRelation rel : web_relationObjects(thenWeb)) {
WebNode a = mapGet(resultMap, mapGet(match, mapGet(patternMap, reverseLookup(thenMap, rel.a))));
WebNode b = mapGet(resultMap, mapGet(match, mapGet(patternMap, reverseLookup(thenMap, rel.b))));
if (a != null && b != null) {
print("Adding labels " + rel.labels + " to: " + a + " - " + b);
WebRelation rel2 = resultWeb.getRelation(a, b);
web_addLabelsFromNodeToNode(rel, rel2);
}
}
}
// Make question
WebRelation rel = web_findDoubleRelation(resultWeb, "Is", "Is?");
question = "?";
if (rel != null) {
String a = web_text(rel.a), b = web_text(rel.b);
question = firstToUpper(a) + " may be " + firstToLower(b) + ".\n\n"
+ "But is " + firstToLower(b) + " " + addSpaceIfNempty(linkWord) + firstToLower(a) + "?";
}
if (tabs != null) {
printWeb(resultWeb);
CirclesAndLines cal = webToCAL(resultWeb);
printBeautify(cal_structure(cal));
replaceTab(tabs, "Result", webToCALWithAutoLayout(resultWeb));
replaceTab(tabs, "Computer's Question", second(jFullCenterTextPane(question)));
}
} finally { _close(__1); }}}
static void substance() {
substanceLAF();
}
static void substance(String skinName) {
substanceLAF(skinName);
}
static void cal_lineLength(int l) {
CALSpringLayout.defaultDesiredLength = l*0.01;
}
static List websFromCALStructures_vis(String... structures) {
if (l(structures) == 1) structures = toStringArray(tlft_j(first(structures)));
webToCAL_visStructures(structures);
return websFromCALStructures(structures);
}
static List websFromCALStructures_vis(List structures) {
return websFromCALStructures_vis(asStringArray(structures));
}
static A last(List l) {
return empty(l) ? null : l.get(l.size()-1);
}
static char last(String s) {
return empty(s) ? '#' : s.charAt(l(s)-1);
}
static int last(int[] a) {
return l(a) != 0 ? a[l(a)-1] : 0;
}
static double last(double[] a) {
return l(a) != 0 ? a[l(a)-1] : 0;
}
static A last(A[] a) {
return l(a) != 0 ? a[l(a)-1] : null;
}
static A last(Iterator it) {
A a = null;
while (it.hasNext()) { ping(); a = it.next(); }
return a;
}
static A last(Collection l) {
if (l == null) return null;
Iterator it = iterator(l);
A a = null;
while (it.hasNext()) { ping(); a = it.next(); }
return a;
}
static A last(SortedSet l) {
return l == null ? null : l.last();
}
// onNewWeb: voidfunc(Web)
static CirclesAndLines webToCAL_live_vis(Web web, final Object onNewWeb) {
final CirclesAndLines cal = webToCAL_vis(web);
cal.onStructureChange = new Runnable() { public void run() { try { pcallF(onNewWeb, calToWeb_vis(cal)) ;
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "pcallF(onNewWeb, calToWeb_vis(cal))"; }};
return cal;
}
static RuntimeException rethrow(Throwable t) {
if (t instanceof Error)
_handleError((Error) t);
throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
static RuntimeException rethrow(String msg, Throwable t) {
throw new RuntimeException(msg, t);
}
static A setFrameWidth(int w, A c) {
return setFrameWidth(c, w);
}
static A setFrameWidth(A c, int w) {
JFrame f = getFrame(c);
if (f != null)
f.setSize(w, f.getHeight());
return c;
}
static JTabbedPane showTabbedWebs(List params) {
return showTabbedWebs(toObjectArray(params));
}
// params: title, web, title, web, ...
// or: web, web, web, ...
static JTabbedPane showTabbedWebs(final Object... params) {
return swing(new F0() { JTabbedPane get() { try {
List out = new ArrayList();
int n = 0;
for (Object o : params) {
Web web = castOpt(o, Web.class);
if (web == null) { out.add(o); continue; }
++n;
CirclesAndLines cal = webToCAL(web);
Canvas canvas = cal.makeCanvas();
if (!isString(last(out)))
out.add(or2(cal.title, "Web " + n));
out.add(calAutoLayout2(cal, canvas));
}
//print("Tabs: " + map className(params) + " -> " + map className(out));
return showTabs(toObjectArray(out));
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "new L out;\r\n int n = 0;\r\n for (O o : params) {\r\n Web web = castOpt..."; }});
}
static volatile boolean calAutoLayout2_onByDefault = true;
static JPanel calAutoLayout2(CirclesAndLines cal, final Canvas canvas) {
calAddAutoLayoutSwitch_center.set(calAutoLayout2_onByDefault);
return centerAndSouth(canvas, calAddAutoLayoutSwitch_make(new Var(cal), canvas, null, calAutoLayout2_onByDefault));
}
static JPanel calAutoLayout2(CirclesAndLines cal) {
return calAutoLayout2(cal, cal.makeCanvas());
}
static Object first(Object list) {
return first((Iterable) list);
}
static A first(List list) {
return empty(list) ? null : list.get(0);
}
static A first(A[] bla) {
return bla == null || bla.length == 0 ? null : bla[0];
}
static A first(IterableIterator i) {
return first((Iterator ) i);
}
static A first(Iterator i) {
return i == null || !i.hasNext() ? null : i.next();
}
static A first(Iterable i) {
if (i == null) return null;
Iterator it = i.iterator();
return it.hasNext() ? it.next() : null;
}
static Character first(String s) { return empty(s) ? null : s.charAt(0); }
static A first(Pair p) {
return p == null ? null : p.a;
}
static Byte first(byte[] l) {
return empty(l) ? null : l[0];
}
static JLabel jlabel(final String text) {
return swingConstruct(BetterLabel.class, text);
}
static JLabel jlabel() {
return jlabel(" ");
}
static A second(List l) {
return get(l, 1);
}
static A second(Iterable l) {
if (l == null) return null;
Iterator it = iterator(l);
if (!it.hasNext()) return null;
it.next();
return it.hasNext() ? it.next() : null;
}
static A second(A[] bla) {
return bla == null || bla.length <= 1 ? null : bla[1];
}
static B second(Pair p) {
return p == null ? null : p.b;
}
static A second(Producer p) {
if (p == null) return null;
if (p.next() == null) return null;
return p.next();
}
static char second(String s) {
return charAt(s, 1);
}
static Pair jFullCenterTextPane(String text) {
JTextPane tp = jcenteredtextpane(text);
return pair(tp, jTiledBackground(whiteImage(10, 10), jFullCenter(setFont(sansSerif(20), tp))));
}
static AutoCloseable tempShowLoadingAnimation() {
return tempShowLoadingAnimation("Hold on user...");
}
static AutoCloseable tempShowLoadingAnimation(String text) { try {
return tempDisposeWindow(showAnimationInTopRightCorner("#1003543", text));
} catch (Throwable __e) { return null; } }
static volatile StringBuffer local_log = new StringBuffer(); // not redirected
static volatile Appendable print_log = local_log; // might be redirected, e.g. to main bot
// in bytes - will cut to half that
static volatile int print_log_max = 1024*1024;
static volatile int local_log_max = 100*1024;
static boolean print_silent = false; // total mute if set
static Object print_byThread_lock = new Object();
static volatile ThreadLocal print_byThread; // special handling by thread - prefers F1
static volatile Object print_allThreads;
static volatile Object print_preprocess;
static void print() {
print("");
}
static A print(String s, A o) {
print((endsWithLetterOrDigit(s) ? s + ": " : s) + o);
return o;
}
// slightly overblown signature to return original object...
static A print(A o) {
ping_okInCleanUp();
if (print_silent) return o;
String s = String.valueOf(o) + "\n";
print_noNewLine(s);
return o;
}
static void print_noNewLine(String s) {
Object f = getThreadLocal(print_byThread_dontCreate());
if (f == null) f = print_allThreads;
if (f != null)
// We do need the general callF machinery here as print_byThread is sometimes shared between modules
if (isFalse(
f instanceof F1 ? ((F1) f).get(s) :
callF(f, s))) return;
print_raw(s);
}
static void print_raw(String s) {
if (print_preprocess != null) s = (String) callF(print_preprocess, s);
s = fixNewLines(s);
Appendable loc = local_log;
Appendable buf = print_log;
int loc_max = print_log_max;
if (buf != loc && buf != null) {
print_append(buf, s, print_log_max);
loc_max = local_log_max;
}
if (loc != null)
print_append(loc, s, loc_max);
System.out.print(s);
}
static void print_autoRotate() {
}
static Pair> cloneWebWithMap(Web web) {
Web w = web_similarEmptyWeb(web);
return pair(w, (Map) web_addWebToWeb(web, w));
}
static Web web_dropRelationsStartingWith(Web web, String prefix) {
for (WebRelation rel : values(web.relations)) {
List labels = new ArrayList();
for (Lisp l : rel.labels)
if (!swic(web.unparseLabel(l), prefix))
labels.add(l);
if (l(labels) < l(rel.labels))
web_setLabels(rel, labels);
}
web_dropEmptyRelations(web);
return web;
}
static Web web_unpackRelationsStartingWith(Web web, String prefix) {
for (WebRelation rel : values(web.relations)) {
List labels = new ArrayList();
for (Lisp l : rel.labels) {
String s = web.unparseLabel(l);
if (swic(s, prefix))
labels.add(web.parseLabel(trim(s.substring(l(prefix)))));
}
web_setLabels(rel, labels);
}
return web_dropEmptyRelations(web);
}
static Map web_matchAllPerms(Web patternWeb, Web inputWeb) {
List patternNodes = web_nodes(patternWeb);
List inputNodes = web_nodes(inputWeb);
if (l(patternNodes) != l(inputNodes))
return null;
//fail("Can't match, differing number of nodes: " + l(patternNodes) + "/" + l(inputNodes));
List> perms = allPermutations(inputNodes);
Best> best = new Best();
for (List perm : perms)
best.put(perm, web_matchNodeLists(patternNodes, perm));
List l = best.getIfScoreAbove(0);
return l == null ? null : twoListsToOrderedMap(patternNodes, l);
}
static Collection web_relationObjects(Web web) {
if (web.relations != null)
return values(web.relations);
List l = new ArrayList();
for (WebNode n : web.nodes)
if (n instanceof WebRelation)
l.add(((WebRelation) n));
return l;
}
static B mapGet(Map map, A a) {
return map == null || a == null ? null : map.get(a);
}
static B mapGet(A a, Map map) {
return map == null || a == null ? null : map.get(a);
}
static A reverseLookup(B value, Map map) {
return reverseLookup(map, value);
}
static A reverseLookup(Map map, B value) {
if (map != null && value != null) for (A key : map.keySet())
if (eq(map.get(key), value))
return key;
return null;
}
static void web_addLabelsFromNodeToNode(WebNode src, WebNode dest) {
if (src == dest) return;
web_addLabels(dest, src.labels);
}
static void web_addLabelsFromNodeToNode(Map map) {
for (WebNode key : keys( map)) { WebNode value = map.get(key);
web_addLabelsFromNodeToNode(key, value);
}
}
static WebRelation web_findDoubleRelation(Web web, String label1, String label2) {
for (WebRelation rel : web_relationObjects(web))
if (web_hasLabelIC(rel, label1) && web_hasLabelIC(web_reverseRelation(rel), label2))
return rel;
return null;
}
static String web_text(WebNode node) {
return node == null ? null : node.text();
}
static String firstToUpper(String s) {
if (empty(s)) return s;
return Character.toUpperCase(s.charAt(0)) + s.substring(1);
}
static String firstToLower(String s) {
if (empty(s)) return s;
return Character.toLowerCase(s.charAt(0)) + s.substring(1);
}
static String addSpaceIfNempty(String s) {
return appendSpaceIfNempty(s);
}
static void printWeb(Web web) {
if (web == null) { print("-"); return; }
List> relations = web_nonEmptyRelations(web);
print((web.unverified ? "UNVERIFIED " : "VERIFIED ")
+ "Web " + web.globalID
+ " from " + web.source
+ (web.created == 0 ? "" : ", created " + dateGMT(web.created))
+ ": " + n(l(web.nodes)-l(relations), "node") + ", " + n(relations, "relation"));
print();
List nodes = web_nonRelationNodes(web);
if (!(l(nodes) == 2 && l(relations) == 1)) {
pnlIndent(collectMethod(nodes, "text"));
print();
}
web_printRelations(web);
}
static class WebToCAL {
Web web;
BufferedImage img = newBufferedImage(20, 20, Color.white);
CirclesAndLines cal = new CirclesAndLines();
Map map = new HashMap();
//new Map, Line> lines;
String makeLabel(Lisp lisp) {
if (web.useCLParse) return conceptLanguageToEnglish(clUnparse(lisp));
return or(lispHead(lisp), "[null]");
}
void convert(final Web web) {
this.web = web;
cal.title = web.title;
List nodes = web.nodes;
nodes = listMinusSet(nodes, web_relationObjects(web));
for (WebNode node : nodes) {
double x = node.x, y = node.y;
if (x == 0 && y == 0) {
x = cal_randomCircleCoord();
y = cal_randomCircleCoord();
}
//print("Circle " + node.text() + " pos: " + x + "/" + y);
String text = makeLabel(first(node.labels()));
String quickvis = null;
if (node.visInfo() instanceof String) quickvis = (String) node.visInfo();
if (empty(quickvis)) quickvis = webToCAL_visMap.get(text);
Circle c;
if (nempty(quickvis))
c = cal.circle_autoVis(text, quickvis, x, y);
else
c = cal.circle(img, x, y, text);
map.put(node, c);
for (Lisp l : dropFirst(node.labels()))
c.addTrait(makeLabel(l));
}
for (Pair p : web_relations(web)) {
WebNode rel = web.getRelation(p);
if (empty(rel.labels())) continue;
Circle a = map.get(p.a), b = map.get(p.b);
if (a == null || b == null) {
warn("webToCAL: Circle not found");
continue;
}
if (a == b) continue; // TODO
/*Line line = lines.get(p);
if (line == null)
lines.put(p,*/
Line line = cal.arrow(a, makeLabel(first(rel.labels())), b);
for (Lisp l : dropFirst(rel.labels()))
line.addTrait(makeLabel(l));
}
cal.onUserMadeCircle = new VF1() { public void get(Circle c) { try {
map.put(web.newNode(c.text), c);
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "map.put(web.newNode(c.text), c);"; }};
cal.onDeleteCircle = new VF1() { public void get(Circle c) { try {
web.removeNode(reverseLookup(map, c));
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "web.removeNode(reverseLookup(map, c));"; }};
cal.onDeleteLine = new VF1() { public void get(Line l) { try {
web.removeRelation(reverseLookup(map, l.a), reverseLookup(map, l.b));
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "web.removeRelation(reverseLookup(map, l.a), reverseLookup(map, l.b));"; }};
cal.onUserMadeArrow = new VF1() { public void get(Arrow a) { try {
web.getRelation(reverseLookup(map, a.a), reverseLookup(map, a.b)).addLabel(a.text);
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "web.getRelation(reverseLookup(map, a.a), reverseLookup(map, a.b)).addLabel(a...."; }};
cal.onLayoutChange = new VF1() { public void get(Circle c) { try {
WebNode node = reverseLookup(map, c);
//print("layout change: " + c.text + " " + (node != null));
updateLayout(node);
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "WebNode node = reverseLookup(map, c);\r\n //print(\"layout change: \" + c.te..."; }};
cal.onFullLayoutChange = new Runnable() { public void run() { try {
//print("full layout change");
for (WebNode web : keys(map))
updateLayout(web);
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "//print(\"full layout change\");\r\n for (WebNode web : keys(map))\r\n ..."; }};
}
void updateLayout(WebNode node) {
if (node == null) return;
Circle c = map.get(node);
if (c == null) return;
node.x = c.x;
node.y = c.y; // TODO: persist?
}
}
static CirclesAndLines webToCAL(WebNode node) {
return webToCAL(node.web);
}
static CirclesAndLines webToCAL(Web web) {
WebToCAL wtc = new WebToCAL();
wtc.convert(web);
return wtc.cal;
}
static void webToCAL(Web web, CirclesAndLines cal, Canvas canvas) {
copyCAL(webToCAL(web), cal);
canvas.update();
}
static void printBeautify(String s) {
print(beautifyStructure(s));
}
static String cal_structure(CirclesAndLines cal) {
return cal_structure_impl(restructure(cal));
}
static String cal_structure_impl(CirclesAndLines cal) {
if (cal.arrowClass == Arrow.class) cal.arrowClass = null;
if (cal.circleClass == Circle.class) cal.circleClass = null;
for (Circle c : cal.circles) cal_structure_simplifyElement(c);
for (Line l : cal.lines) cal_structure_simplifyElement(l);
return structure(cal);
}
static void cal_structure_simplifyElement(Base b) {
if (eq(b.traits, ll(b.text))) b.traits = null;
}
static boolean replaceTab(final JTabbedPane tabs, final String name, final Component c) {
if (tabs == null) return false;
return swing(new F0() { Boolean get() { try {
int idx = tabs.indexOfTab(name);
if (idx < 0) return false;
tabs.setComponentAt(idx, wrap(c));
return true;
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "int idx = tabs.indexOfTab(name);\r\n if (idx < 0) false;\r\n tabs.setCompon..."; }});
}
static JComponent webToCALWithAutoLayout(Web web) {
CirclesAndLines cal = webToCAL(web);
return calAutoLayout2(cal, cal.makeCanvas());
}
static void _close(AutoCloseable c) {
if (c != null) try {
c.close();
} catch (Throwable e) {
// Some classes stupidly throw an exception on double-closing
if (c instanceof javax.imageio.stream.ImageOutputStream)
return;
else throw rethrow(e);
}
}
static Map webToCAL_visMap = caseInsensitiveSynchroMap();
static void webToCAL_visStructures(String... structures) {
for (String s : structures) { try {
webToCAL_visStructures(cal_unstructure(s));
} catch (Throwable __e) { _handleException(__e); }}
}
static void webToCAL_visStructures(CirclesAndLines cal) {
if (cal != null)
for (Circle c : cal.circles)
if (nempty(c.quickvis) && nempty(c.text))
webToCAL_visMap.put(c.text, c.quickvis);
}
static String substanceLAF_defaultSkin = "Creme";
static void substanceLAF() {
substanceLAF(null);
}
static void substanceLAF(String skinName) {
try {
enableSubstance_impl(or2(skinName, substanceLAF_defaultSkin));
} catch (Throwable __e) { _handleException(__e); }
}
static int l(Object[] a) { return a == null ? 0 : a.length; }
static int l(boolean[] a) { return a == null ? 0 : a.length; }
static int l(byte[] a) { return a == null ? 0 : a.length; }
static int l(short[] a) { return a == null ? 0 : a.length; }
static int l(long[] a) { return a == null ? 0 : a.length; }
static int l(int[] a) { return a == null ? 0 : a.length; }
static int l(float[] a) { return a == null ? 0 : a.length; }
static int l(double[] a) { return a == null ? 0 : a.length; }
static int l(char[] a) { return a == null ? 0 : a.length; }
static int l(Collection c) { return c == null ? 0 : c.size(); }
static int l(Iterator i) { return iteratorCount_int_close(i); } // consumes the iterator && closes it if possible
static int l(Map m) { return m == null ? 0 : m.size(); }
static int l(CharSequence s) { return s == null ? 0 : s.length(); }
static long l(File f) { return f == null ? 0 : f.length(); }
static int l(Object o) {
return o == null ? 0
: o instanceof String ? l((String) o)
: o instanceof Map ? l((Map) o)
: o instanceof Collection ? l((Collection) o)
: o instanceof Object[] ? l((Object[]) o)
: o instanceof boolean[] ? l((boolean[]) o)
: o instanceof byte[] ? l((byte[]) o)
: o instanceof char[] ? l((char[]) o)
: o instanceof short[] ? l((short[]) o)
: o instanceof int[] ? l((int[]) o)
: o instanceof float[] ? l((float[]) o)
: o instanceof double[] ? l((double[]) o)
: o instanceof long[] ? l((long[]) o)
: (Integer) call(o, "size");
}
static int l(MultiSet ms) { return ms == null ? 0 : ms.size(); }
static int l(Lisp l) { return l == null ? 0 : l.size(); }
static String[] toStringArray(Collection c) {
String[] a = new String[l(c)];
Iterator it = c.iterator();
for (int i = 0; i < l(a); i++)
a[i] = it.next();
return a;
}
static String[] toStringArray(Object o) {
if (o instanceof String[])
return (String[]) o;
else if (o instanceof Collection)
return toStringArray((Collection) o);
else
throw fail("Not a collection or array: " + getClassName(o));
}
static List tlft_j(String text) {
return toLinesFullTrim_java(text);
}
// also takes one string with multiple lines
static List websFromCALStructures(String... structures) {
if (l(structures) == 1) structures = toStringArray(tlft_j(first(structures)));
return map("webFromCALStructure",structures);
}
static List webFromCALStructures(List structures) {
return map("webFromCALStructure",structures);
}
static String[] asStringArray(Collection c) {
return toStringArray(c);
}
static String[] asStringArray(Object o) {
return toStringArray(o);
}
static boolean empty(Collection c) { return c == null || c.isEmpty(); }
static boolean empty(CharSequence s) { return s == null || s.length() == 0; }
static boolean empty(Map map) { return map == null || map.isEmpty(); }
static boolean empty(Object[] o) { return o == null || o.length == 0; }
static boolean empty(Object o) {
if (o instanceof Collection) return empty((Collection) o);
if (o instanceof String) return empty((String) o);
if (o instanceof Map) return empty((Map) o);
if (o instanceof Object[]) return empty((Object[]) o);
if (o instanceof byte[]) return empty((byte[]) o);
if (o == null) return true;
throw fail("unknown type for 'empty': " + getType(o));
}
static boolean empty(Iterator i) { return i == null || !i.hasNext(); }
static boolean empty(double[] a) { return a == null || a.length == 0; }
static boolean empty(float[] a) { return a == null || a.length == 0; }
static boolean empty(int[] a) { return a == null || a.length == 0; }
static boolean empty(long[] a) { return a == null || a.length == 0; }
static boolean empty(byte[] a) { return a == null || a.length == 0; }
static boolean empty(short[] a) { return a == null || a.length == 0; }
static boolean empty(MultiSet ms) { return ms == null || ms.isEmpty(); }
static boolean empty(File f) { return getFileSize(f) == 0; }
//sbool ping_actions_shareable = true;
static volatile boolean ping_pauseAll = false;
static int ping_sleep = 100; // poll pauseAll flag every 100
static volatile boolean ping_anyActions = false;
static Map ping_actions = newWeakHashMap();
static ThreadLocal ping_isCleanUpThread = new ThreadLocal();
// always returns true
static boolean ping() {
if (ping_pauseAll || ping_anyActions ) ping_impl(true /* XXX */);
//ifndef LeanMode ping_impl(); endifndef
return true;
}
// returns true when it slept
static boolean ping_impl(boolean okInCleanUp) { try {
if (ping_pauseAll && !isAWTThread()) {
do
Thread.sleep(ping_sleep);
while (ping_pauseAll);
return true;
}
if (ping_anyActions) { // don't allow sharing ping_actions
if (!okInCleanUp && !isTrue(ping_isCleanUpThread.get()))
failIfUnlicensed();
Object action = null;
synchronized(ping_actions) {
if (!ping_actions.isEmpty()) {
action = ping_actions.get(currentThread());
if (action instanceof Runnable)
ping_actions.remove(currentThread());
if (ping_actions.isEmpty()) ping_anyActions = false;
}
}
if (action instanceof Runnable)
((Runnable) action).run();
else if (eq(action, "cancelled"))
throw fail("Thread cancelled.");
}
return false;
} catch (Exception __e) { throw rethrow(__e); } }
static Iterator iterator(Iterable c) {
return c == null ? emptyIterator() : c.iterator();
}
static CirclesAndLines webToCAL_vis(Web web) {
CirclesAndLines cal = webToCAL(web);
webToCAL_visStructures(cal);
return cal;
}
static Object pcallF(Object f, Object... args) {
return pcallFunction(f, args);
}
static A pcallF(F0 f) { try {
return f == null ? null : f.get();
} catch (Throwable __e) { return null; } }
static B pcallF(F1 f, A a) { try {
return f == null ? null : f.get(a);
} catch (Throwable __e) { return null; } }
static void pcallF(VF1 f, A a) {
try {
if (f != null) f.get(a);
} catch (Throwable __e) { _handleException(__e); }
}
static Web calToWeb_vis(CirclesAndLines cal) {
webToCAL_visStructures(cal);
return calToWeb(cal);
}
static void _handleError(Error e) {
call(javax(), "_handleError", e);
}
static JFrame getFrame(final Object _o) {
return swing(new F0() { JFrame get() { try {
Object o = _o;
if (o instanceof ButtonGroup) o = first(buttonsInGroup((ButtonGroup) o));
if (!(o instanceof Component)) return null;
Component c = (Component) o;
while (c != null) {
if (c instanceof JFrame) return (JFrame) c;
c = c.getParent();
}
return null;
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "O o = _o;\r\n if (o instanceof ButtonGroup) o = first(buttonsInGroup((Button..."; }});
}
static Object[] toObjectArray(Collection c) {
List l = asList(c);
return l.toArray(new Object[l.size()]);
}
static Object swing(Object f) {
return swingAndWait(f);
}
static A swing(F0 f) {
return (A) swingAndWait(f);
}
static A swing(IF0 f) {
return (A) swingAndWait(f);
}
// get purpose 1: access a list/array/map (safer version of x.get(y))
static A get(List l, int idx) {
return l != null && idx >= 0 && idx < l(l) ? l.get(idx) : null;
}
// seems to conflict with other signatures
/*static B get(Map map, A key) {
ret map != null ? map.get(key) : null;
}*/
static A get(A[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : null;
}
// default to false
static boolean get(boolean[] l, int idx) {
return idx >= 0 && idx < l(l) ? l[idx] : false;
}
// get purpose 2: access a field by reflection or a map
static Object get(Object o, String field) {
try {
if (o == null) return null;
if (o instanceof Class) return get((Class) o, field);
if (o instanceof Map)
return ((Map) o).get(field);
Field f = getOpt_findField(o.getClass(), field);
if (f != null) {
makeAccessible(f);
return f.get(o);
}
if (o instanceof DynamicObject)
return ((DynamicObject) o).fieldValues.get(field);
} catch (Exception e) {
throw asRuntimeException(e);
}
throw new RuntimeException("Field '" + field + "' not found in " + o.getClass().getName());
}
static Object get_raw(String field, Object o) {
return get_raw(o, field);
}
static Object get_raw(Object o, String field) { try {
if (o == null) return null;
Field f = get_findField(o.getClass(), field);
makeAccessible(f);
return f.get(o);
} catch (Exception __e) { throw rethrow(__e); } }
static Object get(Class c, String field) {
try {
Field f = get_findStaticField(c, field);
makeAccessible(f);
return f.get(null);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
static Field get_findStaticField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Static field '" + field + "' not found in " + c.getName());
}
static Field get_findField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
throw new RuntimeException("Field '" + field + "' not found in " + c.getName());
}
static Object get(String field, Object o) {
return get(o, field);
}
static A castOpt(Object o, Class c) {
return isInstance(c, o) ? (A) o : null;
}
static boolean isString(Object o) {
return o instanceof String;
}
static String or2(String a, String b) {
return nempty(a) ? a : b;
}
static String or2(String a, String b, String c) {
return or2(or2(a, b), c);
}
static JTabbedPane showTabs(Object... params) {
JTabbedPane tabs = jtabs(params);
showFrame(tabs);
return tabs;
}
static JPanel centerAndSouth(final Component c, final Component s) {
return swing(new F0() { JPanel get() { try {
JPanel panel = new JPanel(new BorderLayout());
panel.add(BorderLayout.CENTER, wrap(c));
if (s != null) panel.add(BorderLayout.SOUTH, wrap(s));
return panel;
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "JPanel panel = new JPanel(new BorderLayout);\r\n panel.add(BorderLayout.CENT..."; }});
}
static void calAddAutoLayoutSwitch(CirclesAndLines cal, final Canvas canvas, Object modifyLayout, boolean on) {
calAddAutoLayoutSwitch(new Var(cal), canvas, modifyLayout, on);
}
static double calAddAutoLayoutSwitch_scale = 100;
static ThreadLocal calAddAutoLayoutSwitch_center = new ThreadLocal();
static void calAddAutoLayoutSwitch(final Var cal, final Canvas canvas, final Object modifyLayout, final boolean on) {
addToWindow(canvas, calAddAutoLayoutSwitch_make(cal, canvas, modifyLayout, on));
}
static JPanel calAddAutoLayoutSwitch_make(final Var cal, final Canvas canvas, final Object modifyLayout, final boolean on) {
final boolean center = boolOptParam(calAddAutoLayoutSwitch_center);
return swing(new F0() { JPanel get() { try {
// dummy for getting desiredLength
CALSpringLayout _layout = new CALSpringLayout(cal.get());
if (l(cal.get().circles) <= 2) _layout.desiredLength = 0.45;
callF(modifyLayout, _layout);
final JCheckBox cb = jcheckbox("Auto-Layout", on);
final JButton btnNew = jbutton("Scramble", new Runnable() { public void run() { try {
cal_scramble(cal.get());
updateCanvas(canvas);
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "cal_scramble(cal.get());\r\n updateCanvas(canvas);"; }});
final JCheckBox cb2 = jcheckbox("Center", center);
final JSpinner lineLength = setSpinnerStepSize(5, jspinner(iround(_layout.desiredLength*calAddAutoLayoutSwitch_scale), 1, 50));
JPanel panel = jcenteredline(cb, btnNew, cb2, jlabel("Line length:"), lineLength);
awtCalcEvery2(canvas, 100, new Runnable() {
CALSpringLayout layout;
CirclesAndLines lastCAL = cal.get();
boolean lastOn = false;
public void run() {
boolean x = false;
boolean on = isChecked(cb);
if (on) {
if (cal.get() != lastCAL || layout == null) {
lastCAL = cal.get();
layout = new CALSpringLayout(cal.get());
layout.center = false;
callF(modifyLayout, layout);
}
layout.desiredLength = intFromSpinner(lineLength)/calAddAutoLayoutSwitch_scale;
if (!lastOn) layout.clear();
layout.step();
x = true;
}
lastOn = on;
if (isChecked(cb2)) {
calCenterStepwise(cal.get(), 0.1);
x = true;
}
if (x) updateCanvas(canvas);
}
});
return panel;
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "// dummy for getting desiredLength\r\n CALSpringLayout _layout = new CALSpri..."; }});
}
static A swingConstruct(final Class c, final Object... args) {
return swing(new F0 () { A get() { try { return nuObject(c, args); } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "ret nuObject(c, args);"; }});
}
static char charAt(String s, int i) {
return s != null && i >= 0 && i < s.length() ? s.charAt(i) : '\0';
}
static JTextPane jcenteredtextpane() {
return centerTextPane(jtextpane());
}
static JTextPane jcenteredtextpane(String text, AttributeSet attributes) {
return centerTextPane(jtextpane(text, attributes));
}
static JTextPane jcenteredtextpane(String text) {
return centerTextPane(jtextpane(text));
}
static Pair pair(A a, B b) {
return new Pair(a, b);
}
static Pair pair(A a) {
return new Pair(a, a);
}
static JPanel jTiledBackground(String imageID) {
return jTiledBackground(loadImage2(imageID));
}
static JPanel jTiledBackground(final BufferedImage tileImage) {
return swing(new F0() { JPanel get() { try { return new JPanel() {
protected void paintComponent(Graphics g) {
paintTiledBackground(this, g, tileImage);
}
}; } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "ret new JPanel {\r\n protected void paintComponent(Graphics g) { \r\n pa..."; }});
}
static JPanel jTiledBackground(String imageID, Component contents) {
return jTiledBackground(loadImage2(imageID), contents);
}
static JPanel jTiledBackground(BufferedImage tileImage, Component contents) {
JPanel panel = jTiledBackground(tileImage);
panel.setLayout(new BorderLayout());
panel.add(BorderLayout.CENTER, jtransparent_recursive(contents));
return panel;
}
static BufferedImage whiteImage(int w, int h) {
return newBufferedImage(w, h, Color.white);
}
static BufferedImage whiteImage(int size) {
return whiteImage(size, size);
}
static JPanel jFullCenter(final Component c) {
return swing(new F0() { JPanel get() { try {
JPanel panel = new JPanel(new GridBagLayout());
panel.add(c);
return panel;
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "JPanel panel = new JPanel(new GridBagLayout);\r\n panel.add(c);\r\n ret panel;"; }});
}
static A setFont(final Font font, final A a) {
if (a != null) { swing(new Runnable() { public void run() { try { a.setFont(font);
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "a.setFont(font);"; }}); }
return a;
}
static A setFont(A a, Font font) {
return setFont(font, a);
}
static A setFont(final String fontID, float fontSize, final A a) {
return setFont(loadFont_cached(fontID, fontSize), a);
}
static Font sansSerif(int fontSize) {
return new Font(Font.SANS_SERIF, Font.PLAIN, fontSize);
}
static AutoCloseable tempDisposeWindow(final Window w) {
return new AutoCloseable() {
public void close() {
disposeWindow(w);
}
};
}
static boolean showAnimationInTopRightCorner_alwaysOnTop = true;
static boolean showAnimationInTopRightCorner_on = true;
// automatically switches to AWT thread for you
// text is optional text below image
static JWindow showAnimationInTopRightCorner(String imageID, String text) {
if (isHeadless() || !showAnimationInTopRightCorner_on) return null;
return showAnimationInTopRightCorner(imageIcon(imageID), text);
}
static JWindow showAnimationInTopRightCorner(final Image image, final String text) {
if (image == null || isHeadless() || !showAnimationInTopRightCorner_on) return null;
return showAnimationInTopRightCorner(imageIcon(image), text);
}
static JWindow showAnimationInTopRightCorner(final ImageIcon imageIcon, final String text) {
if (isHeadless() || !showAnimationInTopRightCorner_on) return null;
return (JWindow) swingAndWait(new F0() { Object get() { try {
JLabel label = new JLabel(imageIcon);
if (nempty(text)) {
label.setText(text);
label.setVerticalTextPosition(SwingConstants.BOTTOM);
label.setHorizontalTextPosition(SwingConstants.CENTER);
}
final JWindow window = showInTopRightCorner(label);
onClick(label, new Runnable() { public void run() { try { window.dispose() ;
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "window.dispose()"; }});
if (showAnimationInTopRightCorner_alwaysOnTop)
window.setAlwaysOnTop(true);
return window;
} catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "JLabel label = new JLabel(imageIcon);\r\n if (nempty(text)) {\r\n label.s..."; }});
}
static JWindow showAnimationInTopRightCorner(final String imageID) {
return showAnimationInTopRightCorner(imageID, "");
}
static JWindow showAnimationInTopRightCorner(String imageID, double seconds) {
return showAnimationInTopRightCorner(imageID, "", seconds);
}
static JWindow showAnimationInTopRightCorner(String imageID, String text, double seconds) {
if (isHeadless()) return null;
return disposeWindowAfter(iround(seconds*1000), showAnimationInTopRightCorner(imageID, text));
}
static JWindow showAnimationInTopRightCorner(BufferedImage img, String text, double seconds) {
return disposeWindowAfter(iround(seconds*1000), showAnimationInTopRightCorner(img, text));
}
static boolean endsWithLetterOrDigit(String s) {
return s != null && s.length() > 0 && Character.isLetterOrDigit(s.charAt(s.length()-1));
}
static void ping_okInCleanUp() {
if (ping_pauseAll || ping_anyActions )
ping_impl(true);
}
// this syntax should be removed...
static Object getThreadLocal(Object o, String name) {
ThreadLocal t = (ThreadLocal) (getOpt(o, name));
return t != null ? t.get() : null;
}
static A getThreadLocal(ThreadLocal tl) {
return tl == null ? null : tl.get();
}
static A getThreadLocal(ThreadLocal tl, A defaultValue) {
return or(getThreadLocal(tl), defaultValue);
}
static ThreadLocal print_byThread_dontCreate() {
return print_byThread;
}
static boolean isFalse(Object o) {
return eq(false, o);
}
static Map> callF_cache = newDangerousWeakHashMap();
static A callF(F0 f) {
return f == null ? null : f.get();
}
static B callF(F1 f, A a) {
return f == null ? null : f.get(a);
}
static A callF(IF0 f) {
return f == null ? null : f.get();
}
static B callF(IF1 f, A a) {
return f == null ? null : f.get(a);
}
static C callF(F2 f, A a, B b) {
return f == null ? null : f.get(a, b);
}
static C callF(IF2 f, A a, B b) {
return f == null ? null : f.get(a, b);
}
static void callF(VF1 f, A a) {
if (f != null) f.get(a);
}
static Object callF(Object f, Object... args) { try {
if (f instanceof String)
return callMCWithVarArgs((String) f, args); // possible SLOWDOWN over callMC
if (f instanceof Runnable) {
((Runnable) f).run();
return null;
}
if (f == null) return null;
Class c = f.getClass();
ArrayList methods;
synchronized(callF_cache) {
methods = callF_cache.get(c);
if (methods == null)
methods = callF_makeCache(c);
}
int n = l(methods);
if (n == 0) {
throw fail("No get method in " + getClassName(c));
}
if (n == 1) return invokeMethod(methods.get(0), f, args);
for (int i = 0; i < n; i++) {
Method m = methods.get(i);
if (call_checkArgs(m, args, false))
return invokeMethod(m, f, args);
}
throw fail("No matching get method in " + getClassName(c));
} catch (Exception __e) { throw rethrow(__e); } }
// used internally
static ArrayList callF_makeCache(Class c) {
ArrayList l = new ArrayList();
Class _c = c;
do {
for (Method m : _c.getDeclaredMethods())
if (m.getName().equals("get")) {
makeAccessible(m);
l.add(m);
}
if (!l.isEmpty()) break;
_c = _c.getSuperclass();
} while (_c != null);
callF_cache.put(c, l);
return l;
}
static String fixNewLines(String s) {
int i = indexOf(s, '\r');
if (i < 0) return s;
int l = s.length();
StringBuilder out = new StringBuilder(l);
out.append(s, 0, i);
for (; i < l; i++) {
char c = s.charAt(i);
if (c != '\r')
out.append(c);
else {
out.append('\n');
if (i+1 < l && s.charAt(i+1) == '\n') ++i;
}
}
return out.toString();
}
static void print_append(Appendable buf, String s, int max) { try {
synchronized(buf) {
buf.append(s);
if (buf instanceof StringBuffer)
rotateStringBuffer(((StringBuffer) buf), max);
else if (buf instanceof StringBuilder)
rotateStringBuilder(((StringBuilder) buf), max);
}
} catch (Exception __e) { throw rethrow(__e); } }
static Web web_similarEmptyWeb(Web web) {
Web w = new Web();
w.useCLParse = web.useCLParse;
w.labelsToUpper = web.labelsToUpper;
return w;
}
static HashMap web_addWebToWeb(Web web, Web w) {
HashMap map = new HashMap();
for (WebNode node : web.nodes) if (!(node instanceof WebRelation))
map.put(node, cloneNodeToWeb(node, w));
for (Pair p : web_relations(web))
w.getRelation(assertNotNull(map.get(p.a)), assertNotNull(map.get(p.b))).addLabels(web.getRelation(p).labels());
return map;
}
static Collection values(Map map) {
return map == null ? emptyList() : map.values();
}
static Collection values(MultiMap mm) {
return mm == null ? emptyList() : concatLists(values(mm.data));
}
static boolean swic(String a, String b) {
return startsWithIgnoreCase(a, b);
}
static boolean swic(String a, String b, Matches m) {
if (!swic(a, b)) return false;
m.m = new String[] {substring(a, l(b))};
return true;
}
static void web_setLabels(WebNode node, List labels) {
if (eq(labels, node.labels)) return;
web_deindex(node);
node.labels = cloneList(labels);
web_index(node);
}
static Web web_dropEmptyRelations(Web web) {
for (WebRelation rel : cloneList(values(web.relations)))
if (empty(rel.labels))
web_removeRelation(rel);
return web;
}
static String trim(String s) { return s == null ? null : s.trim(); }
static String trim(StringBuilder buf) { return buf.toString().trim(); }
static String trim(StringBuffer buf) { return buf.toString().trim(); }
static List web_nodes(Web web) {
return web_nonRelationNodes(web);
}
static List> allPermutations(List l) {
List> out = new ArrayList();
allPermutations_impl(cloneList(l), l(l), out);
return out;
}
static void allPermutations_impl(List l, int n, List> out) {
if (n <= 1) {
ping();
out.add(cloneList(l));
} else for(int i = 0; i < n; i++) {
allPermutations_impl(l, n-1, out);
swapElements(l, n % 2 == 0 ? i : 0, n-1);
}
}
static boolean web_matchNodeLists_debug = false;
static int web_matchNodeLists(List l1, List l2) {
if (l(l1) != l(l2)) return -1000;
int score = 0;
if (empty(l1)) return score;
HashMap map = twoListsToHashMap(l1, l2);
Web web = first(l1).web, web2 = first(l2).web;
// Score nodes
for (int i = 0; i < l(l1); i++) {
WebNode a = l1.get(i), b = l2.get(i);
if (web_isAnythingVariable(a)) continue;
//if (neq(web_labels(a), web_labels(b))) --score;
if (!containsAllIC_lisp(web_labels(b), web_labels(a))) --score;
}
// Score relations
for (WebRelation rel : web_relationObjects(web)) {
WebNode aa = map.get(rel.a), bb = map.get(rel.b);
if (aa == null || bb == null) continue;
WebRelation rel2 = web2.getRelationOpt(aa, bb);
if (web_matchNodeLists_debug)
print("a=" + rel.a + ", b=" + rel.b + ", aa=" + aa + ", bb=" + bb + ", rel2 labels=" + (rel2 == null ? "-" : str(web_labels(rel2)) + ", labels=" + rel.labels));
if (rel2 == null || !containsAllIC_lisp(web_labels(rel2), web_labels(rel)))
--score;
}
return score;
}
static LinkedHashMap twoListsToOrderedMap(List l1, List l2) {
if (l(l1) != l(l2)) throw fail("Differing list size: " + l(l1) + "/" + l(l2));
LinkedHashMap map = new LinkedHashMap();
int n = l(l1);
for (int i = 0; i < n; i++)
map.put(l1.get(i), l2.get(i));
return map;
}
static boolean eq(Object a, Object b) {
return a == b || (a == null ? b == null : b != null && a.equals(b));
}
static void web_addLabels(WebNode node, List labels) {
node.addLabels(labels);
}
static void web_addLabels(WebNode node, WebNode src) {
if (src != null) node.addLabels(src.labels);
}
static void web_addLabels(WebNode node, Object labels) {
if (labels == null) return;
if (labels instanceof String) { web_addLabel(node, (String) labels); return; }
if (labels instanceof Collection) { web_addStrings(node, (Collection) labels); return; }
throw fail("huh: " + className(labels));
}
static Set keys(Map map) {
return map == null ? new HashSet() : map.keySet();
}
static Set keys(Object map) {
return keys((Map) map);
}
static Set keys(MultiSet ms) {
return ms.keySet();
}
static Set keys(MultiMap mm) {
return mm.keySet();
}
static boolean web_hasLabelIC(WebNode node, String text) {
if (node != null) for (Lisp l : node.labels())
if (eqic(text, node.web.unparseLabel(l)))
return true;
return false;
}
static boolean web_hasLabelIC(Pair p, String text) {
return web_hasLabelIC(p.a.web.relation(p), text);
}
static boolean web_hasLabelIC(WebNode a, WebNode b, String text) {
return web_hasLabelIC(a.web.relation(a, b), text);
}
static WebRelation web_reverseRelation(WebRelation rel) {
return rel == null ? null : rel.a.web.relations.get(pair(rel.b, rel.a));
}
static String appendSpaceIfNempty(String s) {
return empty(s) ? unnull(s) : s + " ";
}
static List> web_nonEmptyRelations(Web web) {
List> l = new ArrayList();
for (Pair r : web_relations(web))
if (nempty(web.getRelation(r).labels()))
l.add(r);
return l;
}
static String dateGMT() {
return formatGMTWithOptionalDate_24(now());
}
static String dateGMT(long time) {
return formatGMTWithOptionalDate_24(time);
}
static String n(long l, String name) {
return l + " " + trim(l == 1 ? singular(name) : getPlural(name));
}
static String n(Collection l, String name) {
return n(l(l), name);
}
static String n(Map m, String name) {
return n(l(m), name);
}
static String n(Object[] a, String name) {
return n(l(a), name);
}
static String n(MultiSet ms, String name) {
return n(l(ms), name);
}
static List web_nonRelationNodes(Web web) {
if (web.relations != null)
return listMinusSet(web.nodes, values(web.relations));
List l = new ArrayList();
for (WebNode n : web.nodes)
if (!(n instanceof WebRelation))
l.add(n);
return l;
}
static void pnlIndent(Collection l) {
print_noNewLine(indentx(numberedLines(l)));
}
static void pnlIndent(String indent, Collection l) {
print_noNewLine(indentx(indent, numberedLines(l)));
}
static List collectMethod(Collection c, String methodName) {
return mapMethod(c, methodName);
}
static List collectMethod(String methodName, Collection c) {
return mapMethod(c, methodName);
}
static void web_printRelations(Web web) {
List> relations = web_nonEmptyRelations(web);
if (nempty(relations)) {
for (Pair p : relations) {
WebNode rel = web.getRelation(p);
String lbl = rel.text();
if (l(rel.labels) > 1) lbl += "+";
printIndent(p.a.text() + " -> " + lbl + " -> " + p.b.text());
}
print();
}
}
// undefined color, seems to be all black in practice
static BufferedImage newBufferedImage(int w, int h) {
return new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
}
static BufferedImage newBufferedImage(int w, int h, RGB rgb) {
return newBufferedImage(w, h, toColor(rgb));
}
static BufferedImage newBufferedImage(int w, int h, Color color) {
BufferedImage img = newBufferedImage(w, h);
Graphics2D g = img.createGraphics();
g.setColor(color);
g.fillRect(0, 0, w, h);
return img;
}
static BufferedImage newBufferedImage(Pt p, Color color) {
return newBufferedImage(p.x, p.y, color);
}
static String conceptLanguageToEnglish(String s) {
if (s == null) return null;
try {
return conceptLanguageToEnglish_xyz(s);
} catch (Throwable __e) { _handleException(__e); }
return s;
}
static String conceptLanguageToEnglish(Lisp l) {
return conceptLanguageToEnglish(clUnparse(l));
}
static String clUnparse(Lisp l) {
if (l == null) return "";
return join(" ", (List) concatLists(ll(conceptQuote(l.head)), map("clUnparse_sub", l)));
}
static String clUnparse_sub(Lisp l) {
return l.empty() ? clUnparse(l) : "(" + clUnparse(l) + ")";
}
static List clUnparse(List l) {
return map("clUnparse", l);
}
static A or(A a, A b) {
return a != null ? a : b;
}
static String lispHead(Lisp l) {
return l == null ? null : l.head;
}
static List listMinusSet(Iterable l, Collection stuff) {
if (l == null) return null;
if (empty(stuff)) return asList(l);
Set set = asSet(stuff);
List l2 = new ArrayList();
for (A a : l) if (!set.contains(a)) l2.add(a);
return l2;
}
static List listMinusSet(Iterable l, Collection stuff, Collection stuff2) {
return listMinusSet(listMinusSet(l, stuff), stuff2);
}
static double cal_randomCircleCoord() {
return random(0.2, 0.8);
}
static boolean nempty(Collection c) {
return !empty(c);
}
static boolean nempty(CharSequence s) {
return !empty(s);
}
static boolean nempty(Object[] o) { return !empty(o); }
static boolean nempty(byte[] o) { return !empty(o); }
static boolean nempty(int[] o) { return !empty(o); }
static boolean nempty(Map m) {
return !empty(m);
}
static boolean nempty(Iterator i) {
return i != null && i.hasNext();
}
static boolean nempty(Object o) { return !empty(o); }
static String[] dropFirst(int n, String[] a) {
return drop(n, a);
}
static String[] dropFirst(String[] a) {
return drop(1, a);
}
static Object[] dropFirst(Object[] a) {
return drop(1, a);
}
static List dropFirst(List l) {
return dropFirst(1, l);
}
static List dropFirst(int n, Iterable i) { return dropFirst(n, toList(i)); }
static List dropFirst(Iterable i) { return dropFirst(toList(i)); }
static List dropFirst(int n, List l) {
return n <= 0 ? l : new ArrayList(l.subList(Math.min(n, l.size()), l.size()));
}
static List dropFirst(List l, int n) {
return dropFirst(n, l);
}
static String dropFirst(int n, String s) { return substring(s, n); }
static String dropFirst(String s, int n) { return substring(s, n); }
static String dropFirst(String s) { return substring(s, 1); }
static Set> web_relations(Web web) {
if (web.relations != null)
return keys(web.relations);
LinkedHashSet> l = new LinkedHashSet();
for (WebNode n : web.nodes)
if (n instanceof WebRelation)
l.add(pair(((WebRelation) n).a, ((WebRelation) n).b));
return l;
}
static boolean warn_on = true;
static ThreadLocal> warn_warnings = new ThreadLocal();
static void warn(String s) {
if (warn_on)
print("Warning: " + s);
}
static void warn(String s, List warnings) {
warn(s);
if (warnings != null)
warnings.add(s);
addToCollection(warn_warnings.get(), s);
}
static void copyCAL(CirclesAndLines cal1, CirclesAndLines cal2) {
if (cal1 == cal2) return;
copyList(cal1.circles, cal2.circles);
copyList(cal1.lines, cal2.lines);
copyFields(cal1, cal2, "defaultImageID", "arrowClass", "circleClass", "imgZoom", "imageForUserMadeNodes", "title", "globalID");
copyListeners(cal1, cal2);
}
static String beautifyStructure(String s) {
List tok = javaTokForStructure(s);
structure_addTokenMarkers(tok);
jreplace(tok, "lhm", "");
return join(tok);
}
static A restructure(A a) {
return (A) unstructure(structure(a));
}
static boolean structure_showTiming, structure_checkTokenCount;
static String structure(Object o) {
return structure(o, new structure_Data());
}
static String structure(Object o, structure_Data d) {
StringWriter sw = new StringWriter();
d.out = new PrintWriter(sw);
structure_go(o, d);
String s = str(sw);
if (structure_checkTokenCount) {
print("token count=" + d.n);
assertEquals("token count", l(javaTokC(s)), d.n);
}
return s;
}
static void structure_go(Object o, structure_Data d) {
structure_1(o, d);
while (nempty(d.stack))
popLast(d.stack).run();
}
static void structureToPrintWriter(Object o, PrintWriter out) {
structure_Data d = new structure_Data();
d.out = out;
structure_go(o, d);
}
// leave to false, unless unstructure() breaks
static boolean structure_allowShortening = false;
// info on how to serialize objects of a certain class
static class structure_ClassInfo {
List fields;
Method customSerializer;
boolean special, nullInstances;
}
static class structure_Data {
PrintWriter out;
int stringSizeLimit;
int shareStringsLongerThan = 20;
boolean noStringSharing = false;
IdentityHashMap seen = new IdentityHashMap();
//new BitSet refd;
HashMap strings = new HashMap();
HashSet concepts = new HashSet();
HashMap infoByClass = new HashMap();
HashMap persistenceInfo = new HashMap();
int n; // token count
List stack = new ArrayList();
// append single token
structure_Data append(String token) { out.print(token); ++n; return this; }
structure_Data append(int i) { out.print(i); ++n; return this; }
// append multiple tokens
structure_Data append(String token, int tokCount) { out.print(token); n += tokCount; return this; }
// extend last token
structure_Data app(String token) { out.print(token); return this; }
structure_Data app(int i) { out.print(i); return this; }
}
static void structure_1(final Object o, final structure_Data d) { try {
if (o == null) { d.append("null"); return; }
Class c = o.getClass();
boolean concept = false;
concept = o instanceof Concept;
structure_ClassInfo info = d.infoByClass.get(c);
if (info == null) {
d.infoByClass.put(c, info = new structure_ClassInfo());
if ((info.customSerializer = findMethodNamed(c, "_serialize"))
!= null) info.special = true;
}
List lFields = info.fields;
if (lFields == null) {
// these are never back-referenced (for readability)
if (o instanceof Number) {
PrintWriter out = d.out;
if (o instanceof Integer) { int i = ((Integer) o).intValue(); out.print(i); d.n += i < 0 ? 2 : 1; return; }
if (o instanceof Long) { long l = ((Long) o).longValue(); out.print(l); out.print("L"); d.n += l < 0 ? 2 : 1; return; }
if (o instanceof Short) { short s = ((Short) o).shortValue(); d.append("sh "); out.print(s); d.n += s < 0 ? 2 : 1; return; }
if (o instanceof Float) { d.append("fl ", 2); quoteToPrintWriter(str(o), out); return; }
if (o instanceof Double) { d.append("d(", 3); quoteToPrintWriter(str(o), out); d.append(")"); return; }
if (o instanceof BigInteger) { out.print("bigint("); out.print(o); out.print(")"); d.n += ((BigInteger) o).signum() < 0 ? 5 : 4; return; }
}
if (o instanceof Boolean) {
d.append(((Boolean) o).booleanValue() ? "t" : "f"); return;
}
if (o instanceof Character) {
d.append(quoteCharacter((Character) o)); return;
}
if (o instanceof File) {
d.append("File ").append(quote(((File) o).getPath())); return;
}
// referencable objects follow
Integer ref = d.seen.get(o);
if (o instanceof String && ref == null) ref = d.strings.get((String) o);
if (ref != null) { /*d.refd.set(ref);*/ d.append("t").app(ref); return; }
if (!(o instanceof String))
d.seen.put(o, d.n); // record token number
else {
String s = d.stringSizeLimit != 0 ? shorten((String) o, d.stringSizeLimit) : (String) o;
if (!d.noStringSharing) {
if (d.shareStringsLongerThan == Integer.MAX_VALUE)
d.seen.put(o, d.n);
if (l(s) >= d.shareStringsLongerThan)
d.strings.put(s, d.n);
}
quoteToPrintWriter(s, d.out); d.n++; return;
}
if (o instanceof Set) {
/*O set2 = unwrapSynchronizedSet(o);
if (set2 != o) {
d.append("sync");
o = set2;
} TODO */
if (((Set) o) instanceof TreeSet) {
d.append(isCISet_gen(((Set) o)) ? "ciset" : "treeset");
structure_1(new ArrayList(((Set) o)), d);
return;
}
// assume it's a HashSet or LinkedHashSet
d.append(((Set) o) instanceof LinkedHashSet ? "lhs" : "hashset");
structure_1(new ArrayList(((Set) o)), d);
return;
}
String name = c.getName();
if (o instanceof Collection
&& !startsWith(name, "main$")
/* && neq(name, "main$Concept$RefL") */) {
// it's a list
if (name.equals("java.util.Collections$SynchronizedList")
|| name.equals("java.util.Collections$SynchronizedRandomAccessList")) {
d.append("sync ");
{ structure_1(unwrapSynchronizedList(((List) o)), d); return; }
}
else if (name.equals("java.util.LinkedList")) d.append("ll");
d.append("[");
final int l = d.n;
final Iterator it = ((Collection) o).iterator();
d.stack.add(new Runnable() { public void run() { try {
if (!it.hasNext())
d.append("]");
else {
d.stack.add(this);
if (d.n != l) d.append(", ");
structure_1(it.next(), d);
}
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (!it.hasNext())\r\n d.append(\"]\");\r\n else {\r\n d.sta..."; }});
return;
}
if (o instanceof Map && !startsWith(name, "main$")) {
if (o instanceof LinkedHashMap) d.append("lhm");
else if (o instanceof HashMap) d.append("hm");
else if (o instanceof TreeMap)
d.append(isCIMap_gen(((TreeMap) o)) ? "cimap" : "tm");
else if (name.equals("java.util.Collections$SynchronizedMap")
|| name.equals("java.util.Collections$SynchronizedSortedMap")
|| name.equals("java.util.Collections$SynchronizedNavigableMap")) {
d.append("sync ");
{ structure_1(unwrapSynchronizedMap(((Map) o)), d); return; }
}
d.append("{");
final int l = d.n;
final Iterator it = ((Map) o).entrySet().iterator();
d.stack.add(new Runnable() {
boolean v = false;
Map.Entry e;
public void run() {
if (v) {
d.append("=");
v = false;
d.stack.add(this);
structure_1(e.getValue(), d);
} else {
if (!it.hasNext())
d.append("}");
else {
e = (Map.Entry) it.next();
v = true;
d.stack.add(this);
if (d.n != l) d.append(", ");
structure_1(e.getKey(), d);
}
}
}
});
return;
}
if (c.isArray()) {
if (o instanceof byte[]) {
d.append("ba ").append(quote(bytesToHex((byte[]) o))); return;
}
final int n = Array.getLength(o);
if (o instanceof boolean[]) {
String hex = boolArrayToHex((boolean[]) o);
int i = l(hex);
while (i > 0 && hex.charAt(i-1) == '0' && hex.charAt(i-2) == '0') i -= 2;
d.append("boolarray ").append(n).app(" ").append(quote(substring(hex, 0, i))); return;
}
String atype = "array"/*, sep = ", "*/; // sep is not used yet
if (o instanceof int[]) {
//ret "intarray " + quote(intArrayToHex((int[]) o));
atype = "intarray";
//sep = " ";
} else if (o instanceof double[]) {
atype = "dblarray";
//sep = " ";
}
d.append(atype).append("{");
d.stack.add(new Runnable() {
int i;
public void run() {
if (i >= n)
d.append("}");
else {
d.stack.add(this);
if (i > 0) d.append(", ");
structure_1(Array.get(o, i++), d);
}
}
});
return;
}
if (o instanceof Class) {
d.append("class(", 2).append(quote(((Class) o).getName())).append(")"); return;
}
if (o instanceof Throwable) {
d.append("exception(", 2).append(quote(((Throwable) o).getMessage())).append(")"); return;
}
if (o instanceof BitSet) {
BitSet bs = (BitSet) o;
d.append("bitset{", 2);
int l = d.n;
for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
if (d.n != l) d.append(", ");
d.append(i);
}
d.append("}"); return;
}
// Need more cases? This should cover all library classes...
if (name.startsWith("java.") || name.startsWith("javax.")) {
d.append("j ").append(quote(str(o))); return; // Hm. this is not unstructure-able
}
if (o instanceof Lisp) {
d.append("l(", 2);
final Lisp lisp = (Lisp) o;
structure_1(lisp.head, d);
final Iterator it = lisp.args == null ? emptyIterator() : lisp.args.iterator();
d.stack.add(new Runnable() { public void run() { try {
if (!it.hasNext())
d.append(")");
else {
d.stack.add(this);
d.append(", ");
structure_1(it.next(), d);
}
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (!it.hasNext())\r\n d.append(\")\");\r\n else {\r\n ..."; }});
return;
}
/*if (name.equals("main$Lisp")) {
fail("lisp not supported right now");
}*/
if (info.special) {
if (info.customSerializer != null) {
// custom serialization (_serialize method)
Object o2 = invokeMethod(info.customSerializer, o);
d.append("cu ");
String shortName = dropPrefix("main$", name);
d.append(shortName);
d.out.append(' ');
structure_1(o2, d);
return;
} else
if (info.nullInstances) { d.append("null"); return; }
else throw fail("unknown special type");
}
String dynName = shortDynamicClassName(o);
if (concept && !d.concepts.contains(dynName)) {
d.concepts.add(dynName);
d.append("c ");
}
// serialize an object with fields.
// first, collect all fields and values in fv.
TreeSet fields = new TreeSet(new Comparator() {
public int compare(Field a, Field b) {
return stdcompare(a.getName(), b.getName());
}
});
Class cc = c;
while (cc != Object.class) {
for (Field field : getDeclaredFields_cached(cc)) {
String fieldName = field.getName();
if (fieldName.equals("_persistenceInfo"))
d.persistenceInfo.put(c, field);
if ((field.getModifiers() & (java.lang.reflect.Modifier.STATIC | java.lang.reflect.Modifier.TRANSIENT)) != 0)
continue;
fields.add(field);
// put special cases here...?
}
cc = cc.getSuperclass();
}
// TODO: S fieldOrder = getOpt(c, "_fieldOrder");
lFields = asList(fields);
// Render this$1 first because unstructure needs it for constructor call.
int n = l(lFields);
for (int i = 0; i < n; i++) {
Field f = lFields.get(i);
if (f.getName().equals("this$1")) {
lFields.remove(i);
lFields.add(0, f);
break;
}
}
info.fields = lFields;
} // << if (lFields == null)
else { // ref handling for lFields != null
Integer ref = d.seen.get(o);
if (ref != null) { /*d.refd.set(ref);*/ d.append("t").app(ref); return; }
d.seen.put(o, d.n); // record token number
}
Field persistenceInfoField = (Field) (d.persistenceInfo.get(c));
Map persistenceInfo = persistenceInfoField == null ? null : (Map) persistenceInfoField.get(o);
LinkedHashMap fv = new LinkedHashMap();
for (Field f : lFields) {
Object value;
try {
value = f.get(o);
} catch (Exception e) {
value = "?";
}
if (value != null && (persistenceInfo == null
|| !Boolean.FALSE.equals(persistenceInfo.get(f.getName()))))
fv.put(f.getName(), value);
}
String name = c.getName();
String shortName = dropPrefix("main$", name);
if (startsWithDigit(shortName)) shortName = name; // for anonymous classes
// Now we have fields & values. Process fieldValues if it's a DynamicObject.
// omit field "className" if equal to class's name
if (concept && eq(fv.get("className"), shortName))
fv.remove("className");
if (o instanceof DynamicObject) {
putAll(fv, (Map) fv.get("fieldValues"));
fv.remove("fieldValues");
shortName = shortDynamicClassName(o);
fv.remove("className");
}
String singleField = fv.size() == 1 ? first(fv.keySet()) : null;
d.append(shortName);
d.n += countDots(shortName)*2; // correct token count
final int l = d.n;
final Iterator it = fv.entrySet().iterator();
d.stack.add(new Runnable() { public void run() { try {
if (!it.hasNext()) {
if (d.n != l)
d.append(")");
} else {
Map.Entry e = (Map.Entry) it.next();
d.append(d.n == l ? "(" : ", ");
d.append((String) e.getKey()).append("=");
d.stack.add(this);
structure_1(e.getValue(), d);
}
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (!it.hasNext()) {\r\n if (d.n != l)\r\n d.append(\")\");\r\n } else..."; }});
} catch (Exception __e) { throw rethrow(__e); } }
static List ll(A... a) {
ArrayList l = new ArrayList(a.length);
if (a != null) for (A x : a) l.add(x);
return l;
}
// c = Component or something implementing swing()
static JComponent wrap(Object swingable) {
return _recordNewSwingComponent(wrap_2(swingable));
}
static JComponent wrap_2(Object swingable) {
if (swingable == null) return null;
JComponent c;
if (swingable instanceof Component) c = componentToJComponent(((Component) swingable));
else c = componentToJComponent((Component) callOpt(swingable, "swing"));
if (c instanceof JTable || c instanceof JList
|| c instanceof JTextArea || c instanceof JEditorPane
|| c instanceof JTextPane || c instanceof JTree)
return jscroll(c);
return c == null ? jlabel(str(swingable)) : c;
}
static Map caseInsensitiveSynchroMap() {
return (Map) synchroMap(caseInsensitiveMap());
}
static CirclesAndLines cal_unstructure(String s) {
return (CirclesAndLines) unstructure(s);
}
static volatile PersistableThrowable _handleException_lastException;
static List _handleException_onException = synchroList(ll("printStackTrace2"));
static void _handleException(Throwable e) {
_handleException_lastException = persistableThrowable(e);
Throwable e2 = innerException(e);
if (e2.getClass() == RuntimeException.class && eq(e2.getMessage(), "Thread cancelled.") || e2 instanceof InterruptedException)
return;
for (Object f : cloneList(_handleException_onException)) try {
callF(f, e);
} catch (Throwable e3) {
printStackTrace2(e3); // not using pcall here - it could lead to endless loops
}
}
// Substance
// Trident (required by Substance)
static void enableSubstance_impl(final String skinName) {
if (headless()) return;
{ swing(new Runnable() { public void run() { try {
if (!substanceLookAndFeelEnabled())
enableSubstance_impl_2(skinName);
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (!substanceLookAndFeelEnabled())\r\n enableSubstance_impl_2(skinName);"; }}); }
}
static void enableSubstance_impl_2(String skinName) { try {
boolean wasEnabled = substanceLookAndFeelEnabled();
ClassLoader cl = main.class.getClassLoader();
UIManager.getDefaults().put("ClassLoader", cl);
Thread.currentThread().setContextClassLoader(cl);
String skinClassName = "org.pushingpixels.substance.api.skin." + addSuffix(skinName, "Skin");
SubstanceSkin skin = (SubstanceSkin) nuObject(cl.loadClass(skinClassName));
SubstanceLookAndFeel.setSkin(skin);
JFrame.setDefaultLookAndFeelDecorated(true);
updateLookAndFeelOnAllWindows_noRenew();
if (!wasEnabled) renewConsoleFrame();
if (substanceLookAndFeelEnabled()) {
//print("Substance L&F enabled.");
} else
print("Could not enable Substance L&F?");
} catch (Exception __e) { throw rethrow(__e); } }
static int iteratorCount_int_close(Iterator i) { try {
int n = 0;
if (i != null) while (i.hasNext()) { i.next(); ++n; }
if (i instanceof AutoCloseable) ((AutoCloseable) i).close();
return n;
} catch (Exception __e) { throw rethrow(__e); } }
static Object call(Object o) {
return callF(o);
}
// varargs assignment fixer for a single string array argument
static Object call(Object o, String method, String[] arg) {
return call(o, method, new Object[] {arg});
}
static Object call(Object o, String method, Object... args) {
//ret call_cached(o, method, args);
return call_withVarargs(o, method, args);
}
static RuntimeException fail() { throw new RuntimeException("fail"); }
static RuntimeException fail(Throwable e) { throw asRuntimeException(e); }
static RuntimeException fail(Object msg) { throw new RuntimeException(String.valueOf(msg)); }
static RuntimeException fail(String msg) { throw new RuntimeException(msg == null ? "" : msg); }
static RuntimeException fail(String msg, Throwable innerException) { throw new RuntimeException(msg, innerException); }
static String getClassName(Object o) {
return o == null ? "null" : o instanceof Class ? ((Class) o).getName() : o.getClass().getName();
}
static List toLinesFullTrim_java(String text) {
// TODO: shouldn't it be tlft(javaDropComments(text))?
return tlft(joinLines(map("javaDropComments",tlft(text))));
}
static List map(Iterable l, Object f) { return map(f, l); }
static List map(Object f, Iterable l) {
List x = emptyList(l);
if (l != null) for (Object o : l)
x.add(callF(f, o));
return x;
}
static List map(Iterable l, F1 f) { return map(f, l); }
static List map(F1 f, Iterable l) {
List x = emptyList(l);
if (l != null) for (A o : l)
x.add(callF(f, o));
return x;
}
static List map(IF1 f, Iterable l) { return map(l, f); }
static List map(Iterable l, IF1 f) {
List x = emptyList(l);
if (l != null) for (A o : l)
x.add(f.get(o));
return x;
}
static List map(IF1 f, A[] l) { return map(l, f); }
static List map(A[] l, IF1 f) {
List x = emptyList(l);
if (l != null) for (A o : l)
x.add(f.get(o));
return x;
}
static List map(Object f, Object[] l) { return map(f, asList(l)); }
static List map(Object[] l, Object f) { return map(f, l); }
static List map(Object f, Map map) {
return map(map, f);
}
// map: func(key, value) -> list element
static List map(Map map, Object f) {
List x = new ArrayList();
if (map != null) for (Object _e : map.entrySet()) {
Map.Entry e = (Map.Entry) _e;
x.add(callF(f, e.getKey(), e.getValue()));
}
return x;
}
static List map(Map map, IF2 f) {
return map(map, (Object) f);
}
static Web webFromCALStructure(String structure) {
return calToWeb((CirclesAndLines) unstructure(structure));
}
static String getType(Object o) {
return getClassName(o);
}
static long getFileSize(String path) {
return path == null ? 0 : new File(path).length();
}
static long getFileSize(File f) {
return f == null ? 0 : f.length();
}
static Map newWeakHashMap() {
return _registerWeakMap(synchroMap(new WeakHashMap()));
}
// TODO: test if android complains about this
static boolean isAWTThread() {
if (isAndroid()) return false;
if (isHeadless()) return false;
return isAWTThread_awt();
}
static boolean isAWTThread_awt() {
return SwingUtilities.isEventDispatchThread();
}
static boolean isTrue(Object o) {
if (o instanceof Boolean)
return ((Boolean) o).booleanValue();
if (o == null) return false;
if (o instanceof ThreadLocal) // TODO: remove this
return isTrue(((ThreadLocal) o).get());
throw fail(getClassName(o));
}
static void failIfUnlicensed() {
assertTrue("license off", licensed());
}
static Thread currentThread() {
return Thread.currentThread();
}
static Iterator emptyIterator() {
return Collections.emptyIterator();
}
static Object pcallFunction(Object f, Object... args) {
try { return callFunction(f, args); } catch (Throwable __e) { _handleException(__e); }
return null;
}
static Web calToWeb(CirclesAndLines cal) {
Web web = new Web();
web.globalID = cal.globalID;
web_useCLParse(web, false);
web.title = cal.title;
web.created = cal.created;
HashMap map = new HashMap();
for (Circle c : cal.circles) {
WebNode node = web.newNode(c.text);
copyFields(c, node, "x", "y");
node.visInfo(c.quickvis);
map.put(c, node);
}
for (Line l : cal.lines) {
WebNode rel = web.getRelation(assertNotNull(map.get(l.a)), assertNotNull(map.get(l.b)));
rel.addLabel(l.text);
}
return web;
}
static Class javax() {
return getJavaX();
}
static List buttonsInGroup(ButtonGroup g) {
if (g == null) return ll();
return asList(g.getElements());
}
static ArrayList asList(A[] a) {
return a == null ? new ArrayList () : new ArrayList (Arrays.asList(a));
}
static ArrayList asList(int[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (int i : a) l.add(i);
return l;
}
static ArrayList asList(float[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (float i : a) l.add(i);
return l;
}
static ArrayList asList(double[] a) {
if (a == null) return null;
ArrayList l = emptyList(a.length);
for (double i : a) l.add(i);
return l;
}
static ArrayList asList(Iterable s) {
if (s instanceof ArrayList) return (ArrayList) s;
ArrayList l = new ArrayList();
if (s != null)
for (A a : s)
l.add(a);
return l;
}
static ArrayList asList(Producer p) {
ArrayList l = new ArrayList();
A a;
if (p != null) while ((a = p.next()) != null)
l.add(a);
return l;
}
static ArrayList asList(Enumeration e) {
ArrayList l = new ArrayList();
if (e != null)
while (e.hasMoreElements())
l.add(e.nextElement());
return l;
}
static void swingAndWait(Runnable r) { try {
if (isAWTThread())
r.run();
else
EventQueue.invokeAndWait(addThreadInfoToRunnable(r));
} catch (Exception __e) { throw rethrow(__e); } }
static Object swingAndWait(final Object f) {
if (isAWTThread())
return callF(f);
else {
final Var result = new Var();
swingAndWait(new Runnable() { public void run() { try {
result.set(callF(f));
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "result.set(callF(f));"; }});
return result.get();
}
}
static Field getOpt_findField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field))
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static Field makeAccessible(Field f) {
try {
f.setAccessible(true);
} catch (Throwable e) {
// Note: The error reporting only works with Java VM option --illegal-access=deny
vmBus_send("makeAccessible_error",e, f);
}
return f;
}
static Method makeAccessible(Method m) {
try {
m.setAccessible(true);
} catch (Throwable e) {
vmBus_send("makeAccessible_error",e, m);
}
return m;
}
static Constructor makeAccessible(Constructor c) {
try {
c.setAccessible(true);
} catch (Throwable e) {
vmBus_send("makeAccessible_error",e, c);
}
return c;
}
static RuntimeException asRuntimeException(Throwable t) {
if (t instanceof Error)
_handleError((Error) t);
return t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
static boolean isInstance(Class type, Object arg) {
return type.isInstance(arg);
}
// x = names and components interleaving.
// or just components.
// or just names.
// also, first element can be index of tab to open at start
// also, SUPER short demo syntax: jtabs(3)
// also, you can pass a Collection containing the elements
static JTabbedPane jtabs(Object... x) {
return fillJTabs(swingNu(JTabbedPane.class), x);
}
static JFrame showFrame() {
return makeFrame();
}
static JFrame showFrame(Object content) {
return makeFrame(content);
}
static JFrame showFrame(String title) {
return makeFrame(title);
}
static JFrame showFrame(String title, Object content) {
return makeFrame(title, content);
}
static JFrame showFrame(final JFrame f) {
if (f != null) { swing(new Runnable() { public void run() { try {
if (frameTooSmall(f)) frameStandardSize(f);
if (!f.isVisible()) f.setVisible(true); // XXX
if (f.getState() == Frame.ICONIFIED) f.setState(Frame.NORMAL);
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (frameTooSmall(f)) frameStandardSize(f);\r\n if (!f.isVisible()) f.setVis..."; }}); }
return f;
}
// make or update frame
static JFrame showFrame(String title, Object content, JFrame frame) {
if (frame == null)
return showFrame(title, content);
else {
frame.setTitle(title);
setFrameContents(frame, content);
return frame;
}
}
static Component addToWindow(final Component c, final Component toAdd) {
if (toAdd != null) { swing(new Runnable() { public void run() { try {
JFrame frame = getFrame(c);
if (frame == null) return;
setContentPane(frame, centerAndSouth(frame.getContentPane(), toAdd));
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "JFrame frame = getFrame(c);\r\n if (frame == null) return;\r\n setContentPa..."; }}); }
return c;
}
static boolean boolOptParam(ThreadLocal tl) {
return isTrue(optPar(tl));
}
// defaults to false
static boolean boolOptParam(Object[] __, String name) {
return isTrue(optParam(__, name));
}
static boolean boolOptParam(String name, Object[] __) {
return boolOptParam(__, name);
}
static boolean boolOptParam(String name, Map __) {
return isTrue(optPar(name, __));
}
static JCheckBox jcheckbox() {
return jCheckBox();
}
static JCheckBox jcheckbox(boolean checked) {
return jCheckBox(checked);
}
static JCheckBox jcheckbox(String text, boolean checked) {
return jCheckBox(text, checked);
}
static JCheckBox jcheckbox(String text) {
return jCheckBox(text);
}
// keep old state
static JCheckBox jcheckbox(JCheckBox cb, String text) {
return jcheckbox(text, isChecked(cb));
}
static JButton jbutton(String text, Object action) {
return newButton(text, action);
}
// button without action
static JButton jbutton(String text) {
return newButton(text, null);
}
/*static JButton jbutton(BufferedImage img, O action) {
ret setButtonImage(img, jbutton("", action));
}*/
static JButton jbutton(Action action) {
return swingNu(JButton.class, action);
}
static void cal_scramble(CirclesAndLines cal) {
if (cal == null) return;
for (Circle c : cal.circles) {
c.x = cal_randomCircleCoord();
c.y = cal_randomCircleCoord();
}
pcallF(cal.onFullLayoutChange);
}
static int updateCanvas_retryInterval = 50;
// if makeImg returns null, it is recalled after a delay
static void updateCanvas(final Canvas canvas, final Object makeImg) {
swingNowOrLater(new Runnable() { public void run() { try {
if (canvas.updating || canvas.getWidth() == 0) return;
canvas.updating = true;
try {
BufferedImage img = asBufferedImage(callF(makeImg, canvas.getWidth(), canvas.getHeight()));
if (img != null) {
canvas.setImage(img);
canvas.updating = false;
} else
awtLater(updateCanvas_retryInterval, new Runnable() { public void run() { try {
canvas.updating = false;
updateCanvas(canvas, makeImg);
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "canvas.updating = false;\r\n updateCanvas(canvas, makeImg);"; }});
} catch (Throwable e) {
canvas.updating = false;
throw rethrow(e);
}
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (canvas.updating || canvas.getWidth() == 0) return;\r\n canvas.updating =..."; }});
}
static void updateCanvas(final Canvas canvas) {
if (canvas != null) canvas.update();
}
static JSpinner setSpinnerStepSize(int stepSize, JSpinner s) {
callOpt(castOpt(s.getModel(), SpinnerNumberModel.class), "setStepSize", stepSize);
return s;
}
static JSpinner jspinner(int value) {
return jSpinner(value);
}
static JSpinner jspinner(int value, int min, int max) {
return jSpinner(value, min, max);
}
static int iround(double d) {
return (int) Math.round(d);
}
static int iround(Number n) {
return iround(toDouble(n));
}
static JPanel jcenteredline(final Component... components) {
//ret new CenteredLine(components);
return swing(new F0() { JPanel get() { try { return jFullCenter(hstackWithSpacing(components)); } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "ret jFullCenter(hstackWithSpacing(components));"; }});
}
static JPanel jcenteredline(List components) {
return jcenteredline(asArray(Component.class, components));
}
static Timer awtCalcEvery2(Component component, int delay, final Object runnable) {
return awtCalcEvery2(component, delay, delay, runnable);
}
static Timer awtCalcEvery2(Component component, int delay, int firstDelay, final Object runnable) {
final SingleThread thread = new SingleThread();
return installTimer(componentToJComponent(component), delay, firstDelay, new Runnable() {
public void run() {
if (!licensed()) return;
thread.go(runnable);
}
});
}
static boolean isChecked(final JCheckBox checkBox) {
return checkBox != null && (boolean) swing(new F0() { Boolean get() { try { return checkBox.isSelected(); } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "ret checkBox.isSelected();"; }});
}
static boolean isChecked(final JCheckBoxMenuItem mi) {
return mi != null && (boolean) swing(new F0() { Boolean get() { try { return mi.isSelected(); } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "ret mi.isSelected();"; }});
}
static int intFromSpinner(JSpinner s) {
return toInt(s.getValue());
}
static void calCenterStepwise(CirclesAndLines cal, double speed) {
DoublePt c = calAverageCenter(cal);
if (c == null) return;
calTranslate(cal, (0.5-c.x)*speed, (0.5-c.y)*speed);
cal.translate = null;
}
static Object nuObject(String className, Object... args) { try {
return nuObject(classForName(className), args);
} catch (Exception __e) { throw rethrow(__e); } }
// too ambiguous - maybe need to fix some callers
/*static O nuObject(O realm, S className, O... args) {
ret nuObject(_getClass(realm, className), args);
}*/
static A nuObject(Class c, Object... args) { try {
if (args.length == 0) return nuObjectWithoutArguments(c); // cached!
Constructor m = nuObject_findConstructor(c, args);
makeAccessible(m);
return (A) m.newInstance(args);
} catch (Exception __e) { throw rethrow(__e); } }
static Constructor nuObject_findConstructor(Class c, Object... args) {
for (Constructor m : c.getDeclaredConstructors()) {
if (!nuObject_checkArgs(m.getParameterTypes(), args, false))
continue;
return m;
}
throw fail("Constructor " + c.getName() + getClasses(args) + " not found"
+ (args.length == 0 && (c.getModifiers() & java.lang.reflect.Modifier.STATIC) == 0 ? " - hint: it's a non-static class!" : ""));
}
static boolean nuObject_checkArgs(Class[] types, Object[] args, boolean debug) {
if (types.length != args.length) {
if (debug)
System.out.println("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++)
if (!(args[i] == null || isInstanceX(types[i], args[i]))) {
if (debug)
System.out.println("Bad parameter " + i + ": " + args[i] + " vs " + types[i]);
return false;
}
return true;
}
static JTextPane centerTextPane(JTextPane p) {
//S text = getText(p);
textPane_paragraphAttributes(p, style_center());
//setText(p, text);
return p;
}
static JTextPane jtextpane() {
return jenableUndoRedo(swing(new F0() { JTextPane get() { try { return new JTextPane(); } catch (Exception __e) { throw rethrow(__e); } }
public String toString() { return "ret new JTextPane;"; }}));
}
static JTextPane jtextpane(String text, AttributeSet attributes) {
JTextPane pane = jtextpane();
pane.setCharacterAttributes(attributes, true);
pane.setText(text);
return pane;
}
static JTextPane jtextpane(String text) {
return jtextpane(text, style_normal());
}
static BufferedImage loadImage2(String snippetIDOrURL) {
return loadBufferedImage(snippetIDOrURL);
}
static BufferedImage loadImage2(File file) {
return loadBufferedImage(file);
}
static void paintTiledBackground(Component c, Graphics g, BufferedImage image) {
int width = c.getWidth();
int height = c.getHeight();
for (int x = 0; x < width; x += image.getWidth())
for (int y = 0; y < height; y += image.getHeight())
g.drawImage(image, x, y, c);
}
static A jtransparent_recursive(A a) {
if (a instanceof JPanel) {
((JPanel) a).setOpaque(false);
for (Component c : getSwingChildren(a))
jtransparent_recursive(c);
}
return a;
}
static Map loadFont_cached_cache = new HashMap();
static synchronized Font loadFont_cached(String snippetID) { try {
snippetID = formatSnippetID(snippetID);
Font f = loadFont_cached_cache.get(snippetID);
if (f == null)
loadFont_cached_cache.put(snippetID, f = loadFont(snippetID, 12f));
return f;
} catch (Exception __e) { throw rethrow(__e); } }
static synchronized Font loadFont_cached(String snippetID, float size) { try {
return loadFont_cached(snippetID).deriveFont(size);
} catch (Exception __e) { throw rethrow(__e); } }
static void disposeWindow(final Window window) {
if (window != null) { swing(new Runnable() { public void run() { try {
window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING)); // call listeners
myFrames_list.remove(window);
window.dispose();
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING)); //..."; }}); }
}
static void disposeWindow(final Component c) {
disposeWindow(getWindow(c));
}
static void disposeWindow(Object o) {
if (o != null) disposeWindow(((Component) o));
}
static void disposeWindow() {
disposeWindow(heldInstance(Component.class));
}
static Boolean isHeadless_cache;
static boolean isHeadless() {
if (isHeadless_cache != null) return isHeadless_cache;
if (isAndroid()) return isHeadless_cache = true;
if (GraphicsEnvironment.isHeadless()) return isHeadless_cache = true;
// Also check if AWT actually works.
// If DISPLAY variable is set but no X server up, this will notice.
try {
SwingUtilities.isEventDispatchThread();
return isHeadless_cache = false;
} catch (Throwable e) { return isHeadless_cache = true; }
}
static int imageIcon_cacheSize = 10;
static boolean imageIcon_verbose = false;
static Map imageIcon_cache;
static Lock imageIcon_lock = lock();
static ThreadLocal imageIcon_fixGIF = new ThreadLocal();
// not going through BufferedImage preserves animations
static ImageIcon imageIcon(String imageID) { try {
if (imageID == null) return null;
Lock __0 = imageIcon_lock; lock(__0); try {
if (imageIcon_cache == null)
imageIcon_cache = new MRUCache(imageIcon_cacheSize);
imageID = fsI(imageID);
ImageIcon ii = imageIcon_cache.get(imageID);
if (ii == null) {
if (imageIcon_verbose) print("Loading image icon: " + imageID);
File f = loadBinarySnippet(imageID);
Boolean b = imageIcon_fixGIF.get();
if (!isFalse(b))
ii = new ImageIcon(loadBufferedImageFixingGIFs(f));
else
ii = new ImageIcon(f.toURI().toURL());
} else
imageIcon_cache.remove(imageID); // move to front of cache on access
imageIcon_cache.put(imageID, ii);
return ii;
} finally { unlock(__0); } } catch (Exception __e) { throw rethrow(__e); } }
// doesn't fix GIFs
static ImageIcon imageIcon(File f) { try {
return new ImageIcon(f.toURI().toURL());
} catch (Exception __e) { throw rethrow(__e); } }
static ImageIcon imageIcon(Image img) {
return new ImageIcon(img);
}
static ImageIcon imageIcon(RGBImage img) {
return imageIcon(img.getBufferedImage());
}
static JWindow showInTopRightCorner(Component c) {
return swing(() -> {
JWindow w = new JWindow();
w.add(c);
w.pack();
moveToTopRightCorner(w);
w.setVisible(true);
return w;
});
}
static A onClick(final A c, final Object runnable) {
if (c != null) { swing(new Runnable() { public void run() { try {
c.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
callF(runnable, e);
}
});
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "c.addMouseListener(new MouseAdapter {\r\n public void mouseClicked(MouseEv..."; }}); }
return c;
}
// re-interpreted for buttons
static void onClick(JButton btn, final Object runnable) {
onEnter(btn, runnable);
}
static A disposeWindowAfter(int delay, final A w) {
if (w != null)
swingLater(delay, new Runnable() { public void run() { try {
w.dispose();
} catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "w.dispose();"; }});
return w;
}
static A disposeWindowAfter(A w, double seconds) {
return disposeWindowAfter(toMS_int(seconds), w);
}
static A disposeWindowAfter(double seconds, A w) {
return disposeWindowAfter(w, seconds);
}
static Object getOpt(Object o, String field) {
return getOpt_cached(o, field);
}
static Object getOpt(String field, Object o) {
return getOpt_cached(o, field);
}
static Object getOpt_raw(Object o, String field) { try {
Field f = getOpt_findField(o.getClass(), field);
if (f == null) return null;
makeAccessible(f);
return f.get(o);
} catch (Exception __e) { throw rethrow(__e); } }
// access of static fields is not yet optimized
static Object getOpt(Class c, String field) { try {
if (c == null) return null;
Field f = getOpt_findStaticField(c, field);
if (f == null) return null;
makeAccessible(f);
return f.get(null);
} catch (Exception __e) { throw rethrow(__e); } }
static Field getOpt_findStaticField(Class c, String field) {
Class _c = c;
do {
for (Field f : _c.getDeclaredFields())
if (f.getName().equals(field) && (f.getModifiers() & java.lang.reflect.Modifier.STATIC) != 0)
return f;
_c = _c.getSuperclass();
} while (_c != null);
return null;
}
static Map newDangerousWeakHashMap() {
return _registerDangerousWeakMap(synchroMap(new WeakHashMap()));
}
// initFunction: voidfunc(Map) - is called initially, and after clearing the map
static Map newDangerousWeakHashMap(Object initFunction) {
return _registerDangerousWeakMap(synchroMap(new WeakHashMap()), initFunction);
}
static Object callMCWithVarArgs(String method, Object... args) {
return call_withVarargs(mc(), method, args);
}
static Object invokeMethod(Method m, Object o, Object... args) { try {
try {
return m.invoke(o, args);
} catch (InvocationTargetException e) {
throw rethrow(getExceptionCause(e));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(e.getMessage() + " - was calling: " + m + ", args: " + joinWithSpace(classNames(args)));
}
} catch (Exception __e) { throw rethrow(__e); } }
static boolean call_checkArgs(Method m, Object[] args, boolean debug) {
Class[] types = m.getParameterTypes();
if (types.length != args.length) {
if (debug)
print("Bad parameter length: " + args.length + " vs " + types.length);
return false;
}
for (int i = 0; i < types.length; i++) {
Object arg = args[i];
if (!(arg == null ? !types[i].isPrimitive()
: isInstanceX(types[i], arg))) {
if (debug)
print("Bad parameter " + i + ": " + arg + " vs " + types[i]);
return false;
}
}
return true;
}
static int indexOf(List l, A a, int startIndex) {
if (l == null) return -1;
int n = l(l);
for (int i = startIndex; i < n; i++)
if (eq(l.get(i), a))
return i;
return -1;
}
static int indexOf(List l, int startIndex, A a) {
return indexOf(l, a, startIndex);
}
static int indexOf(List l, A a) {
if (l == null) return -1;
return l.indexOf(a);
}
static int indexOf(String a, String b) {
return a == null || b == null ? -1 : a.indexOf(b);
}
static int indexOf(String a, String b, int i) {
return a == null || b == null ? -1 : a.indexOf(b, i);
}
static int indexOf(String a, char b) {
return a == null ? -1 : a.indexOf(b);
}
static int indexOf(String a, int i, char b) {
return indexOf(a, b, i);
}
static int indexOf(String a, char b, int i) {
return a == null ? -1 : a.indexOf(b, i);
}
static int indexOf(String a, int i, String b) {
return a == null || b == null ? -1 : a.indexOf(b, i);
}
static int indexOf(A[] x, A a) {
int n = l(x);
for (int i = 0; i < n; i++)
if (eq(x[i], a))
return i;
return -1;
}
static void rotateStringBuffer(StringBuffer buf, int max) { try {
if (buf == null) return;
synchronized(buf) {
if (buf.length() <= max) return;
try {
int newLength = max/2;
int ofs = buf.length()-newLength;
String newString = buf.substring(ofs);
buf.setLength(0);
buf.append("[...] ").append(newString);
} catch (Exception e) {
buf.setLength(0);
}
buf.trimToSize();
}
} catch (Exception __e) { throw rethrow(__e); } }
static void rotateStringBuilder(StringBuilder buf, int max) { try {
if (buf == null) return;
synchronized(buf) {
if (buf.length() <= max) return;
try {
int newLength = max/2;
int ofs = buf.length()-newLength;
String newString = buf.substring(ofs);
buf.setLength(0);
buf.append("[...] ").append(newString);
} catch (Exception e) {
buf.setLength(0);
}
buf.trimToSize();
}
} catch (Exception __e) { throw rethrow(__e); } }
static WebNode cloneNodeToWeb(WebNode node, Web w) {
WebNode n = w.newNode();
n.addLabels(web_labels(node));
copyFields(node, n, "x", "y");
return n;
}
static A assertNotNull(A a) {
assertTrue(a != null);
return a;
}
static A assertNotNull(String msg, A a) {
assertTrue(msg, a != null);
return a;
}
static ArrayList emptyList() {
return new ArrayList();
//ret Collections.emptyList();
}
static ArrayList emptyList(int capacity) {
return new ArrayList(max(0, capacity));
}
// Try to match capacity
static ArrayList emptyList(Iterable l) {
return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList();
}
static ArrayList emptyList(Object[] l) {
return emptyList(l(l));
}
// get correct type at once
static ArrayList emptyList(Class c) {
return new ArrayList();
}
static List concatLists(Collection ... lists) {
List l = new ArrayList();
if (lists != null) for (Collection list : lists)
if (list != null)
l.addAll(list);
return l;
}
static List concatLists(Collection> lists) {
List l = new ArrayList();
if (lists != null) for (Collection list : lists)
if (list != null)
l.addAll(list);
return l;
}
static boolean startsWithIgnoreCase(String a, String b) {
return regionMatchesIC(a, 0, b, 0, b.length());
}
static String substring(String s, int x) {
return substring(s, x, strL(s));
}
static String substring(String s, int x, int y) {
if (s == null) return null;
if (x < 0) x = 0;
if (x >= s.length()) return "";
if (y < x) y = x;
if (y > s.length()) y = s.length();
return s.substring(x, y);
}
static void web_deindex(WebNode n) {
MultiMap index = n.web.index;
if (index != null)
for (Lisp label : n.labels())
index.remove(label, n);
}
static ArrayList cloneList(Iterable l) {
return l instanceof Collection ? cloneList((Collection) l) : asList(l);
}
static ArrayList cloneList(Collection l) {
if (l == null) return new ArrayList();
synchronized(collectionMutex(l)) {
return new ArrayList (l);
}
}
static void web_index(WebNode n) {
MultiMap index = n.web.index;
if (index != null)
for (Lisp label : n.labels())
index.setPut(label, n);
}
static void web_removeRelation(WebRelation rel) {
if (rel == null || rel.web == null) return;
rel.web.removeRelation(rel.a, rel.b);
}
static void swapElements(List l, int i, int j) {
if (i == j) return;
Object o = l.get(i);
l.set(i, l.get(j));
l.set(j, o);
}
static HashMap twoListsToHashMap(List l1, List l2) {
if (l(l1) != l(l2)) throw fail("Differing list size: " + l(l1) + "/" + l(l2));
HashMap map = new HashMap();
int n = l(l1);
for (int i = 0; i < n; i++)
map.put(l1.get(i), l2.get(i));
return map;
}
static HashMap twoListsToHashMap(A[] l1, A[] l2) {
return twoListsToHashMap(Arrays.asList(l1), Arrays.asList(l2));
}
static boolean web_isAnythingVariable(WebNode n) {
return endsWithIC(web_text(n), " [Anything]");
}
static boolean containsAllIC_lisp(Collection a, Collection b) {
for (Lisp o : b)
if (!containsLispIC(a, o))
return false;
return true;
}
static List web_labels(WebNode n) {
return n == null ? null : n.labels();
}
static String str(Object o) {
return o == null ? "null" : o.toString();
}
static String str(char[] c) {
return new String(c);
}
static void web_addLabel(WebNode node, String label) {
node.addLabel(label);
}
static void web_addStrings(WebNode node, Collection labels) {
node.addStrings(labels);
}
static String className(Object o) {
return getClassName(o);
}
static boolean eqic(String a, String b) {
if ((a == null) != (b == null)) return false;
if (a == null) return true;
return a.equalsIgnoreCase(b);
}
static boolean eqic(char a, char b) {
if (a == b) return true;
char u1 = Character.toUpperCase(a);
char u2 = Character.toUpperCase(b);
if (u1 == u2) return true;
return Character.toLowerCase(u1) == Character.toLowerCase(u2);
}
static String unnull(String s) {
return s == null ? "" : s;
}
static Collection unnull(Collection l) {
return l == null ? emptyList() : l;
}
static List unnull(List l) {
return l == null ? emptyList() : l;
}
static Map unnull(Map l) {
return l == null ? emptyMap() : l;
}
static Iterable unnull(Iterable i) {
return i == null ? emptyList() : i;
}
static A[] unnull(A[] a) {
return a == null ? (A[]) new Object[0] : a;
}
static BitSet unnull(BitSet b) {
return b == null ? new BitSet() : b;
}
static Pt unnull(Pt p) {
return p == null ? new Pt() : p;
}
//ifclass Symbol
static Pair unnull(Pair p) {
return p != null ? p : new Pair(null, null);
}
static String formatGMTWithOptionalDate_24(long time) {
SimpleDateFormat format = simpleDateFormat_GMT("yyyy/MM/dd");
String date = format.format(time);
boolean needDate = neq(date, format.format(now()));
return (needDate ? date + " " : "") + formatGMT_24(time);
}
static long now_virtualTime;
static long now() {
return now_virtualTime != 0 ? now_virtualTime : System.currentTimeMillis();
}
static Map