Warning : session_start(): open(/var/lib/php/sessions/sess_hs4apjjnqd41n52dp8981hrddo, 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 someFunctions = ll(new F1() {
public Boolean get(Character x) {
try {
return isDigit(x);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "isDigit(x)";
}
}, new F1() {
public Boolean get(Character x) {
try {
return isLetter(x);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "isLetter(x)";
}
}, new F1() {
public Boolean get(Character x) {
try {
return isLetterOrDigit(x);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "isLetterOrDigit(x)";
}
}, new F1() {
public Boolean get(Character x) {
try {
return isSpace(x);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "isSpace(x)";
}
});
public JComponent visualize() {
return jvsplit(jhsplit(dm_textAreaAsSection("input"), dm_textAreaAsSection("output")), super.visualize());
}
public void start() {
try {
super.start();
dm_onFieldChangeAndNow("input", new Runnable() {
public void run() {
try {
calc();
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "calc();";
}
});
} catch (Exception __e) {
throw rethrow(__e);
}
}
public void calc() {
ITokenizer tokenizer = __12 -> splitAtSpaceTokenizer(__12);
List> tokenizedInput = map(s -> simpleSpacesAndTrim(tokenizer.tokenize(s)), tlft(input));
pnlStruct("tokenizedInput", tokenizedInput);
Set patterns = asSet(findOneArgumentPatterns(tokenizedInput));
assertEquals(2, l(patterns));
print("patterns", patterns);
Map> examples = mapToValues_linkedHashMap(patterns, pat -> mapNotNulls(tok -> firstMatch(getFlexMatchIC(pat, tok)), tokenizedInput));
print("examples", examples);
Map>> examplesAsLists = mapValues(l -> lambdaMap(__40 -> characters(__40), l), examples);
print(examplesAsLists);
List> posExamples = firstValue(examplesAsLists), negExamples = secondValue(examplesAsLists);
LinkedHashSet>> theories = new LinkedHashSet();
for (Object function : concatAsOrderedSet(lambdaMap(__41 -> plusNegation(__41), someFunctions))) {
print("Testing function " + function);
theories.add(new AllElementsSatisfy(function));
theories.add(new AnyElementSatisfies(function));
}
theories.addAll(concatLists(lambdaMap(__42 -> theoryPlusInverse(__42), theories)));
pnl(theories);
Map>, PosNeg>> theoryResults = mapToValues(theories, theory -> new PosNeg(mapToValues(trueFalseMap(posExamples, negExamples), (example, x) -> theory.check(example) == x)));
pnl(theoryResults);
List newStatements = new ArrayList();
List>> perfectTheories = sortByMetaTransformerStructureComplexity(keysWhereValue(theoryResults, pn -> pn.perfect()));
print("perfectTheories", perfectTheories);
newStatements.addAll(makeExamplesFor(perfectTheories, posExamples, firstKey(examplesAsLists)));
List>> antiPerfectTheories = sortByMetaTransformerStructureComplexity(keysWhereValue(theoryResults, pn -> pn.antiPerfect()));
print("antiPerfectTheories", antiPerfectTheories);
newStatements.addAll(makeExamplesFor(antiPerfectTheories, negExamples, secondKey(examplesAsLists)));
setField("output", lines(newStatements));
}
public List makeExamplesFor(List>> theories, Collection> examples, String pattern) {
List out = new ArrayList();
IntRange sizeRange = sizeRangeOfCollections(examples);
print("sizeRange", sizeRange);
for (ITheoryOn> t : theories) if (t instanceof AllElementsSatisfy) {
IF0 generator = predicateToGenerator(((AllElementsSatisfy) t).pred);
if (generator == null) {
print("No generator for " + ((AllElementsSatisfy) t).pred);
continue;
}
for (int _repeat_10 = 0; _repeat_10 < 3; _repeat_10++) {
String example = charactersToString(repF(random(sizeRange), generator));
print("> ", addAndReturn(out, format_noQuote(pattern, example)));
}
break;
}
return out;
}
public IF0 predicateToGenerator(Object f) {
return () -> (Character) random(filter(f, printableASCIICharsList()));
}
}
static public boolean _moduleClass_AModule = true;
static public String programID;
static public void _onLoad_initUtils() {
utils.__javax = javax();
}
static public void _onLoad_defaultClassFinder() {
setDefaultClassFinder(new F1() {
public Class get(String name) {
Class c = findClass_fullName(name);
if (c != null)
return c;
if (name.startsWith("main$"))
return loadableUtils.utils.findClass_fullName("loadableUtils.utils" + name.substring(4));
return null;
}
});
}
static public ThreadLocal dynamicObjectIsLoading_threadLocal() {
return DynamicObject_loading;
}
static public String autoUnindent_mls(String s) {
return autoUnindent(rtrim(dropLeadingNewLine(s)));
}
static public List ll(A... a) {
ArrayList l = new ArrayList(a.length);
if (a != null)
for (A x : a) l.add(x);
return l;
}
static public boolean isDigit(char c) {
return Character.isDigit(c);
}
static public boolean isLetter(char c) {
return Character.isLetter(c);
}
static public boolean isLetterOrDigit(char c) {
return Character.isLetterOrDigit(c);
}
static public boolean isSpace(char c) {
return " \t\r\n".indexOf(c) >= 0;
}
static public JSplitPane jvsplit(Component n, Component s) {
return jvsplit(n, s, 0.5);
}
static public JSplitPane jvsplit(Component n, Component s, double splitPoint, int delay) {
return jvsplit(n, s, splitPoint);
}
static public JSplitPane jvsplit(Component n, Component s, double splitPoint) {
return setSplitPaneOnFirstShowing(swingNu(JSplitPane.class, JSplitPane.VERTICAL_SPLIT, wrap(n), wrap(s)), splitPoint);
}
static public JSplitPane jvsplit(double splitPoint, Component n, Component s) {
return jvsplit(n, s, splitPoint);
}
static public JSplitPane jhsplit(Component l, Component r) {
return jhsplit(l, r, 0.5);
}
static public JSplitPane jhsplit(Component l, Component r, double splitPoint, int delay) {
return jhsplit(l, r, splitPoint);
}
static public JSplitPane jhsplit(Component l, Component r, double splitPoint) {
return setSplitPaneOnFirstShowing(swingNu(JSplitPane.class, JSplitPane.HORIZONTAL_SPLIT, wrap(l), wrap(r)), splitPoint);
}
static public JSplitPane jhsplit(double splitPoint, Component l, Component r) {
return jhsplit(l, r, splitPoint);
}
static public JComponent dm_textAreaAsSection(String field) {
return jCenteredSection(humanizeLabel(field), dm_textArea(field));
}
static public void dm_onFieldChangeAndNow(String field, Runnable onChange) {
dm_watchFieldAndNow(field, onChange);
}
static public List splitAtSpaceTokenizer(String s) {
ArrayList tok = new ArrayList();
int l = l(s);
int i = 0, n = 0;
while (i < l) {
int j = i;
char c;
while (j < l) {
c = s.charAt(j);
if (isSpace(c))
++j;
else
break;
}
tok.add(javaTok_substringN(s, i, j));
++n;
i = j;
if (i >= l)
break;
while (j < l && !isSpace(s.charAt(j))) ++j;
tok.add(javaTok_substringC(s, i, j));
++n;
i = j;
}
if ((tok.size() % 2) == 0)
tok.add("");
return tok;
}
static public List map(Iterable l, Object f) {
return map(f, l);
}
static public 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 public List map(Iterable l, F1 f) {
return map(f, l);
}
static public 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 public List map(IF1 f, Iterable l) {
return map(l, f);
}
static public 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 public List map(IF1 f, A[] l) {
return map(l, f);
}
static public 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 public List map(Object f, Object[] l) {
return map(f, asList(l));
}
static public List map(Object[] l, Object f) {
return map(f, l);
}
static public List map(Object f, Map map) {
return map(map, f);
}
static public 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 public List map(Map map, IF2 f) {
return map(map, (Object) f);
}
static public List simpleSpacesAndTrim(List tok) {
tok = cloneList(tok);
int n = l(tok);
for (int i = 0; i < n; i += 2) tok.set(i, i == 0 || i == n - 1 || empty(tok.get(i)) ? "" : " ");
return tok;
}
static public String simpleSpacesAndTrim(String s) {
return join(simpleSpacesAndTrim(nlTok(s)));
}
static public List tlft(String s) {
return toLinesFullTrim(s);
}
static public List tlft(File f) {
return toLinesFullTrim(f);
}
static public void pnlStruct(Object o) {
if (o instanceof Collection)
pnlStruct(((Collection) o));
else if (o instanceof Map)
pnlStruct(((Map) o));
else if (o != null)
pnlStruct(ll(o));
}
static public > B pnlStruct(B l) {
pnlStruct((Iterable) l);
return l;
}
static public Iterable pnlStruct(Iterable l) {
return pnlStruct("", l);
}
static public Iterable pnlStruct(String prefix, Iterable l) {
int i = 0;
if (l != null)
for (A a : l) print(prefix + (++i) + ". " + struct_noStringSharing(a));
return l;
}
static public A[] pnlStruct(A[] l) {
pnlStruct(asList(l));
return l;
}
static public Map pnlStruct(Map map) {
pnl(map(map, new F2() {
public Object get(A a, B b) {
try {
return sfu(a) + " = " + sfu(b);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "sfu(a) + \" = \" + sfu(b)";
}
}));
return map;
}
static public Set asSet(Object[] array) {
HashSet set = new HashSet();
for (Object o : array) if (o != null)
set.add(o);
return set;
}
static public Set asSet(String[] array) {
TreeSet set = new TreeSet();
for (String o : array) if (o != null)
set.add(o);
return set;
}
static public Set asSet(Iterable l) {
if (l instanceof Set)
return (Set) l;
HashSet set = new HashSet();
for (A o : unnull(l)) if (o != null)
set.add(o);
return set;
}
static public Set asSet(MultiSet ms) {
return ms == null ? null : ms.asSet();
}
static public MultiSet findOneArgumentPatterns(List> toks) {
MultiSet patterns = ciMultiSet();
MultiMap> byLength = indexListsByLength(lambdaMap(__43 -> simpleSpacesAndTrim(__43), toks));
for (List> toks2 : byLength.values()) {
for (int i = 1; i < l(first(toks2)) - 1; i += 2) {
int _i = i;
MultiSet set = mapToCIMultiSet(toks2, tok -> join(cloneListReplacingElementAtIndex(tok, _i, "*")));
patterns.addAll(multiSetWithoutSingles(set));
}
}
return patterns;
}
static public A assertEquals(Object x, A y) {
return assertEquals(null, x, y);
}
static public A assertEquals(String msg, Object x, A y) {
if (assertVerbose())
return assertEqualsVerbose(msg, x, y);
if (!(x == null ? y == null : x.equals(y)))
throw fail((msg != null ? msg + ": " : "") + y + " != " + x);
return y;
}
static volatile public StringBuffer local_log = new StringBuffer();
static volatile public Appendable print_log = local_log;
static volatile public int print_log_max = 1024 * 1024;
static volatile public int local_log_max = 100 * 1024;
static public boolean print_silent = false;
static public Object print_byThread_lock = new Object();
static volatile public ThreadLocal print_byThread;
static volatile public Object print_allThreads;
static volatile public Object print_preprocess;
static public void print() {
print("");
}
static public A print(String s, A o) {
print((endsWithLetterOrDigit(s) ? s + ": " : s) + o);
return o;
}
static public A print(A o) {
ping_okInCleanUp();
if (print_silent)
return o;
String s = String.valueOf(o) + "\n";
print_noNewLine(s);
return o;
}
static public void print_noNewLine(String s) {
Object f = getThreadLocal(print_byThread_dontCreate());
if (f == null)
f = print_allThreads;
if (f != null)
if (isFalse(f instanceof F1 ? ((F1) f).get(s) : callF(f, s)))
return;
print_raw(s);
}
static public 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 public void print_autoRotate() {
}
static public Map mapToValues_linkedHashMap(Iterable l, Object f) {
return mapToValues_linkedHashMap(f, l);
}
static public Map mapToValues_linkedHashMap(Object f, Iterable l) {
LinkedHashMap map = new LinkedHashMap();
if (l != null)
for (Object o : l) map.put(o, callF(f, o));
return map;
}
static public Map mapToValues_linkedHashMap(Iterable l, IF1 f) {
return mapToValues_linkedHashMap(f, l);
}
static public List mapNotNulls(Iterable l, Object f) {
return mapNonNulls(l, f);
}
static public List mapNotNulls(Object f, Object[] l) {
return mapNonNulls(f, l);
}
static public List mapNotNulls(Object f, Iterable l) {
return mapNonNulls(f, l);
}
static public List mapNotNulls(Iterable l, F1 f) {
return mapNonNulls(l, f);
}
static public List mapNotNulls(IF1 f, Iterable l) {
return mapNonNulls(f, l);
}
static public List mapNotNulls(Iterable l, IF1 f) {
return mapNonNulls(l, f);
}
static public List mapNotNulls(F1 f, Iterable l) {
return mapNonNulls(f, l);
}
static public String firstMatch(Matches m) {
return m == null ? null : m.get(0);
}
static public Matches getFlexMatchIC(String pat, String s) {
Matches m = new Matches();
return flexMatchIC(pat, s, m) ? m : null;
}
static public Matches getFlexMatchIC(String pat, String s, boolean joinBrackets) {
Matches m = new Matches();
return flexMatchIC(pat, s, m, joinBrackets) ? m : null;
}
static public Matches getFlexMatchIC(String pat, List tokInput) {
Matches m = new Matches();
return flexMatchIC(pat, tokInput, m) ? m : null;
}
static public Map mapValues(Object func, Map map) {
Map m = similarEmptyMap(map);
for (Object key : keys(map)) m.put(key, callF(func, map.get(key)));
return m;
}
static public Map mapValues(Map map, IF1 f) {
return mapValues(f, map);
}
static public Map mapValues(IF1 f, Map map) {
return mapValues((Object) f, map);
}
static public Map mapValues(Map map, Object func) {
return mapValues(func, map);
}
static public List lambdaMap(IF1 f, Iterable l) {
return map(l, f);
}
static public List lambdaMap(IF1 f, A[] l) {
return map(l, f);
}
static public List characters(final String s) {
return stringAsCharacterList(s);
}
static public B firstValue(Map map) {
return first(values(map));
}
static public B secondValue(Map map) {
return second(values(map));
}
static public LinkedHashSet concatAsOrderedSet(Collection ... lists) {
return concatToOrderedSet(lists);
}
static public LinkedHashSet concatAsOrderedSet(Collection> lists) {
return concatToOrderedSet(lists);
}
static public List plusNegation(Object o) {
if (o instanceof Not)
return ll(((Not) o), ((Not) o).a);
else
return ll(o, new Not(o));
}
static public List concatLists(Iterable ... lists) {
List l = new ArrayList();
if (lists != null)
for (Iterable list : lists) addAll(l, list);
return l;
}
static public List concatLists(Collection> lists) {
List l = new ArrayList();
if (lists != null)
for (Iterable list : lists) addAll(l, list);
return l;
}
static public List> theoryPlusInverse(ITheoryOn t) {
if (t instanceof InverseTheory)
return ll(((InverseTheory) t), ((InverseTheory) t).t);
else
return ll(t, new InverseTheory(t));
}
static public A pnl(String prefix, A l) {
printNumberedLines(prefix, l);
return l;
}
static public A pnl(A l) {
printNumberedLines(l);
return l;
}
static public A pnl(A map) {
printNumberedLines(map);
return map;
}
static public A pnl(String prefix, A map) {
printNumberedLines(prefix, map);
return map;
}
static public A[] pnl(A[] a) {
printNumberedLines(a);
return a;
}
static public String pnl(String s) {
printNumberedLines(lines(s));
return s;
}
static public Map mapToValues(Iterable l, Object f) {
return mapKeyAndFunction(l, f);
}
static public Map mapToValues(Object f, Iterable l) {
return mapKeyAndFunction(f, l);
}
static public Map mapToValues(Iterable l, IF1 f) {
return mapKeyAndFunction(f, l);
}
static public Map mapToValues(Map map, IF2 f) {
return mapKeyAndFunction(map, f);
}
static public Map trueFalseMap(Iterable pos, Iterable neg) {
LinkedHashMap map = new LinkedHashMap();
for (A a : unnull(pos)) map.put(a, true);
for (A a : unnull(neg)) map.put(a, false);
return map;
}
static public List sortByMetaTransformerStructureComplexity(Collection l) {
return sortedByCalculatedField("metaTransformable_structureSize_orNull", l);
}
static public List keysWhereValue(IF1 pred, Map map) {
return keysWithValueThat(pred, map);
}
static public List keysWhereValue(Map map, IF1 pred) {
return keysWithValueThat(map, pred);
}
static public A firstKey(Map map) {
return first(keys(map));
}
static public A secondKey(Map map) {
return second(keys(map));
}
static public String lines(Iterable lines) {
return fromLines(lines);
}
static public String lines(Object[] lines) {
return fromLines(asList(lines));
}
static public List lines(String s) {
return toLines(s);
}
static public > IntRange sizeRangeOfCollections(Iterable l) {
IntRange r = null;
for (B c : unnull(l)) r = rangePlus(r, l(c));
return r;
}
static public String charactersToString(List l) {
if (l == null)
return null;
int n = l.size();
char[] array = new char[n];
for (int i = 0; i < n; i++) array[i] = l.get(i);
return new String(array);
}
static public List repF(int n, Object f, Object... args) {
List l = new ArrayList();
for (int i = 0; i < n; i++) l.add(callF(f, args));
return l;
}
static public List repF(Object f, int n) {
return repF(n, f);
}
static public List repF(int n, IF0 f) {
return repF(f, n);
}
static public Random random_random = new Random();
static public int random(int n) {
return random(random_random, n);
}
static public int random(Random r, int n) {
return n <= 0 ? 0 : r.nextInt(n);
}
static public double random(double max) {
return random() * max;
}
static public double random() {
return random_random.nextInt(100001) / 100000.0;
}
static public double random(double min, double max) {
return min + random() * (max - min);
}
static public int random(int min, int max) {
return min + random(max - min);
}
static public int random(Random r, int min, int max) {
return min + random(r, max - min);
}
static public A random(List l) {
return oneOf(l);
}
static public A random(Collection c) {
if (c instanceof List)
return random((List ) c);
int i = random(l(c));
return collectionGet(c, i);
}
static public int random(IntRange r) {
return random(r.start, r.end);
}
static public A addAndReturn(Collection c, A a) {
if (c != null)
c.add(a);
return a;
}
static public String format_noQuote(String pat, Object... args) {
if (args.length == 0)
return pat;
List tok = javaTok(pat);
int argidx = 0;
for (int i = 1; i < tok.size(); i += 2) if (tok.get(i).equals("*"))
tok.set(i, str(argidx < args.length ? args[argidx++] : null));
return join(tok);
}
static public List filter(Iterable c, Object pred) {
if (pred instanceof F1)
return filter(c, (F1) pred);
List x = new ArrayList();
if (c != null)
for (Object o : c) if (isTrue(callF(pred, o)))
x.add(o);
return x;
}
static public List filter(Object pred, Iterable c) {
return filter(c, pred);
}
static public List filter(Iterable c, F1 pred) {
List x = new ArrayList();
if (c != null)
for (B o : c) if (pred.get(o))
x.add(o);
return x;
}
static public List filter(F1 pred, Iterable c) {
return filter(c, pred);
}
static public List filter(Iterable c, IF1 pred) {
List x = new ArrayList();
if (c != null)
for (B o : c) if (pred.get(o))
x.add(o);
return x;
}
static public List filter(B[] c, IF1 pred) {
List x = new ArrayList();
if (c != null)
for (B o : c) if (pred.get(o))
x.add(o);
return x;
}
static public List filter(IF1 pred, Iterable c) {
return filter(c, pred);
}
static public List printableASCIICharsList() {
return new RandomAccessAbstractList() {
public int size() {
return 128 - 32;
}
public Character get(int i) {
return (char) (32 + i);
}
};
}
static public Class javax() {
return getJavaX();
}
static public void setDefaultClassFinder(Object cf) {
_defaultClassFinder_value = cf;
}
static public HashMap findClass_fullName_cache = new HashMap();
static public Class findClass_fullName(String name) {
synchronized (findClass_fullName_cache) {
if (findClass_fullName_cache.containsKey(name))
return findClass_fullName_cache.get(name);
Class c;
try {
c = Class.forName(name);
} catch (ClassNotFoundException e) {
c = null;
}
findClass_fullName_cache.put(name, c);
return c;
}
}
static public AutoCloseable tempInterceptPrintIfNotIntercepted(F1 f) {
return print_byThread().get() == null ? tempInterceptPrint(f) : null;
}
static public Object _defaultClassFinder_value = defaultDefaultClassFinder();
static public Object _defaultClassFinder() {
return _defaultClassFinder_value;
}
static public String autoUnindent(String s) {
int n = getIndent(s);
if (n == 0)
return s;
List l = toLines(s);
for (int i = 0; i < l(l); i++) l.set(i, substring(l.get(i), n));
return fromLines(l);
}
public static String rtrim(String s) {
if (s == null)
return null;
int i = s.length();
while (i > 0 && " \t\r\n".indexOf(s.charAt(i - 1)) >= 0) --i;
return i < s.length() ? s.substring(0, i) : s;
}
static public String dropLeadingNewLine(String s) {
if (startsWith(s, "\r\n"))
return substring(s, 2);
if (startsWith(s, "\n"))
return substring(s, 1);
return s;
}
static public JSplitPane setSplitPaneOnFirstShowing(final Component c, final double value) {
final JSplitPane sp = first(childrenOfType(c, JSplitPane.class));
if (sp != null)
onFirstResize(sp, new Runnable() {
public void run() {
try {
sp.setDividerLocation(value);
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "sp.setDividerLocation(value);";
}
});
return sp;
}
static public A swingNu(final Class c, final Object... args) {
return swingConstruct(c, args);
}
static public JComponent wrap(Object swingable) {
return _recordNewSwingComponent(wrap_2(swingable));
}
static public 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 public JPanel jCenteredSection(Component c) {
return jCenteredSection("", c);
}
static public JPanel jCenteredSection(final String title, final Component c) {
return swing(new F0() {
public JPanel get() {
try {
JPanel p = jSection(title, c);
((TitledBorder) p.getBorder()).setTitleJustification(TitledBorder.CENTER);
return p;
} catch (Exception __e) {
throw rethrow(__e);
}
}
public String toString() {
return "JPanel p = jSection(title, c);\r\n ((TitledBorder) p.getBorder()).setTitleJu...";
}
});
}
static public JPanel jCenteredSection(String title) {
return jCenteredSection(title, jpanel());
}
static public String humanizeLabel(String s) {
return humanizeFormLabel(s);
}
static public JTextArea dm_textArea(String field) {
return dm_fieldTextArea(field);
}
static public void dm_watchFieldAndNow(String field, Runnable onChange) {
dm_watchField(field, onChange);
dm_q(onChange);
}
static public String javaTok_substringN(String s, int i, int j) {
if (i == j)
return "";
if (j == i + 1 && s.charAt(i) == ' ')
return " ";
return s.substring(i, j);
}
static public String javaTok_substringC(String s, int i, int j) {
return s.substring(i, j);
}
static public ArrayList emptyList() {
return new ArrayList();
}
static public ArrayList emptyList(int capacity) {
return new ArrayList(max(0, capacity));
}
static public ArrayList emptyList(Iterable l) {
return l instanceof Collection ? emptyList(((Collection) l).size()) : emptyList();
}
static public ArrayList emptyList(Object[] l) {
return emptyList(l(l));
}
static public ArrayList emptyList(Class c) {
return new ArrayList();
}
static public Object callF(Object f, Object... args) {
try {
if (f instanceof String)
return callMC((String) f, args);
return x30_util.callF(f, args);
} catch (Exception __e) {
throw rethrow(__e);
}
}
static public A callF(F0 f) {
return f == null ? null : f.get();
}
static public A callF(IF0 f) {
return f == null ? null : f.get();
}
static public B callF(F1 f, A a) {
return f == null ? null : f.get(a);
}
static public B callF(IF1 f, A a) {
return f == null ? null : f.get(a);
}
static public C callF(F2 f, A a, B b) {
return f == null ? null : f.get(a, b);
}
static public void callF(VF1 f, A a) {
if (f != null)
f.get(a);
}
static public Object callMC(String method, Object... args) {
return call(mc(), method, args);
}
static public Object call(Object o) {
return callF(o);
}
static public Object call(Object o, String method, Object... args) {
return call_withVarargs(o, method, args);
}
static public ArrayList asList(A[] a) {
return a == null ? new ArrayList () : new ArrayList (Arrays.asList(a));
}
static public ArrayList asList(int[] a) {
if (a == null)
return null;
ArrayList l = emptyList(a.length);
for (int i : a) l.add(i);
return l;
}
static public ArrayList asList(float[] a) {
if (a == null)
return null;
ArrayList l = emptyList(a.length);
for (float i : a) l.add(i);
return l;
}
static public ArrayList asList(double[] a) {
if (a == null)
return null;
ArrayList l = emptyList(a.length);
for (double i : a) l.add(i);
return l;
}
static public 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 public ArrayList asList(Enumeration e) {
ArrayList l = new ArrayList();
if (e != null)
while (e.hasMoreElements()) l.add(e.nextElement());
return l;
}
static public ArrayList cloneList(Iterable l) {
return l instanceof Collection ? cloneList((Collection) l) : asList(l);
}
static public ArrayList cloneList(Collection l) {
if (l == null)
return new ArrayList();
synchronized (collectionMutex(l)) {
return new ArrayList (l);
}
}
static public boolean empty(Collection c) {
return c == null || c.isEmpty();
}
static public boolean empty(CharSequence s) {
return s == null || s.length() == 0;
}
static public boolean empty(Map map) {
return map == null || map.isEmpty();
}
static public boolean empty(Object[] o) {
return o == null || o.length == 0;
}
static public 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 public boolean empty(Iterator i) {
return i == null || !i.hasNext();
}
static public boolean empty(double[] a) {
return a == null || a.length == 0;
}
static public boolean empty(float[] a) {
return a == null || a.length == 0;
}
static public boolean empty(int[] a) {
return a == null || a.length == 0;
}
static public boolean empty(long[] a) {
return a == null || a.length == 0;
}
static public boolean empty(byte[] a) {
return a == null || a.length == 0;
}
static public boolean empty(short[] a) {
return a == null || a.length == 0;
}
static public boolean empty(MultiSet ms) {
return ms == null || ms.isEmpty();
}
static public boolean empty(MultiMap mm) {
return mm == null || mm.isEmpty();
}
static public boolean empty(File f) {
return getFileSize(f) == 0;
}
public static String join(String glue, Iterable strings) {
if (strings == null)
return "";
if (strings instanceof Collection) {
if (((Collection) strings).size() == 1)
return str(first(((Collection) strings)));
}
StringBuilder buf = new StringBuilder();
Iterator i = strings.iterator();
if (i.hasNext()) {
buf.append(i.next());
while (i.hasNext()) buf.append(glue).append(i.next());
}
return buf.toString();
}
public static String join(String glue, String... strings) {
return join(glue, Arrays.asList(strings));
}
static public String join(Iterable strings) {
return join("", strings);
}
static public String join(Iterable strings, String glue) {
return join(glue, strings);
}
public static String join(String[] strings) {
return join("", strings);
}
static public String join(String glue, Pair p) {
return p == null ? "" : str(p.a) + glue + str(p.b);
}
static public List nlTok(String s) {
return javaTokPlusPeriod(s);
}
static public List toLinesFullTrim(String s) {
List l = new ArrayList();
for (String line : toLines(s)) if (nempty(line = trim(line)))
l.add(line);
return l;
}
static public List toLinesFullTrim(File f) {
List l = new ArrayList();
for (String line : linesFromFile(f)) if (nempty(line = trim(line)))
l.add(line);
return l;
}
static public String struct_noStringSharing(Object o) {
structure_Data d = new structure_Data();
d.noStringSharing = true;
return structure(o, d);
}
static public String sfu(Object o) {
return structureForUser(o);
}
static public String unnull(String s) {
return s == null ? "" : s;
}
static public Collection unnull(Collection l) {
return l == null ? emptyList() : l;
}
static public List unnull(List l) {
return l == null ? emptyList() : l;
}
static public Map unnull(Map l) {
return l == null ? emptyMap() : l;
}
static public Iterable unnull(Iterable i) {
return i == null ? emptyList() : i;
}
static public A[] unnull(A[] a) {
return a == null ? (A[]) emptyObjectArray() : a;
}
static public BitSet unnull(BitSet b) {
return b == null ? new BitSet() : b;
}
static public Pt unnull(Pt p) {
return p == null ? new Pt() : p;
}
static public Pair unnull(Pair p) {
return p != null ? p : new Pair(null, null);
}
static public MultiSet ciMultiSet() {
MultiSet ms = new MultiSet();
ms.map = ciMap();
return ms;
}
static public MultiSet ciMultiSet(Iterable l) {
return asCIMultiSet(l);
}
static public > MultiMap indexListsByLength(Collection lists) {
return indexByCalculatedField_treeMultiMap(__44 -> l(__44), lists);
}
static public Object first(Object list) {
return first((Iterable) list);
}
static public A first(List list) {
return empty(list) ? null : list.get(0);
}
static public A first(A[] bla) {
return bla == null || bla.length == 0 ? null : bla[0];
}
static public A first(IterableIterator i) {
return first((Iterator ) i);
}
static public A first(Iterator i) {
return i == null || !i.hasNext() ? null : i.next();
}
static public A first(Iterable i) {
if (i == null)
return null;
Iterator it = i.iterator();
return it.hasNext() ? it.next() : null;
}
static public Character first(String s) {
return empty(s) ? null : s.charAt(0);
}
static public A first(Pair p) {
return p == null ? null : p.a;
}
static public Byte first(byte[] l) {
return empty(l) ? null : l[0];
}
static public MultiSet mapToCIMultiSet(IF1 f, Iterable l) {
return mapToCIMultiSet((Object) f, l);
}
static public MultiSet mapToCIMultiSet(Object f, Iterable l) {
MultiSet x = ciMultiSet();
if (l != null)
for (Object o : l) {
String s = (String) (callF(f, o));
if (s != null)
x.add(s);
}
return x;
}
static public MultiSet mapToCIMultiSet(Iterable l, IF1 f) {
return mapToCIMultiSet(f, l);
}
static public List cloneListReplacingElementAtIndex(List l, int i, A a) {
listSetIfInRange(l = cloneList(l), i, a);
return l;
}
static public MultiSet multiSetWithoutSingles(MultiSet ms) {
if (ms == null)
return null;
MultiSet ms2 = similarEmptyMultiSet(ms);
for (A a : keys(ms)) {
int n = ms.get(a);
if (n > 1)
ms2.add(a, n);
}
return ms2;
}
static public ThreadLocal assertVerbose_value = new ThreadLocal();
static public void assertVerbose(boolean b) {
assertVerbose_value.set(b);
}
static public boolean assertVerbose() {
return isTrue(assertVerbose_value.get());
}
static public A assertEqualsVerbose(Object x, A y) {
assertEqualsVerbose((String) null, x, y);
return y;
}
static public A assertEqualsVerbose(String msg, Object x, A y) {
if (!eq(x, y)) {
throw fail((msg != null ? msg + ": " : "") + "expected: " + x + ", got: " + y);
} else
print("OK" + (empty(msg) ? "" : " " + msg) + ": " + (x));
return y;
}
static public boolean endsWithLetterOrDigit(String s) {
return s != null && s.length() > 0 && Character.isLetterOrDigit(s.charAt(s.length() - 1));
}
static public void ping_okInCleanUp() {
if (ping_pauseAll || ping_anyActions)
ping_impl(true);
}
static public Object getThreadLocal(Object o, String name) {
ThreadLocal t = (ThreadLocal) (getOpt(o, name));
return t != null ? t.get() : null;
}
static public A getThreadLocal(ThreadLocal tl) {
return tl == null ? null : tl.get();
}
static public A getThreadLocal(ThreadLocal tl, A defaultValue) {
return or(getThreadLocal(tl), defaultValue);
}
static public ThreadLocal print_byThread_dontCreate() {
return print_byThread;
}
static public boolean isFalse(Object o) {
return eq(false, o);
}
static public 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 public 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 public List mapNonNulls(Iterable l, Object f) {
return mapNonNulls(f, l);
}
static public List mapNonNulls(Object f, Iterable l) {
List x = new ArrayList();
if (l != null)
for (Object o : l) addIfNotNull(x, callF(f, o));
return x;
}
static public List mapNonNulls(Object f, Object[] l) {
List x = new ArrayList();
if (l != null)
for (Object o : l) addIfNotNull(x, callF(f, o));
return x;
}
static public List mapNonNulls(Iterable l, F1 f) {
return mapNonNulls(f, l);
}
static public List mapNonNulls(F1 f, Iterable l) {
List x = new ArrayList();
if (l != null)
for (Object o : l) addIfNotNull(x, callF(f, o));
return x;
}
static public List mapNonNulls(A[] l, IF1 f) {
return mapNonNulls(f, l);
}
static public List mapNonNulls(Iterable l, IF1 f) {
List x = emptyList(l);
if (l != null)
for (A o : l) addIfNotNull(x, f.get(o));
return x;
}
static public List mapNonNulls(IF1 f, Iterable l) {
return mapNonNulls(l, f);
}
static public boolean flexMatchIC(String pat, String s) {
return flexMatchIC2(pat, s);
}
static public boolean flexMatchIC(String pat, String s, Matches m) {
return flexMatchIC2(pat, s, m);
}
static public boolean flexMatchIC(String pat, List