")) return mc(); { Class c = findClass_fullName(name); if (c != null) return c; } if (startsWithAny(name, "loadableUtils.utils$", "main$", mcDollar())) for (String pkg : ll("loadableUtils.utils$", mcDollar())) { String newName = pkg + afterDollar(name); { Class c = findClass_fullName(newName); if (c != null) return c; } } return null; } }; } static public Object[] html_massageAutofocusParam(Object[] params) { Object autofocus = optPar("autofocus", params); return changeParam(params, "autofocus", eqOneOf(autofocus, html_valueLessParam(), true, 1, "1", "autofocus") ? html_valueLessParam() : null); } static public long lastModified(File f) { return fileModificationTime(f); } static public SimpleAttributeSet style_normal() { return new SimpleAttributeSet(); } static public int sixteenToNine(int w) { return iround(w * 9.0 / 16); } static public String extractYouTubeID(String s) { if (empty(s)) return null; int i = indexOfAfter(s, "youtu.be/"); if (i >= 0) return substring(s, i); s = substring(s, indexOf(s, '?') + 1); try { String __1 = mapGet(decodeHQuery(s), "v"); if (!empty(__1)) return __1; } catch (Throwable _e) { } return s; } static public String iframe(String url, Object... params) { return hfulltag("iframe", "", arrayPlus(params, "src", url)); } static public String nlToBr(String s) { return s.replace("\n", "
\n"); } static public String htmlEncode2(String s) { return htmlencode_noQuotes(s); } static public String htmlEncode2(Object o) { return htmlEncode2(strOrEmpty(o)); } static public Pair listToPair(List l) { return l(l) != 2 ? null : pair(first(l), second(l)); } static public List tok_splitAtEquals(String s) { return splitAtTokens(javaTokWithAllBrackets_cached(s), "="); } static public Integer parseIntOptOrNull(String s) { return isInteger(s) ? parseInt(s) : null; } static public A firstOfType(Collection c, Class type) { for (Object x : c) if (isInstanceX(type, x)) return (A) x; return null; } static public String assertIPv4(String s) { assertTrue(s, isIPv4(s)); return s; } static public Pair pairMapB(Object f, Pair p) { return p == null ? null : pair(p.a, callF(f, p.b)); } static public Pair pairMapB(IF1 f, Pair p) { return p == null ? null : pair(p.a, f.get(p.b)); } static public Pair pairMapB(Pair p, Object f) { return pairMap(f, p); } static public Map unwrapSynchronizedMapOrNull(Map map) { Map map2 = unwrapSynchronizedMap(map); return map2 == map ? null : map2; } static public int compareIgnoreCase_jdk(String s1, String s2) { if (s1 == null) return s2 == null ? 0 : -1; if (s2 == null) return 1; int n1 = s1.length(); int n2 = s2.length(); int min = Math.min(n1, n2); for (int i = 0; i < min; i++) { char c1 = s1.charAt(i); char c2 = s2.charAt(i); if (c1 != c2) { c1 = Character.toUpperCase(c1); c2 = Character.toUpperCase(c2); if (c1 != c2) { c1 = Character.toLowerCase(c1); c2 = Character.toLowerCase(c2); if (c1 != c2) return c1 - c2; } } } return n1 - n2; } static public Map decodeHQuery(String query) { Map map = new HashMap(); for (String s : splitAtAmpersand(query)) { int i = s.indexOf('='); if (i >= 0) map.put(urldecode(s.substring(0, i)), urldecode(s.substring(i + 1))); } return map; } static public String getQueryFromURL(String url) { return dropAfterSubstring(substring(url, smartIndexOf(url, "?") + 1), "#"); } static public Map unsafe_sizeOf_cache = weakHashMap(); static public long unsafe_sizeOf(Object o) { if (isArray(o)) if (o instanceof Object[]) return inMemorySizeOfObjectArray(((Object[]) o).length); else return inMemorySizeOfPrimitiveArray(o); Class c = _getClass(o); Integer l = unsafe_sizeOf_cache.get(c); if (l == null) unsafe_sizeOf_cache.put(c, l = unsafe_sizeOf_uncached(c)); return l; } static public int unsafe_sizeOf_uncached(Class src) { int WORD = javaDataModelWordSize(); int MIN_SIZE = 16; List instanceFields = new ArrayList(); while (src != null && src != Object.class && empty(instanceFields)) { for (Field f : src.getDeclaredFields()) if ((f.getModifiers() & Modifier.STATIC) == 0) instanceFields.add(f); src = src.getSuperclass(); } long maxOffset = MIN_SIZE - 1; for (Field f : instanceFields) { long offset = unsafe_objectFieldOffset(f); if (offset > maxOffset) maxOffset = offset; } return (((int) maxOffset / WORD) + 1) * WORD; } static public IterableIterator> mapPairs(Map map) { final Iterator> it = map.entrySet().iterator(); return iteratorFromFunction(new F0>() { public Pair get() { try { if (it.hasNext()) { Map.Entry entry = it.next(); return pair(entry.getKey(), entry.getValue()); } return null; } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (it.hasNext()) {\r\n Map.Entry entry = it.next();\r\n ret pair..."; } }); } static public List mapPairs(Iterable> l, IF2 f) { return mapPairsToList(l, f); } static public Map unsafe_allFieldOffsets(Object o) { Class src = _getClass(o); Map map = new HashMap(); while (src != null && src != Object.class) { for (Field f : src.getDeclaredFields()) { if ((f.getModifiers() & Modifier.STATIC) == 0) { long offset = (long) (call(theUnsafe_gen(), "objectFieldOffset", f)); String name = f.getName(); if (map.containsKey(name)) name = lightlyShortClassName(src) + "." + name; map.put(name, offset); } } src = src.getSuperclass(); } return orderMapByValue(map); } static public long parseYYYYslashMMslashDD(String s) { try { return new SimpleDateFormat("yyyy/MM/dd").parse(s).getTime(); } catch (Exception __e) { throw rethrow(__e); } } static public TreeMap litCIMap(Object... x) { TreeMap map = caseInsensitiveMap(); litmap_impl(map, x); return map; } static public String regexpReplaceIC(String s, String pat, Object f) { return regexReplaceIC(s, pat, f); } static public String regexpReplaceIC(String s, String pat, String replacement) { return regexReplaceIC(s, pat, replacement); } static public String regexpReplaceIC(String s, String pat, IF1 f) { return regexReplaceIC(s, pat, f); } static public String hcomment_unescaped(String text) { return ""; } static public String htmlencode(Object o) { return htmlencode(str(o)); } static public String htmlencode(String s) { if (s == null) return ""; StringBuilder out = new StringBuilder(Math.max(16, s.length())); for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (c > 127 || c == '"' || c == '<' || c == '>' || c == '&') { int cp = s.codePointAt(i); out.append("&#x"); out.append(intToHex_flexLength(cp)); out.append(';'); i += Character.charCount(cp) - 1; } else out.append(c); } return out.toString(); } static public A foldl_noSeed(F2 f, Iterable l) { return foldl_noSeed((Object) f, l); } static public A foldl_noSeed(IF2 f, Iterable l) { Iterator it = iterator(l); if (!it.hasNext()) return null; A a = it.next(); while (it.hasNext()) a = f.get(a, it.next()); return a; } static public A foldl_noSeed(IF2 f, A... l) { return foldl_noSeed(f, asList(l)); } static public A foldl_noSeed(Object f, Iterable l) { Iterator it = iterator(l); if (!it.hasNext()) return null; A a = it.next(); while (it.hasNext()) a = (A) callF(f, a, it.next()); return a; } static public int methodApplicabilityScore(Method m, Object[] args) { Class[] types = m.getParameterTypes(); if (types.length != args.length) return Integer.MAX_VALUE; int score = 0; for (int i = 0; i < types.length; i++) { Object a = args[i]; Class c = types[i]; if (a == null) ++score; else if (c == a.getClass()) { } else if (isInstanceX(c, a)) ++score; else return Integer.MAX_VALUE; } return score; } static public A copyNonTransientFields(Object x, A y) { return copyFields(x, y, nonTransientNonStaticFields(x)); } static public long conceptID(Concept c) { return c == null ? 0 : c.id; } static public long conceptID(Concept.Ref ref) { return conceptID(cDeref(ref)); } static public long lround(double d) { return Math.round(d); } static public long lround(Number n) { return lround(toDouble(n)); } static public Set setMinus(Set set, Object... stuff) { Set s2 = cloneSet(set); for (Object o : stuff) s2.remove(o); return s2; } static public Set mergeSets(Collection ... l) { return joinSets(l); } static public Set allNonStaticNonTransientFields(Object o) { TreeSet fields = new TreeSet(); Class _c = _getClass(o); do { for (Field f : _c.getDeclaredFields()) if ((f.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) == 0) fields.add(f.getName()); _c = _c.getSuperclass(); } while (_c != null); return fields; } static public boolean isHardError(Throwable e) { return innerExceptionOfType(Error.class, e) != null; } static public double toG_double(long l) { return l / (1024 * 1024 * 1024.0); } static public void setTitledBorderFontSize(JComponent c, float fontSize) { if (c == null) return; { swing(() -> { javax.swing.border.TitledBorder b = optCast(javax.swing.border.TitledBorder.class, c.getBorder()); if (b != null) { Font font = b.getTitleFont(); b.setTitleFont(font.deriveFont(fontSize)); } }); } } static public JTable setTableFontSizesAndRowHeight(float size, JTable table) { if (table == null) return null; { swing(() -> { setTableFontSizes(size, table); setRowHeight(table, fontSizeToRowHeight(size, table)); }); } return table; } static public JTable setTableFontSizesAndRowHeight(JTable table, float size) { return setTableFontSizesAndRowHeight(size, table); } static public String plusMinusFix(String s) { return dropMinusFromZero(addPlusIfPositive(s)); } static public String formatMarginPrice(double price) { return formatDouble2X(price); } static public Map paramsToMap_withNulls(Object... params) { int n = l(params); if (l(params) == 1 && params[0] instanceof Map) return (Map) params[0]; LinkedHashMap map = new LinkedHashMap(); for (int i = 0; i + 1 < n; i += 2) map.put(params[i], params[i + 1]); return map; } static public String jsonEncode_extended(Object o) { StringBuilder buf = new StringBuilder(); jsonEncode_extended(o, buf); return str(buf); } static public void jsonEncode_extended(Object o, StringBuilder buf) { if (o == null) buf.append("null"); else if (o instanceof JS) buf.append(((JS) o).get()); else if (o instanceof String) buf.append(quote((String) o)); else if (o instanceof Number || o instanceof Boolean) buf.append(o); else if (o instanceof Map) { Map map = (Map) o; buf.append("{"); boolean first = true; for (Object key : keys(map)) { if (first) first = false; else buf.append(","); buf.append(quote((String) key)); buf.append(":"); jsonEncode_extended(map.get(key), buf); } buf.append("}"); } else if (o instanceof Collection) { Collection l = (Collection) o; buf.append("["); boolean first = true; for (Object element : l) { if (first) first = false; else buf.append(","); jsonEncode_extended(element, buf); } buf.append("]"); } else throw fail("Unknown object for JSON encoding: " + className(o)); } static public boolean isRelativeOrAbsoluteURL(String s) { return isAbsoluteURL(s) || isRelativeURL(s); } static public String hstylesheetsrc(String src) { return tag("link", "", "rel", "stylesheet", "href", src); } static public String addLineBreak(String s) { return addSuffix(s, "\n"); } static public String base64(byte[] a) { return base64encode(a); } static public String dropSuffixICOrNull_trim(String suffix, String s) { return !ewic(s, suffix) ? null : trimSubstring(s, 0, l(s) - l(suffix)); } static public TokCondition toTokCondition(ITokCondition condition) { return condition == null ? null : condition instanceof TokCondition ? (TokCondition) condition : new TokCondition() { public boolean get(List tok, int i) { return condition.get(tok, i); } }; } static public boolean startsWithIC(String a, String b) { return startsWithIgnoreCase(a, b); } static public Cache oshi_operatingSystem_cache = new Cache<>(() -> oshi_operatingSystem_load()); static public OperatingSystem oshi_operatingSystem() { return oshi_operatingSystem_cache.get(); } static public OperatingSystem oshi_operatingSystem_load() { return oshi_systemInfo().getOperatingSystem(); } static public boolean isOpeningTag(String token, String tag) { return isTag(token, tag) && !token.endsWith("/>"); } static public boolean isOpeningTag(String token) { return token.startsWith("<") && token.endsWith(">") && !token.endsWith("/>") && isLetter(token.charAt(1)); } static public boolean isTag(String token, String tag) { return token.regionMatches(true, 0, "<" + tag + " ", 0, tag.length() + 2) || token.regionMatches(true, 0, "<" + tag + ">", 0, tag.length() + 2); } static public String tagParam(String tag, String key) { return getHtmlTagParameter(tag, key); } static public String tagParam(List tok, String key) { return getHtmlTagParameter(second(tok), key); } static public List htmlcoarsetok(String s) { List tok = new ArrayList(); int l = s == null ? 0 : s.length(); int i = 0; while (i < l) { int j = i; char c; while (j < l) { if (s.charAt(j) != '<') ++j; else if (s.substring(j, Math.min(j + 4, l)).equals("")); j = Math.min(j + 3, l); } else { char d = charAt(s, j + 1); if (d == '/' || isLetter(d)) break; else ++j; } } tok.add(s.substring(i, j)); i = j; if (i >= l) break; c = s.charAt(i); if (c == '<') { ++j; while (j < l && s.charAt(j) != '>') ++j; if (j < l) ++j; } tok.add(s.substring(i, j)); i = j; } if ((tok.size() & 1) == 0) tok.add(""); return tok; } static public boolean isDir(File f) { return isDirectory(f); } static public boolean isDir(String path) { return isDirectory(path); } static public ThreadLocal smartZipCompressionLevel_on = new ThreadLocal(); static public AutoCloseable smartZipCompressionLevel(ZipOutputStream zip, File f) { return smartZipCompressionLevel(zip, fileName(f)); } static public AutoCloseable smartZipCompressionLevel(final ZipOutputStream zip, String fileName) { if (!isTrue(smartZipCompressionLevel_on.get())) return null; int level = Deflater.DEFAULT_COMPRESSION; if (isImageFileName(fileName) || eqicOneOf(fileExtension(fileName), ".zip", ".jar", ".gz", ".bin")) level = Deflater.NO_COMPRESSION; zip.setLevel(level); return new AutoCloseable() { public String toString() { return "zip.setLevel(Deflater.DEFAULT_COMPRESSION);"; } public void close() throws Exception { zip.setLevel(Deflater.DEFAULT_COMPRESSION); } }; } static public void copyFileToStream(File src, OutputStream out) { try { file2stream(src, out); } catch (Exception __e) { throw rethrow(__e); } } static public byte[] randomBytes(int n) { byte[] l = new byte[n]; for (int i = 0; i < n; i++) l[i] = randomByte(); return l; } static public int colorToRGBA(Color c) { return c.getRGB(); } static public BufferedImage bufferedImageFromFunctionWithAlpha(int w, IF2_Int f) { return bufferedImageFromFunctionWithAlpha(w, w, f); } static public BufferedImage bufferedImageFromFunctionWithAlpha(int w, int h, IF2_Int f) { return imageFromFunctionWithAlpha(w, h, f); } static public BufferedImage imageFromFunctionWithoutAlpha(int w, IF2_Int f) { return imageFromFunctionWithoutAlpha(w, w, f); } static public BufferedImage imageFromFunctionWithoutAlpha(int w, int h, IF2_Int f) { int[] pixels = new int[w * h]; int i = 0; for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) pixels[i++] = f.get(x, y); return intArrayToBufferedImageWithoutAlpha(pixels, w, h); } static public void zip_addTextFile(ZipOutputStream outZip, String name, String text) { try { if (text == null) return; byte[] utf8 = toUtf8(text); ZipEntry e = new ZipEntry(name); e.setSize(l(utf8)); outZip.putNextEntry(e); outZip.write(utf8, 0, l(utf8)); } catch (Exception __e) { throw rethrow(__e); } } static public void saveQOI(BufferedImage img, File file) { try { QOIImageWriterSPI spi = new QOIImageWriterSPI(); var imageWriter = spi.createWriterInstance(); try { var stream = ImageIO.createImageOutputStream(file); imageWriter.setOutput(stream); imageWriter.write(img); } finally { imageWriter.dispose(); } vmBus_send("wroteFile", file); } catch (Exception __e) { throw rethrow(__e); } } static public void saveQOI(File file, BufferedImage img) { saveQOI(img, file); } static public short hi15(int r, int g, int b) { return (short) ((r << 10) | (g << 5) | b); } static public JavaClass classToBCEL(Class c) { try { InputStream in = inputStreamForClass(c); try { return in == null ? null : new ClassParser(in, c.getName() + ".class").parse(); } finally { _close(in); } } catch (Exception __e) { throw rethrow(__e); } } static public JavaClass classToBCEL(Object o) { return classToBCEL(_getClass(o)); } static public void printWithNLBeforeAndAfter(Object o) { print_doubleNL(o); } static public BufferedReader utf8Reader(InputStream in) { return utf8BufferedReader(in); } static public BufferedReader utf8Reader(File f) { return utf8BufferedReader(f); } static public String repString(int n, String s) { return repeatString(s, n); } static public String repString(String s, int n) { return repeatString(s, n); } static public Map initHashMap(Map map) { return map != null ? map : new HashMap(); } static public boolean isConceptClassIndexed(Class c) { return isConceptClassIndexed(db_mainConcepts(), c); } static public boolean isConceptClassIndexed(Concepts concepts, Class c) { return concepts.conceptCounterForClass(c) != null; } static public void indexRandomConceptField(Class c) { indexRandomConceptField(db_mainConcepts(), c); } static public void indexRandomConceptField(Concepts cc, Class c) { String field = or(first(conceptFields(c)), "_dummy"); print("Indexing " + c + "." + field); indexConceptField(cc, c, field); assertTrue("Concept class indexed", isConceptClassIndexed(cc, c)); { long _startTime_0 = sysNow(); try { print("Got " + nConcepts(countConcepts(cc, c))); } finally { _startTime_0 = sysNow() - _startTime_0; saveTiming(_startTime_0); } } } static public Object[] changeParam(Object[] params, String name, Object value) { if (eq(optPar(params, name), value)) return params; Map map = paramsToOrderedMap(params); map.put(name, value); return mapToParams(map); } static public int indexOfAfter(String a, String b) { int i = indexOf(a, b); return i >= 0 ? i + l(b) : i; } static public List splitAtTokens(String s, List tokens) { return splitAtTokens(javaTok(s), tokens); } static public List splitAtTokens(List tok, List tokens) { List l = new ArrayList(); int i = 0; while (i < l(tok)) { int j = indexOfSubList(tok, tokens, i); if (i >= l(tok)) break; if (j < 0) j = l(tok); l.add(trimJoin(tok.subList(i, j))); i = j + l(tokens); } return l; } static public List splitAtTokens(List tok, String... tokens) { List l = new ArrayList(); int i = 0; while (i < l(tok)) { int j = indexOfSubList(tok, tokens, i); if (i >= l(tok)) break; if (j < 0) j = l(tok); l.add(trimJoin(tok.subList(i, j))); i = j + l(tokens); } return l; } static public Map> javaTokWithAllBrackets_cached_cache = synchronizedMRUCache(defaultTokenizerCacheSize()); static public List javaTokWithAllBrackets_cached(String s) { List tok = javaTokWithAllBrackets_cached_cache.get(s); if (tok == null) javaTokWithAllBrackets_cached_cache.put(s, tok = javaTokWithAllBrackets(s)); return tok; } static public Pair pairMap(Object f, Pair p) { return p == null ? null : pair(callF(f, p.a), callF(f, p.b)); } static public Pair pairMap(IF1 f, Pair p) { return p == null ? null : pair(callF(f, p.a), callF(f, p.b)); } static public Pair pairMap(Pair p, Object f) { return pairMap(f, p); } static public Map unwrapSynchronizedMap(Map map) { if (eqOneOf(shortClassName(map), "SynchronizedMap", "SynchronizedSortedMap", "SynchronizedNavigableMap")) return (Map) get_raw(map, "m"); return map; } static public List splitAtAmpersand(String s) { return s == null ? emptyList() : asList(s.split("&")); } static public String urldecode(String x) { try { return URLDecoder.decode(unnull(x), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } } static public String dropAfterSubstring(String s, String b) { return substring(s, 0, smartIndexOf(s, b)); } static public long inMemorySizeOfObjectArray(int length) { return roundUpTo(javaDataModelWordSize(), unsafe_sizeOf(_SimulatedArrayStub.class) + java_pointerSize() * ((long) length)); } static public long inMemorySizeOfPrimitiveArray(Object o) { return roundUpTo(javaDataModelWordSize(), unsafe_sizeOf(_SimulatedArrayStub.class) + primitiveTypeSize(arrayElementType(o)) * ((long) Array.getLength(o))); } static public int javaDataModelWordSize_value; static public int javaDataModelWordSize() { if (javaDataModelWordSize_value == 0) javaDataModelWordSize_value = Integer.valueOf(System.getProperty("sun.arch.data.model")) / 8; return javaDataModelWordSize_value; } static public long unsafe_objectFieldOffset(Field f) { return (long) call(theUnsafe_gen(), "objectFieldOffset", f); } static public Object theUnsafe_gen_theUnsafe; static public Object theUnsafe_gen() { if (theUnsafe_gen_theUnsafe == null) theUnsafe_gen_theUnsafe = get(classForName("sun.misc.Unsafe"), "theUnsafe"); return theUnsafe_gen_theUnsafe; } static public String lightlyShortClassName(Object o) { if (o == null) return null; return lightlyShortenClassName(className(o)); } static public String regexReplaceIC(String s, String pat, Object f) { return regexReplace(regexpMatcherIC(pat, s), f); } static public String regexReplaceIC(String s, String pat, String replacement) { return regexpReplaceIC_direct(s, pat, replacement); } static public Set nonTransientNonStaticFields(Object o) { return allNonStaticNonTransientFields(o); } static public Set cloneSet(Collection set) { if (set == null) return new HashSet(); synchronized (collectionMutex(set)) { Set s = similarEmptySet(set); s.addAll(set); return s; } } static public JTable setTableFontSizes(float size, JTable table) { if (table == null) return null; { swing(() -> { setFontSize(table.getTableHeader(), size); setFontSize(table, size); }); } return table; } static public JTable setTableFontSizes(JTable table, float size) { return setTableFontSizes(size, table); } static public JTable setRowHeight(final int h, final JTable t) { if (t != null) { swing(() -> { t.setRowHeight(h); }); } return t; } static public JTable setRowHeight(JTable t, int h) { return setRowHeight(h, t); } static public int fontSizeToRowHeight(float fontSize, JTable table) { return iround(fontSize * 1.5); } static public String addPlusIfPositive(String s) { return isPositiveNumberString(s) ? addPrefix("+", s) : s; } static public boolean isRelativeURL(String s) { return startsWithOneOf(s, "/", "./", "../"); } static public Cache oshi_systemInfo_cache = new Cache<>(() -> oshi_systemInfo_load()); static public SystemInfo oshi_systemInfo() { return oshi_systemInfo_cache.get(); } static public SystemInfo oshi_systemInfo_load() { return new SystemInfo(); } static public String getHtmlTagParameter(String tag, String key) { return getHtmlTagParameters(tag).get(key); } static public byte randomByte() { return (byte) random(256); } static public int randomByte(Random random) { return (byte) random(random, 256); } static public BufferedImage imageFromFunctionWithAlpha(int w, IF2_Int f) { return imageFromFunctionWithAlpha(w, w, f); } static public BufferedImage imageFromFunctionWithAlpha(int w, int h, IF2_Int f) { int[] pixels = new int[w * h]; int i = 0; for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) pixels[i++] = f.get(x, y); return intArrayToBufferedImageWithAlpha(pixels, w, h); } static public InputStream inputStreamForClass(Class c) { try { if (c == null) return null; ClassLoader cl = getClassLoader(c); if (cl instanceof InMemoryClassLoader) { byte[] bytes = ((InMemoryClassLoader) cl).getClassBytes(c); if (bytes != null) return byteArrayInputStream(bytes); } Collection files = (Collection) (getOpt(cl, "files")); if (files != null) { String name = c.getName().replace('.', '/') + ".class"; for (File location : files) { InputStream in = inputStreamForFileInDirOrZip(location, name); if (in != null) return in; } throw fail(name + " not found in: " + files); } return null; } catch (Exception __e) { throw rethrow(__e); } } static public void print_doubleNL(Object o) { print("\n" + str(o) + "\n"); } static public String repeatString(String s, int n) { StringBuilder buf = new StringBuilder(l(s) * n); for (int i = 0; i < n; i++) buf.append(s); return str(buf); } static public String nConcepts(long n) { return n2(n, "concept"); } static public String nConcepts(Collection l) { return nConcepts(l(l)); } static public String nConcepts(Map map) { return nConcepts(l(map)); } static public ThreadLocal saveTiming_last = new ThreadLocal(); static public void saveTiming(long ms) { print(ms + " ms"); saveTiming_noPrint(ms); } static public void saveTiming_noPrint(long ms) { saveTiming_last.set(ms); } static public ThreadLocal saveTiming_tl() { return saveTiming_last; } static public String trimJoin(List s) { return trim(join(s)); } static public int defaultTokenizerCacheSize() { return 1000; } static public List javaTokWithAllBrackets(String s) { return javaTokPlusBrackets2(s); } static public int java_pointerSize() { boolean c = compressedOOPSEnabled(); return compressedOOPSEnabled_is64bitHotSpot && !c ? 8 : 4; } static public int primitiveTypeSize(Class c) { if (c == byte.class || c == boolean.class) return 1; if (c == short.class || c == char.class) return 2; if (c == int.class || c == float.class) return 4; if (c == long.class || c == double.class) return 8; return 0; } static public Class arrayElementType(Object o) { return _getClass(o).getComponentType(); } static public String lightlyShortenClassName(String name) { if (name == null) return null; int i = indexOf(name, "$"); if (i < 0) i = indexOf(name, "."); return i < 0 ? name : substring(name, i + 1); } static public String regexpReplaceIC_direct(String s, String pat, String replacement) { Matcher m = regexpIC(pat, s); StringBuffer buf = new StringBuffer(); while (m.find()) m.appendReplacement(buf, replacement); m.appendTail(buf); return str(buf); } static public boolean isPositiveNumberString(String s) { return regexpFind("^\\+|^0*[1-9]|^0*\\.0*[1-9]", s); } static public boolean getHtmlTagParameters_debug = false; static public Map getHtmlTagParameters(String tag) { if (empty(tag)) return null; List tok = codeTokens(tok_joinMinusIdentifiers(htmlFineTok(tag))); if (getHtmlTagParameters_debug) printStruct(tok); assertEquals("<", tok.get(0)); int i = 1; if (eq(tok.get(1), "/")) ++i; String name = tok.get(i++); if (!isMinusIdentifier(name)) throw fail(tag + " (" + name + ")"); Map map = new HashMap(); while (i < l(tok)) { String t = tok.get(i); if (eqOneOf(t, "/", ">")) break; if (!isMinusIdentifier(t)) throw fail(tag + " (" + t + ")"); ++i; String value = "1"; if (eq(tok.get(i), "=")) { ++i; value = htmlunquote(tok.get(i++)); } map.put(t, value); } return map; } static public BufferedImageWithMeta intArrayToBufferedImageWithAlpha(int[] pixels, int w) { return intArrayToBufferedImageWithAlpha(pixels, w, pixels.length / w); } static public BufferedImageWithMeta intArrayToBufferedImageWithAlpha(int[] pixels, int w, int h) { return intArrayToBufferedImage(pixels, w, h); } static public BufferedImageWithMeta intArrayToBufferedImageWithAlpha(int w, int... pixels) { return intArrayToBufferedImage(w, pixels); } static public ByteArrayInputStream byteArrayInputStream(byte[] data) { return new ByteArrayInputStream(data); } static public InputStream inputStreamForFileInDirOrZip(File location, String subPath) { try { if (location.isDirectory()) { File f = new File(location, subPath); return f.exists() ? newFileInputStream(f) : null; } else if (location.isFile()) { InputStream in = zipFileInputStream(location, subPath); if (in != null) return in; } return null; } catch (Exception __e) { throw rethrow(__e); } } static public List javaTokPlusBrackets2(String s) { return tok_combineRoundCurlySquareBrackets_keep(javaTok(s)); } static public boolean compressedOOPSEnabled_is64bitHotSpot = false; static public boolean compressedOOPSEnabled_compressedOOPS = false; static public boolean compressedOOPSEnabled_checked = false; static public boolean compressedOOPSEnabled() { if (compressedOOPSEnabled_checked) return compressedOOPSEnabled_compressedOOPS; String OS_ARCH = System.getProperty("os.arch"); String MANAGEMENT_FACTORY_CLASS = "java.lang.management.ManagementFactory"; String HOTSPOT_BEAN_CLASS = "com.sun.management.HotSpotDiagnosticMXBean"; String x = System.getProperty("sun.arch.data.model"); boolean is64Bit = contains(or(x, OS_ARCH), "64"); if (is64Bit) { compressedOOPSEnabled_is64bitHotSpot = true; compressedOOPSEnabled_compressedOOPS = !eq("false", getHotspotVMOption("UseCompressedOops")); } compressedOOPSEnabled_checked = true; return compressedOOPSEnabled_compressedOOPS; } static public List tok_joinMinusIdentifiers(List tok) { for (int i = 1; i + 4 < l(tok); i += 2) if (isMinusIdentifier(get(tok, i)) && eq(get(tok, i + 2), "-") && isIdentifier(get(tok, i + 4))) { replaceSublist(tok, i, i + 5, ll(join(subList(tok, i, i + 5)))); i -= 2; } return tok; } static public List htmlFineTok(String s) { List tok = new ArrayList(); int l = s.length(); int i = 0, n = 0; while (i < l) { int j = i; char c, d; while (j < l) { c = s.charAt(j); d = j + 1 >= l ? '\0' : s.charAt(j + 1); if (c == ' ' || c == '\t' || c == '\r' || c == '\n') ++j; else break; } tok.add(quickSubstring(s, i, j)); ++n; i = j; if (i >= l) break; c = s.charAt(i); d = i + 1 >= l ? '\0' : s.charAt(i + 1); if (c == '\'' || c == '"') { char opener = c; ++j; while (j < l) { if (s.charAt(j) == opener) { ++j; break; } else if (s.charAt(j) == '\\' && j + 1 < l) j += 2; else ++j; } } else if (Character.isJavaIdentifierStart(c)) do ++j; while (j < l && (Character.isJavaIdentifierPart(s.charAt(j)) || "'".indexOf(s.charAt(j)) >= 0)); else if (Character.isDigit(c)) { do ++j; while (j < l && Character.isDigit(s.charAt(j))); if (j < l && s.charAt(j) == 'L') ++j; } else ++j; tok.add(quickSubstring(s, i, j)); ++n; i = j; } if ((tok.size() % 2) == 0) tok.add(""); return tok; } static public boolean isMinusIdentifier(String s) { if (empty(s)) return false; if (!Character.isJavaIdentifierStart(s.charAt(0)) && !s.startsWith("-")) return false; for (int i = 1; i < s.length(); i++) if (!Character.isJavaIdentifierPart(s.charAt(i)) && s.charAt(i) != '-') return false; return true; } static public String htmlunquote(String s) { if (s.startsWith("'") && s.endsWith("'") && s.length() >= 2 || s.startsWith("\"") && s.endsWith("\"") && s.length() >= 2) s = s.substring(1, s.length() - 1); return htmldecode(s); } static public InputStream zipFileInputStream(File inZip, String fileName) { try { ZipFile zip = new ZipFile(inZip); return zipInputStream(zip, fileName); } catch (Exception __e) { throw rethrow(__e); } } static public List tok_combineRoundCurlySquareBrackets_keep(List tok) { List l = new ArrayList(); for (int i = 0; i < l(tok); i++) { String t = tok.get(i); if (odd(i) && eqOneOf(t, "{", "(", "[")) { int j = findEndOfBracketPart2(tok, i); l.add(joinSubList(tok, i, j)); i = j - 1; } else l.add(t); } return l; } static public Object getHotspotVMOption(String optionName) { try { String MANAGEMENT_FACTORY_CLASS = "java.lang.management.ManagementFactory"; String HOTSPOT_BEAN_CLASS = "com.sun.management.HotSpotDiagnosticMXBean"; Class beanClazz = Class.forName(HOTSPOT_BEAN_CLASS); Object hotSpotBean = call(Class.forName(MANAGEMENT_FACTORY_CLASS), "getPlatformMXBean", beanClazz); if (hotSpotBean == null) return null; Object vmOption = call(hotSpotBean, "getVMOption", optionName); return call(vmOption, "getValue"); } catch (Throwable __e) { print(exceptionToStringShort(__e)); } return null; } static public int findEndOfBracketPart2(List cnc, int i) { int j = i + 2, level = 1; while (j < cnc.size()) { if (eqOneOf(cnc.get(j), "{", "(", "[")) ++level; else if (eqOneOf(cnc.get(j), "}", ")", "]")) --level; if (level == 0) return j + 1; ++j; } return cnc.size(); } static public class HashBinaryImage implements IFieldsToList { public IBinaryImage img; public HashBinaryImage() { } public HashBinaryImage(IBinaryImage img) { this.img = img; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + img + ")"; } public Object[] _fieldsToList() { return new Object[] { img }; } public long hash; public long get() { if (img == null) return hash; var img = this.img.toImage2B(); int w = img.getWidth(), h = img.getHeight(); int n = w * h; byte[] pixels = img.pixels; addToHash(w); addToHash(h); for (int i = 0; i < n; i++) addToHash((pixels[i / 8] & (1 << (i & 7))) != 0 ? 0xFFFFFFFF : 0xFF000000); return hash; } public void addToHash(long x) { hash = boostHashCombine64(hash, x); } } static public class G22LAScratchpad extends ConceptWithChangeListeners { static final public String _fieldOrder = "text ide"; public transient FieldVar varText_cache; public FieldVar varText() { if (varText_cache == null) varText_cache = varText_load(); return varText_cache; } public FieldVar varText_load() { return new FieldVar(this, "text", () -> text(), text -> text(text)); } final public G22LAScratchpad setText(String text) { return text(text); } public G22LAScratchpad text(String text) { if (!eq(this.text, text)) { this.text = text; change(); } return this; } final public String getText() { return text(); } public String text() { return text; } public String text; transient public JLeftArrowScriptIDE ide; public G22Utils g22utils() { return main.g22utils(this); } public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { ide = g22utils().leftArrowScriptIDE(); ide.sourceInfo("Scratchpad"); var btnSave = jImageButton("#1103084", "Save script", runnableThread(new Runnable() { public void run() { try { saveAsNewScript(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "saveAsNewScript();"; } })); int idx = 0; while (getComponentAtIndex(ide.buttons(), idx) instanceof SingleComponentPanel) idx++; addComponentAtIndex(ide.buttons(), idx, btnSave); ide.sectionTitle("Left Arrow Script Scratchpad"); ide.lvScript(varText()); return withTopMargin(ide.visualize()); } public void saveAsNewScript() { g22utils().projectActions().saveAsNewScript(text); } } static public class G22MakeMaskCorrelationMatrix implements MakesBufferedImage { final public G22MakeMaskCorrelationMatrix setImagesH(long[][] imagesH) { return imagesH(imagesH); } public G22MakeMaskCorrelationMatrix imagesH(long[][] imagesH) { this.imagesH = imagesH; return this; } final public long[][] getImagesH() { return imagesH(); } public long[][] imagesH() { return imagesH; } public long[][] imagesH; final public G22MakeMaskCorrelationMatrix setImagesW(long[][] imagesW) { return imagesW(imagesW); } public G22MakeMaskCorrelationMatrix imagesW(long[][] imagesW) { this.imagesW = imagesW; return this; } final public long[][] getImagesW() { return imagesW(); } public long[][] imagesW() { return imagesW; } public long[][] imagesW; final public int[] getMatrix() { return matrix(); } public int[] matrix() { return matrix; } public int[] matrix; public G22MakeMaskCorrelationMatrix images(long[][] images) { return imagesW(images).imagesH(images); } public G22MakeMaskCorrelationMatrix images(List images) { return images(toArray(long[].class, images)); } public int w() { return imagesH.length; } public int h() { return imagesW.length; } public int maxPixelDiff() { return l(first(imagesW)) * 64; } public boolean symmetrical() { return imagesW == imagesH; } public void run() { try { int w = w(), h = h(); var matrix = this.matrix = new int[w * h]; int i = 0; if (symmetrical()) for (int y = 0; y < h; y++) { long[] imageH = imagesH[y]; int x = 0, i2 = y; for (; x < y; x++, i2 += w) matrix[i++] = matrix[i2]; for (; x < w; x++) matrix[i++] = countDifferingBits(imageH, imagesW[x]); } else for (int y = 0; y < h; y++) { long[] imageH = imagesH[y]; for (int x = 0; x < w; x++) matrix[i++] = countDifferingBits(imageH, imagesW[x]); } } catch (Exception __e) { throw rethrow(__e); } } public FloatBWImage get() { if (matrix == null) run(); int w = w(), h = h(); float max = maxPixelDiff(); return floatBWImageFromFunction(w, h, (x, y) -> 1f - matrix[y * w + x] / max); } public BufferedImage getBufferedImage() { return toBufferedImage(get()); } } static public class G22ScreenPart extends ConceptWithChangeListeners { static final public String _fieldOrder = "name bounds"; public String name; public Rect bounds; public String toString() { return commaCombine(name, str_megapixels(bounds)); } } static public class G22LetterRecognizer1 implements IFieldsToList { public SnPSettings snpSettings; public IMultiMap thumbnailToUnicode; public G22LetterRecognizer1() { } public G22LetterRecognizer1(SnPSettings snpSettings, IMultiMap thumbnailToUnicode) { this.thumbnailToUnicode = thumbnailToUnicode; this.snpSettings = snpSettings; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + snpSettings + ", " + thumbnailToUnicode + ")"; } public Object[] _fieldsToList() { return new Object[] { snpSettings, thumbnailToUnicode }; } public HashedBWImage exampleImage() { return firstKey(thumbnailToUnicode); } } static public class G22Challenge extends G22LeftArrowScript { static final public String _fieldOrder = "type usesRNG type_singleImage type_animation types lvType lvUsesRNG"; public String type = "Single Image"; public boolean usesRNG = false; static public String type_singleImage = "Single Image"; static public String type_animation = "Animation"; static public List types = ll(type_singleImage, type_animation); public void _onChange() { super._onChange(); { if (lvType != null) lvType.set(type); } { if (lvUsesRNG != null) lvUsesRNG.set(usesRNG); } } transient public SimpleLiveValue lvType; synchronized public SimpleLiveValue lvType() { { if (lvType == null) lvType = new SimpleLiveValue(String.class, type).onChange(new Runnable() { public void run() { try { setField("type", lvType.get()); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "setField(type := lvType!);"; } }); return lvType; } } transient public SimpleLiveValue lvUsesRNG; synchronized public SimpleLiveValue lvUsesRNG() { { if (lvUsesRNG == null) lvUsesRNG = new SimpleLiveValue(Boolean.class, usesRNG).onChange(new Runnable() { public void run() { try { setField("usesRNG", lvUsesRNG.get()); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "setField(usesRNG := lvUsesRNG!);"; } }); return lvUsesRNG; } } } static public class G22MaskUtils implements IFieldsToList { public G22Utils g22utils; public G22MaskUtils() { } public G22MaskUtils(G22Utils g22utils) { this.g22utils = g22utils; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")"; } public Object[] _fieldsToList() { return new Object[] { g22utils }; } public IG22SimpleMasksHolder simpleMaskSet() { return new G22HashedMasks(); } public IG22MasksHolder optimizedMaskSet(IG22MasksHolder masks) { var search = new G22CriticalPixelSearch(masks); return search.bestTree(); } } static public class G22GalleryImage extends ConceptWithChangeListeners { public transient FieldVar varPath_cache; public FieldVar varPath() { if (varPath_cache == null) varPath_cache = varPath_load(); return varPath_cache; } public FieldVar varPath_load() { return new FieldVar(this, "path", () -> path(), path -> path(path)); } final public G22GalleryImage setPath(File path) { return path(path); } public G22GalleryImage path(File path) { if (!eq(this.path, path)) { this.path = path; change(); } return this; } final public File getPath() { return path(); } public File path() { return path; } public File path; public String toString() { return fileName(path); } public boolean imageExists() { return fileExists(path); } final public BufferedImage image() { return load(); } final public BufferedImage getImage() { return load(); } public BufferedImage load() { return loadImage2(path); } public File imageFile() { return path; } } static public class AllThreadsProfiler extends AbstractProfiler { public String toString() { return shortClassName(this); } public void stepImpl() { Map map = runnableThreadsWithStackTraces(); Lock __1 = lock; lock(__1); try { samples++; for (var __0 : _entrySet(map)) { var t = __0.getKey(); var stackTrace = __0.getValue(); if (!isSystemThread(t)) addSample(stackTrace); } } finally { unlock(__1); } } } static public class MPM { final public PositionSet getImaginaryPositions() { return imaginaryPositions(); } public PositionSet imaginaryPositions() { return imaginaryPositions; } public PositionSet imaginaryPositions = new PositionSet(); final public PositionSet getRealPositions() { return realPositions(); } public PositionSet realPositions() { return realPositions; } public PositionSet realPositions = new PositionSet(); final public MPM setCryptoPrice(double cryptoPrice) { return cryptoPrice(cryptoPrice); } public MPM cryptoPrice(double cryptoPrice) { this.cryptoPrice = cryptoPrice; return this; } final public double getCryptoPrice() { return cryptoPrice(); } public double cryptoPrice() { return cryptoPrice; } public double cryptoPrice; public DoubleBuffer cryptoPriceLog = new DoubleBuffer(); final public MPM setCryptoDirection(int cryptoDirection) { return cryptoDirection(cryptoDirection); } public MPM cryptoDirection(int cryptoDirection) { this.cryptoDirection = cryptoDirection; return this; } final public int getCryptoDirection() { return cryptoDirection(); } public int cryptoDirection() { return cryptoDirection; } public int cryptoDirection; transient public Set onCryptoDirectionChanged; public MPM onCryptoDirectionChanged(Runnable r) { onCryptoDirectionChanged = createOrAddToSyncLinkedHashSet(onCryptoDirectionChanged, r); return this; } public MPM removeCryptoDirectionChangedListener(Runnable r) { loadableUtils.utils.remove(onCryptoDirectionChanged, r); return this; } public void cryptoDirectionChanged() { if (onCryptoDirectionChanged != null) for (var listener : onCryptoDirectionChanged) pcallF_typed(listener); } final public MPM setCurrentTime(double currentTime) { return currentTime(currentTime); } public MPM currentTime(double currentTime) { this.currentTime = currentTime; return this; } final public double getCurrentTime() { return currentTime(); } public double currentTime() { return currentTime; } public double currentTime; final public MPM setMaxAllowedLoss(double maxAllowedLoss) { return maxAllowedLoss(maxAllowedLoss); } public MPM maxAllowedLoss(double maxAllowedLoss) { this.maxAllowedLoss = maxAllowedLoss; return this; } final public double getMaxAllowedLoss() { return maxAllowedLoss(); } public double maxAllowedLoss() { return maxAllowedLoss; } public double maxAllowedLoss = 1; public Position newShort() { return new Position().direction(-1); } public Position newLong() { return new Position().direction(1); } abstract public class CloseReason { } public class LossClose extends CloseReason { } public class HappyClose extends CloseReason { } public class RegularClose extends CloseReason { } public class KillClose extends CloseReason { } final public MPM setFees(double fees) { return fees(fees); } public MPM fees(double fees) { this.fees = fees; return this; } final public double getFees() { return fees(); } public double fees() { return fees; } public double fees = 0.12; final public MPM setExpectedSlippage(double expectedSlippage) { return expectedSlippage(expectedSlippage); } public MPM expectedSlippage(double expectedSlippage) { this.expectedSlippage = expectedSlippage; return this; } final public double getExpectedSlippage() { return expectedSlippage(); } public double expectedSlippage() { return expectedSlippage; } public double expectedSlippage = .1; public class Position { final public Position setReal(boolean real) { return real(real); } public Position real(boolean real) { this.real = real; return this; } final public boolean getReal() { return real(); } public boolean real() { return real; } public boolean real = false; final public Position setDirection(int direction) { return direction(direction); } public Position direction(int direction) { this.direction = direction; return this; } final public int getDirection() { return direction(); } public int direction() { return direction; } public int direction; final public Position setOpeningTime(double openingTime) { return openingTime(openingTime); } public Position openingTime(double openingTime) { this.openingTime = openingTime; return this; } final public double getOpeningTime() { return openingTime(); } public double openingTime() { return openingTime; } public double openingTime; final public Position setOpeningPrice(double openingPrice) { return openingPrice(openingPrice); } public Position openingPrice(double openingPrice) { this.openingPrice = openingPrice; return this; } final public double getOpeningPrice() { return openingPrice(); } public double openingPrice() { return openingPrice; } public double openingPrice; final public Position setLastPrice(double lastPrice) { return lastPrice(lastPrice); } public Position lastPrice(double lastPrice) { this.lastPrice = lastPrice; return this; } final public double getLastPrice() { return lastPrice(); } public double lastPrice() { return lastPrice; } public double lastPrice; final public Position setClosingTime(double closingTime) { return closingTime(closingTime); } public Position closingTime(double closingTime) { this.closingTime = closingTime; return this; } final public double getClosingTime() { return closingTime(); } public double closingTime() { return closingTime; } public double closingTime; final public Position setClosingPrice(double closingPrice) { return closingPrice(closingPrice); } public Position closingPrice(double closingPrice) { this.closingPrice = closingPrice; return this; } final public double getClosingPrice() { return closingPrice(); } public double closingPrice() { return closingPrice; } public double closingPrice; public Double openingPriceWithFeesAndSlippage_cache; public double openingPriceWithFeesAndSlippage() { if (openingPriceWithFeesAndSlippage_cache == null) openingPriceWithFeesAndSlippage_cache = openingPriceWithFeesAndSlippage_load(); return openingPriceWithFeesAndSlippage_cache; } public double openingPriceWithFeesAndSlippage_load() { return openingPrice * (1 + (fees + expectedSlippage) / 100 * direction); } final public Position setRelativeValue(double relativeValue) { return relativeValue(relativeValue); } public Position relativeValue(double relativeValue) { this.relativeValue = relativeValue; return this; } final public double getRelativeValue() { return relativeValue(); } public double relativeValue() { return relativeValue; } public double relativeValue; final public Position setMaxRelativeValue(double maxRelativeValue) { return maxRelativeValue(maxRelativeValue); } public Position maxRelativeValue(double maxRelativeValue) { this.maxRelativeValue = maxRelativeValue; return this; } final public double getMaxRelativeValue() { return maxRelativeValue(); } public double maxRelativeValue() { return maxRelativeValue; } public double maxRelativeValue = negativeInfinity(); final public Position setMinRelativeValue(double minRelativeValue) { return minRelativeValue(minRelativeValue); } public Position minRelativeValue(double minRelativeValue) { this.minRelativeValue = minRelativeValue; return this; } final public double getMinRelativeValue() { return minRelativeValue(); } public double minRelativeValue() { return minRelativeValue; } public double minRelativeValue = infinity(); final public Position setPullbackThreshold(double pullbackThreshold) { return pullbackThreshold(pullbackThreshold); } public Position pullbackThreshold(double pullbackThreshold) { this.pullbackThreshold = pullbackThreshold; return this; } final public double getPullbackThreshold() { return pullbackThreshold(); } public double pullbackThreshold() { return pullbackThreshold; } public double pullbackThreshold; final public Position setCloseReason(CloseReason closeReason) { return closeReason(closeReason); } public Position closeReason(CloseReason closeReason) { this.closeReason = closeReason; return this; } final public CloseReason getCloseReason() { return closeReason(); } public CloseReason closeReason() { return closeReason; } public CloseReason closeReason; public PositionSet motherList() { return real ? realPositions : imaginaryPositions; } public void close(CloseReason reason) { closingTime(time()); closingPrice(cryptoPrice); closeReason(reason); motherList().wasClosed(this); } public void imagine() { real(false); launch(); } public void launch() { update(cryptoPrice); motherList().add(this); } public void update(double cryptoPrice) { lastPrice(cryptoPrice); relativeValue((cryptoPrice / openingPriceWithFeesAndSlippage() - 1) * direction * 100); maxRelativeValue(max(maxRelativeValue, relativeValue)); minRelativeValue(min(minRelativeValue, relativeValue)); pullbackThreshold(maxRelativeValue - pullback(this)); } public String toString() { return renderVars("direction", direction, "openingPrice", openingPrice, "openingPriceWithFeesAndSlippage", openingPriceWithFeesAndSlippage(), "lastPrice", lastPrice, "relativeValue", relativeValue, "maxRelativeValue", maxRelativeValue); } public void autoClose() { if (relativeValue < -maxAllowedLoss) { close(new LossClose()); return; } if (relativeValue >= 0 && relativeValue < pullbackThreshold) { close(new RegularClose()); return; } } public boolean isOpen() { return closeReason == null; } } public class PositionSet { public LinkedHashSet positionsByDate = new LinkedHashSet(); public LinkedHashSet openPositions = new LinkedHashSet(); public LinkedHashSet closedPositions = new LinkedHashSet(); public void add(Position p) { positionsByDate.add(p); (p.isOpen() ? openPositions : closedPositions).add(p); } public void remove(Position p) { positionsByDate.remove(p); openPositions.remove(p); closedPositions.remove(p); } public void wasClosed(Position p) { openPositions.remove(p); closedPositions.add(p); } } transient public IF1 pullback; public double pullback(Position p) { return pullback != null ? pullback.get(p) : pullback_base(p); } final public double pullback_fallback(IF1 _f, Position p) { return _f != null ? _f.get(p) : pullback_base(p); } public double pullback_base(Position p) { return 0.5; } public double time() { return currentTime; } public void addTickerSequence(TickerSequence ts) { int n = l(ts); for (int i = 0; i < n; i++) newCryptoPrice(ts.prices.get(i), ts.timestamps.get(i)); } public void newCryptoPrice(double price) { newCryptoPrice(price, currentTime + 1); } public void newCryptoPrice(double price, double time) { currentTime(time); if (price == cryptoPrice) return; int direction = sign(cryptoPrice - price); cryptoPriceLog.add(price); cryptoPrice(price); for (var p : allOpenPositions()) { p.update(cryptoPrice); p.autoClose(); } if (direction != cryptoDirection) { cryptoDirection(direction); cryptoDirectionChanged(); } } public List allPositions() { return concatLists(realPositions().positionsByDate, imaginaryPositions().positionsByDate); } public List allOpenPositions() { return concatLists(realPositions().openPositions, imaginaryPositions().openPositions); } { init(); } public void init() { onCryptoDirectionChanged(() -> { for (var p : ll(newLong(), newShort())) p.openingTime(time()).openingPrice(cryptoPrice).imagine(); }); } public void printStatus() { print(toString()); } public String toString() { return combineWithSeparator(" + ", n2(realPositions.positionsByDate, "real position"), n2(imaginaryPositions.positionsByDate, "imaginary position")); } } static public class G22ProjectInfo extends Concept { static final public String _fieldOrder = "projectID projectDir defaultMaskSize compilationDate historicalProjectDirs useFirefox"; final public String getProjectID() { return projectID(); } public String projectID() { return projectID; } public String projectID = aGlobalID(); public File projectDir; final public G22MaskSize getDefaultMaskSize() { return defaultMaskSize(); } public G22MaskSize defaultMaskSize() { return defaultMaskSize; } public G22MaskSize defaultMaskSize = new G22MaskSize(); public String compilationDate; public List historicalProjectDirs = new ArrayList(); final public boolean getUseFirefox() { return useFirefox(); } public boolean useFirefox() { return useFirefox; } public boolean useFirefox = false; public void addHistoricalProjectDir(File dir) { if (syncSetAdd(historicalProjectDirs, dir)) change(); } } public interface G22ProjectActions { public void openObjectInProject(long id); public boolean openPathInProject(String path); public void editProjectStory(); public void editScripts(); public void editScript(G22LeftArrowScript script); public void openUIURL(String url); public IVarWithNotify varShowCasedScript(); public G22DatabasesPanel databasesPanel(); public void closeProject(); public G22Utils g22utils(); public DynamicVStack topStack(); public void saveAsNewScript(String text); public Set projectLibs(); public G22SelfTests selfTests(); public List projectErrors(); public void goToSource(TokenRangeWithSrc src); } static public class G22VisualizeMeshes implements IFieldsToList { public WidthAndHeight originalImage; public List meshes; public G22VisualizeMeshes() { } public G22VisualizeMeshes(WidthAndHeight originalImage, List meshes) { this.meshes = meshes; this.originalImage = originalImage; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + originalImage + ", " + meshes + ")"; } public Object[] _fieldsToList() { return new Object[] { originalImage, meshes }; } final public G22VisualizeMeshes setAnchorColor(Color anchorColor) { return anchorColor(anchorColor); } public G22VisualizeMeshes anchorColor(Color anchorColor) { this.anchorColor = anchorColor; return this; } final public Color getAnchorColor() { return anchorColor(); } public Color anchorColor() { return anchorColor; } public Color anchorColor = withAlpha(0.5, Color.red); final public G22VisualizeMeshes setAnchorSize(int anchorSize) { return anchorSize(anchorSize); } public G22VisualizeMeshes anchorSize(int anchorSize) { this.anchorSize = anchorSize; return this; } final public int getAnchorSize() { return anchorSize(); } public int anchorSize() { return anchorSize; } public int anchorSize = 5; final public G22VisualizeMeshes setCurveColor(Color curveColor) { return curveColor(curveColor); } public G22VisualizeMeshes curveColor(Color curveColor) { this.curveColor = curveColor; return this; } final public Color getCurveColor() { return curveColor(); } public Color curveColor() { return curveColor; } public Color curveColor = Color.blue; public BufferedImage get() { var markedImage = whiteImage(imageSize(originalImage)); drawOn(createGraphics(markedImage)); return markedImage; } public void drawOn(Graphics2D g) { for (var mesh : meshes) for (var curve : mesh.curves()) drawCurve(g, curve); for (var mesh : meshes) for (var p : mesh.anchorPts()) drawAnchor(g, p); } public void drawCurve(Graphics2D g, G22Mesh.Curve curve) { drawPixels(g, curve.path().pointIterator(), curveColor); } public void drawAnchor(Graphics2D g, Pt p) { fillRect(g, p.x - anchorSize / 2, p.y - anchorSize / 2, anchorSize, anchorSize, anchorColor); } } static public class JOnDemandWithReloadButton implements Swingable, IFieldsToList { public IF0 makeComponent; public JOnDemandWithReloadButton() { } public JOnDemandWithReloadButton(IF0 makeComponent) { this.makeComponent = makeComponent; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + makeComponent + ")"; } public Object[] _fieldsToList() { return new Object[] { makeComponent }; } public SingleComponentPanel scp = singleComponentPanel(); public ReliableSingleThread rstReload = rst(() -> reloadImpl()); public JButton btnReload; final public JOnDemandWithReloadButton setControls(JPanel controls) { return controls(controls); } public JOnDemandWithReloadButton controls(JPanel controls) { this.controls = controls; return this; } final public JPanel getControls() { return controls(); } public JPanel controls() { return controls; } public JPanel controls = rightAlignedLine(); public SingleComponentPanel scpControlsMain = scp(); final public JOnDemandWithReloadButton setLoadingScreenWhenReloading(boolean loadingScreenWhenReloading) { return loadingScreenWhenReloading(loadingScreenWhenReloading); } public JOnDemandWithReloadButton loadingScreenWhenReloading(boolean loadingScreenWhenReloading) { this.loadingScreenWhenReloading = loadingScreenWhenReloading; return this; } final public boolean getLoadingScreenWhenReloading() { return loadingScreenWhenReloading(); } public boolean loadingScreenWhenReloading() { return loadingScreenWhenReloading; } public boolean loadingScreenWhenReloading = false; final public JOnDemandWithReloadButton setShowControls(boolean showControls) { return showControls(showControls); } public JOnDemandWithReloadButton showControls(boolean showControls) { this.showControls = showControls; return this; } final public boolean getShowControls() { return showControls(); } public boolean showControls() { return showControls; } public boolean showControls = true; public void reload() { rstReload.trigger(); } public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { bindToComponent(scp, () -> { if (scp.isEmpty()) reload(); }, null); if (!showControls) return scp; makeControls(); return northAndCenter(withMargin(centerAndEastWithMargin(scpControlsMain, controls)), scp); } public void makeControls() { if (!showControls) return; btnReload = jReloadButton(() -> reload()); controls.add(btnReload); } public void reloadImpl() { AutoCloseable __1 = tempDisableButton(btnReload); try { if (loadingScreenWhenReloading() || !scp.hasComponent()) scp.setComponent(jCenteredLabel("Loading...")); try { scp.setComponent(makeComponent == null ? null : makeComponent.get()); } catch (Throwable e) { printStackTrace(e); scp.setComponent(jscroll(jFastLogView_noWrap(renderStackTrace(e)))); } } finally { _close(__1); } } public JOnDemandWithReloadButton function(IF0 f) { makeComponent = () -> wrap(f == null ? null : f.get()); return this; } } static public class FlexWebSocketClient extends WebSocketClient { public FlexWebSocketClient(URI uri) { super(uri); } public FlexWebSocketClient(URI uri, Map httpHeaders) { super(uri, httpHeaders); } final public FlexWebSocketClient setVerbose(boolean verbose) { return verbose(verbose); } public FlexWebSocketClient verbose(boolean verbose) { this.verbose = verbose; return this; } final public boolean getVerbose() { return verbose(); } public boolean verbose() { return verbose; } public boolean verbose = false; transient public Set> onOpened; public FlexWebSocketClient onOpened(IVF1 f) { onOpened = createOrAddToSyncLinkedHashSet(onOpened, f); return this; } public FlexWebSocketClient removeOpenedListener(IVF1 f) { loadableUtils.utils.remove(onOpened, f); return this; } public void opened(ServerHandshake handshake) { if (onOpened != null) for (var listener : onOpened) pcallF_typed(listener, handshake); } transient public Set> onGotMessage; public FlexWebSocketClient onGotMessage(IVF1 f) { onGotMessage = createOrAddToSyncLinkedHashSet(onGotMessage, f); return this; } public FlexWebSocketClient removeGotMessageListener(IVF1 f) { loadableUtils.utils.remove(onGotMessage, f); return this; } public void gotMessage(String message) { if (onGotMessage != null) for (var listener : onGotMessage) pcallF_typed(listener, message); } transient public Set> onClosed; public FlexWebSocketClient onClosed(IVF1 f) { onClosed = createOrAddToSyncLinkedHashSet(onClosed, f); return this; } public FlexWebSocketClient removeClosedListener(IVF1 f) { loadableUtils.utils.remove(onClosed, f); return this; } public void closed(CloseInfo info) { if (onClosed != null) for (var listener : onClosed) pcallF_typed(listener, info); } transient public Set> onError; public FlexWebSocketClient onError(IVF1 f) { onError = createOrAddToSyncLinkedHashSet(onError, f); return this; } public FlexWebSocketClient removeErrorListener(IVF1 f) { loadableUtils.utils.remove(onError, f); return this; } public void error(Exception error) { if (onError != null) for (var listener : onError) pcallF_typed(listener, error); } public class CloseInfo implements IFieldsToList { public int code; public String reason; public boolean remote = false; public CloseInfo() { } public CloseInfo(int code, String reason, boolean remote) { this.remote = remote; this.reason = reason; this.code = code; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + code + ", " + reason + ", " + remote + ")"; } public Object[] _fieldsToList() { return new Object[] { code, reason, remote }; } } public void onMessage(String s) { if (verbose) print("WebSocket received: " + s); gotMessage(s); } public void onOpen(ServerHandshake handshake) { if (verbose) print("WebSocket opened"); opened(handshake); } public void onClose(int code, String reason, boolean remote) { if (verbose) print("WebSocket closed, code " + code + ", reason: " + reason + ", remote: " + remote); closed(new CloseInfo(code, reason, remote)); } public void onError(Exception e) { printStackTrace(e); error(e); } } static public class G22PassiveTradingStrategy extends G22TradingStrategy { static final public String _fieldOrder = "tradingViewRegexp tradingViewPSFactor"; public transient FieldVar varTradingViewRegexp_cache; public FieldVar varTradingViewRegexp() { if (varTradingViewRegexp_cache == null) varTradingViewRegexp_cache = varTradingViewRegexp_load(); return varTradingViewRegexp_cache; } public FieldVar varTradingViewRegexp_load() { return new FieldVar(this, "tradingViewRegexp", () -> tradingViewRegexp(), tradingViewRegexp -> tradingViewRegexp(tradingViewRegexp)); } final public G22PassiveTradingStrategy setTradingViewRegexp(String tradingViewRegexp) { return tradingViewRegexp(tradingViewRegexp); } public G22PassiveTradingStrategy tradingViewRegexp(String tradingViewRegexp) { if (!eq(this.tradingViewRegexp, tradingViewRegexp)) { this.tradingViewRegexp = tradingViewRegexp; change(); } return this; } final public String getTradingViewRegexp() { return tradingViewRegexp(); } public String tradingViewRegexp() { return tradingViewRegexp; } public String tradingViewRegexp; public transient FieldVar varTradingViewPSFactor_cache; public FieldVar varTradingViewPSFactor() { if (varTradingViewPSFactor_cache == null) varTradingViewPSFactor_cache = varTradingViewPSFactor_load(); return varTradingViewPSFactor_cache; } public FieldVar varTradingViewPSFactor_load() { return new FieldVar(this, "tradingViewPSFactor", () -> tradingViewPSFactor(), tradingViewPSFactor -> tradingViewPSFactor(tradingViewPSFactor)); } final public G22PassiveTradingStrategy setTradingViewPSFactor(double tradingViewPSFactor) { return tradingViewPSFactor(tradingViewPSFactor); } public G22PassiveTradingStrategy tradingViewPSFactor(double tradingViewPSFactor) { if (!eq(this.tradingViewPSFactor, tradingViewPSFactor)) { this.tradingViewPSFactor = tradingViewPSFactor; change(); } return this; } final public double getTradingViewPSFactor() { return tradingViewPSFactor(); } public double tradingViewPSFactor() { return tradingViewPSFactor; } public double tradingViewPSFactor; public void price(double price) { if (currentPrice == price) return; currentPrice = price; afterStep(); change(); } public boolean tradingViewMatch(String text) { return empty(cleanedTradingViewRegexp()) || safeRegexpFindIC(cleanedTradingViewRegexp(), text); } public String cleanedTradingViewRegexp() { return trim(tradingViewRegexp); } public List addPassiveTradingStatus(List list) { if (nempty(tradingViewRegexp)) list.add("TradingView regexp: " + cleanedTradingViewRegexp()); return list; } public List status() { return addPassiveTradingStatus(super.status()); } public List activationStatus() { return addPassiveTradingStatus(super.activationStatus()); } public boolean hasTradingViewPSFactor() { return isNonZero(tradingViewPSFactor); } } static public class G22NetworksPanel extends G22CRUDAndDetailPanel { public SimpleCRUD_v2 makeCRUD() { var crud = new SimpleCRUD_v2<>(g22utils.concepts(), G22Network.class); crud.iconButtons(true); crud.excludeFieldsFromEditing("elements"); crud.createDuplicate = network -> (G22Network) g22utils.restructure(network); crud.entityName = () -> "Network"; crud.addButton(new JPopDownButton().content("Browse networks in other projects", (Runnable) () -> g22utils.openUIURL("Networks from all projects")).visualize()); return crud; } public JComponent makeDetailView(G22Network network) { return new JG22Network(g22utils, network).visualize(); } public SimpleCRUD_v2 networkCRUD() { return crud(); } public G22NetworksPanel g22utils(G22Utils g22utils) { super.g22utils(g22utils); return this; } } static public class G22TickerFile extends ConceptWithChangeListeners { static final public String _fieldOrder = "file creationDate modificationDate fileSize format markets timeRanges dateAnalyzed slowAnalysis"; public transient FieldVar varFile_cache; public FieldVar varFile() { if (varFile_cache == null) varFile_cache = varFile_load(); return varFile_cache; } public FieldVar varFile_load() { return new FieldVar(this, "file", () -> file(), file -> file(file)); } final public G22TickerFile setFile(File file) { return file(file); } public G22TickerFile file(File file) { if (!eq(this.file, file)) { this.file = file; change(); } return this; } final public File getFile() { return file(); } public File file() { return file; } public File file; public transient FieldVar varCreationDate_cache; public FieldVar varCreationDate() { if (varCreationDate_cache == null) varCreationDate_cache = varCreationDate_load(); return varCreationDate_cache; } public FieldVar varCreationDate_load() { return new FieldVar(this, "creationDate", () -> creationDate(), creationDate -> creationDate(creationDate)); } final public G22TickerFile setCreationDate(Timestamp creationDate) { return creationDate(creationDate); } public G22TickerFile creationDate(Timestamp creationDate) { if (!eq(this.creationDate, creationDate)) { this.creationDate = creationDate; change(); } return this; } final public Timestamp getCreationDate() { return creationDate(); } public Timestamp creationDate() { return creationDate; } public Timestamp creationDate; public transient FieldVar varModificationDate_cache; public FieldVar varModificationDate() { if (varModificationDate_cache == null) varModificationDate_cache = varModificationDate_load(); return varModificationDate_cache; } public FieldVar varModificationDate_load() { return new FieldVar(this, "modificationDate", () -> modificationDate(), modificationDate -> modificationDate(modificationDate)); } final public G22TickerFile setModificationDate(Timestamp modificationDate) { return modificationDate(modificationDate); } public G22TickerFile modificationDate(Timestamp modificationDate) { if (!eq(this.modificationDate, modificationDate)) { this.modificationDate = modificationDate; change(); } return this; } final public Timestamp getModificationDate() { return modificationDate(); } public Timestamp modificationDate() { return modificationDate; } public Timestamp modificationDate; public transient FieldVar varFileSize_cache; public FieldVar varFileSize() { if (varFileSize_cache == null) varFileSize_cache = varFileSize_load(); return varFileSize_cache; } public FieldVar varFileSize_load() { return new FieldVar(this, "fileSize", () -> fileSize(), fileSize -> fileSize(fileSize)); } final public G22TickerFile setFileSize(Long fileSize) { return fileSize(fileSize); } public G22TickerFile fileSize(Long fileSize) { if (!eq(this.fileSize, fileSize)) { this.fileSize = fileSize; change(); } return this; } final public Long getFileSize() { return fileSize(); } public Long fileSize() { return fileSize; } public Long fileSize; public transient FieldVar varFormat_cache; public FieldVar varFormat() { if (varFormat_cache == null) varFormat_cache = varFormat_load(); return varFormat_cache; } public FieldVar varFormat_load() { return new FieldVar(this, "format", () -> format(), format -> format(format)); } final public G22TickerFile setFormat(String format) { return format(format); } public G22TickerFile format(String format) { if (!eq(this.format, format)) { this.format = format; change(); } return this; } final public String getFormat() { return format(); } public String format() { return format; } public String format; public transient FieldVar> varMarkets_cache; public FieldVar> varMarkets() { if (varMarkets_cache == null) varMarkets_cache = varMarkets_load(); return varMarkets_cache; } public FieldVar> varMarkets_load() { return new FieldVar>(this, "markets", () -> markets(), markets -> markets(markets)); } final public G22TickerFile setMarkets(Collection markets) { return markets(markets); } public G22TickerFile markets(Collection markets) { if (!eq(this.markets, markets)) { this.markets = markets; change(); } return this; } final public Collection getMarkets() { return markets(); } public Collection markets() { return markets; } public Collection markets; public transient FieldVar> varTimeRanges_cache; public FieldVar> varTimeRanges() { if (varTimeRanges_cache == null) varTimeRanges_cache = varTimeRanges_load(); return varTimeRanges_cache; } public FieldVar> varTimeRanges_load() { return new FieldVar>(this, "timeRanges", () -> timeRanges(), timeRanges -> timeRanges(timeRanges)); } final public G22TickerFile setTimeRanges(List timeRanges) { return timeRanges(timeRanges); } public G22TickerFile timeRanges(List timeRanges) { if (!eq(this.timeRanges, timeRanges)) { this.timeRanges = timeRanges; change(); } return this; } final public List getTimeRanges() { return timeRanges(); } public List timeRanges() { return timeRanges; } public List timeRanges; public transient FieldVar varDateAnalyzed_cache; public FieldVar varDateAnalyzed() { if (varDateAnalyzed_cache == null) varDateAnalyzed_cache = varDateAnalyzed_load(); return varDateAnalyzed_cache; } public FieldVar varDateAnalyzed_load() { return new FieldVar(this, "dateAnalyzed", () -> dateAnalyzed(), dateAnalyzed -> dateAnalyzed(dateAnalyzed)); } final public G22TickerFile setDateAnalyzed(Timestamp dateAnalyzed) { return dateAnalyzed(dateAnalyzed); } public G22TickerFile dateAnalyzed(Timestamp dateAnalyzed) { if (!eq(this.dateAnalyzed, dateAnalyzed)) { this.dateAnalyzed = dateAnalyzed; change(); } return this; } final public Timestamp getDateAnalyzed() { return dateAnalyzed(); } public Timestamp dateAnalyzed() { return dateAnalyzed; } public Timestamp dateAnalyzed; transient volatile public IVF1 slowAnalysis; public String toString() { return or(fileName(file), super.toString()); } } abstract static public class G22WatchTarget { public void mainWindow(Window window) { } abstract public void configureScreenCamStream(ScreenCamStream stream); public String toolTip() { return null; } } static public class WatchScreen extends G22WatchTarget implements IFieldsToList { public int screenNr; public WatchScreen() { } public WatchScreen(int screenNr) { this.screenNr = screenNr; } public boolean equals(Object o) { if (!(o instanceof WatchScreen)) return false; WatchScreen __1 = (WatchScreen) o; return screenNr == __1.screenNr; } public int hashCode() { int h = -1787428357; h = boostHashCombine(h, _hashCode(screenNr)); return h; } public Object[] _fieldsToList() { return new Object[] { screenNr }; } public String toString() { return "Screen " + screenNr; } public void configureScreenCamStream(ScreenCamStream stream) { stream.useScreen(screenNr - 1); } } static public class WatchMouse extends G22WatchTarget implements IFieldsToList { static final public String _fieldOrder = "width height"; public int width; public int height; public WatchMouse(int width, int height) { this.height = height; this.width = width; } public boolean equals(Object o) { if (!(o instanceof WatchMouse)) return false; WatchMouse __2 = (WatchMouse) o; return width == __2.width && height == __2.height; } public int hashCode() { int h = 1876823350; h = boostHashCombine(h, _hashCode(width)); h = boostHashCombine(h, _hashCode(height)); return h; } public Object[] _fieldsToList() { return new Object[] { width, height }; } public WatchMouse() { height = 256; width = iround(height * 16.0 / 9); } public String toString() { return "Mouse"; } public void configureScreenCamStream(ScreenCamStream stream) { stream.area(mouseArea(width, height)); } @Override public String toolTip() { return "Watch an area of " + str_px(width, height) + " around the mouse pointer"; } } static public class WatchScreenWithMouse extends G22WatchTarget implements IFieldsToList { public WatchScreenWithMouse() { } public boolean equals(Object o) { return o instanceof WatchScreenWithMouse; } public int hashCode() { int h = -1449766972; return h; } public Object[] _fieldsToList() { return null; } public String toString() { return "Screen w/mouse"; } public void configureScreenCamStream(ScreenCamStream stream) { stream.useScreen(screenNrContaining(mouseLocationPt())); } @Override public String toolTip() { return "Watch the screen the mouse pointer is in"; } } static public class WatchOtherScreen extends G22WatchTarget implements IFieldsToList { public WatchOtherScreen() { } public boolean equals(Object o) { return o instanceof WatchOtherScreen; } public int hashCode() { int h = 1734016877; return h; } public Object[] _fieldsToList() { return null; } public String toString() { return "Other Screen"; } final public void setMainWindow(Window mainWindow) { mainWindow(mainWindow); } public void mainWindow(Window mainWindow) { this.mainWindow = mainWindow; } final public Window getMainWindow() { return mainWindow(); } public Window mainWindow() { return mainWindow; } transient public Window mainWindow; public void configureScreenCamStream(ScreenCamStream stream) { stream.useScreen(mod(screenNrOfWindow(mainWindow) + 1, numberOfScreens())); } @Override public String toolTip() { return "Watch the first screen the Gazelle window is NOT in"; } } static public class SmoothLabel extends JLabel { public SmoothLabel() { } public SmoothLabel(String text) { super(text); } public SmoothLabel(Icon icon) { super(icon); } public void paintComponent(Graphics g) { Graphics2D g2d = (Graphics2D) g; g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON); g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); super.paintComponent(g2d); } } static public class TunableParameters { public class Scrd extends Var> { final public Sc getScore() { return score(); } public Sc score() { return score; } public Sc score; public Scrd() { } public Scrd(Map a, Sc score) { super(a); this.score = score; } public String toString() { return actualScoreFunction.get(score) + ": " + str(get()); } public boolean isBest() { return this == best; } public boolean tiesBest() { return compareScrd(this, best) == 0; } public Object actualScore() { return actualScoreFunction.get(score); } } final public TunableParameters setScoreFunction(IF1, Sc> scoreFunction) { return scoreFunction(scoreFunction); } public TunableParameters scoreFunction(IF1, Sc> scoreFunction) { this.scoreFunction = scoreFunction; return this; } final public IF1, Sc> getScoreFunction() { return scoreFunction(); } public IF1, Sc> scoreFunction() { return scoreFunction; } public IF1, Sc> scoreFunction; final public TunableParameters setComparisonFunction(IF2_OOInt comparisonFunction) { return comparisonFunction(comparisonFunction); } public TunableParameters comparisonFunction(IF2_OOInt comparisonFunction) { this.comparisonFunction = comparisonFunction; return this; } final public IF2_OOInt getComparisonFunction() { return comparisonFunction(); } public IF2_OOInt comparisonFunction() { return comparisonFunction; } public IF2_OOInt comparisonFunction; final public TunableParameters setActualScoreFunction(IF1 actualScoreFunction) { return actualScoreFunction(actualScoreFunction); } public TunableParameters actualScoreFunction(IF1 actualScoreFunction) { this.actualScoreFunction = actualScoreFunction; return this; } final public IF1 getActualScoreFunction() { return actualScoreFunction(); } public IF1 actualScoreFunction() { return actualScoreFunction; } public IF1 actualScoreFunction = __1 -> id(__1); final public Scrd getBest() { return best(); } public Scrd best() { return best; } public Scrd best; public LinkedHashMap parameters = new LinkedHashMap(); public List parameterList = new ArrayList(); final public long getInstancesTested() { return instancesTested(); } public long instancesTested() { return instancesTested; } volatile public long instancesTested; transient public Set>> onTestingInstance; public TunableParameters onTestingInstance(IVF1> f) { onTestingInstance = createOrAddToSyncLinkedHashSet(onTestingInstance, f); return this; } public TunableParameters removeTestingInstanceListener(IVF1> f) { loadableUtils.utils.remove(onTestingInstance, f); return this; } public void testingInstance(Map instance) { if (onTestingInstance != null) for (var listener : onTestingInstance) pcallF_typed(listener, instance); } transient public Set> onInstanceScored; public TunableParameters onInstanceScored(IVF1 f) { onInstanceScored = createOrAddToSyncLinkedHashSet(onInstanceScored, f); return this; } public TunableParameters removeInstanceScoredListener(IVF1 f) { loadableUtils.utils.remove(onInstanceScored, f); return this; } public void fireInstanceScored(Scrd scored) { if (onInstanceScored != null) for (var listener : onInstanceScored) pcallF_typed(listener, scored); } transient public Set> onNewBest; public TunableParameters onNewBest(IVF1 f) { onNewBest = createOrAddToSyncLinkedHashSet(onNewBest, f); return this; } public TunableParameters removeNewBestListener(IVF1 f) { loadableUtils.utils.remove(onNewBest, f); return this; } public void newBest(Scrd instance) { if (onNewBest != null) for (var listener : onNewBest) pcallF_typed(listener, instance); } abstract public class Parameter { final public Parameter setName(String name) { return name(name); } public Parameter name(String name) { this.name = name; return this; } final public String getName() { return name(); } public String name() { return name; } public String name; final public Parameter setDefaultValue(A defaultValue) { return defaultValue(defaultValue); } public Parameter defaultValue(A defaultValue) { this.defaultValue = defaultValue; return this; } final public A getDefaultValue() { return defaultValue(); } public A defaultValue() { return defaultValue; } public A defaultValue; abstract public A randomValue(); public A get(Map instance) { return (A) instance.get(name); } public TunableParameters tuner() { return TunableParameters.this; } } public class IntRangeParameter extends Parameter { final public IntRangeParameter setRange(IntRange range) { return range(range); } public IntRangeParameter range(IntRange range) { this.range = range; return this; } final public IntRange getRange() { return range(); } public IntRange range() { return range; } public IntRange range; final public IntRangeParameter setStep(int step) { return step(step); } public IntRangeParameter step(int step) { this.step = step; return this; } final public int getStep() { return step(); } public int step() { return step; } public int step = 1; public Integer randomValue() { return random(range); } public IntRangeParameter fixedValue(int value) { defaultValue(value); range(intRange(value, value)); return this; } } public class DoubleRangeParameter extends Parameter { final public DoubleRangeParameter setRange(DoubleRange range) { return range(range); } public DoubleRangeParameter range(DoubleRange range) { this.range = range; return this; } final public DoubleRange getRange() { return range(); } public DoubleRange range() { return range; } public DoubleRange range; final public DoubleRangeParameter setStep(double step) { return step(step); } public DoubleRangeParameter step(double step) { this.step = step; return this; } final public double getStep() { return step(); } public double step() { return step; } public double step = .1; public Double randomValue() { return random(range); } public DoubleRangeParameter fixedValue(double value) { defaultValue(value); range(doubleRange(value, value)); return this; } } public A add(A p) { parameters.put(p.name(), p); parameterList.add(p); return p; } public IntRangeParameter intParam(String name, int defaultValue, int min, int max) { IntRangeParameter p = new IntRangeParameter(); p.range(intRange(min, max)).defaultValue(defaultValue).name(name); return add(p); } public DoubleRangeParameter doubleParam(String name, double defaultValue, double min, double max) { return doubleParam(name, defaultValue, min, max, .1); } public DoubleRangeParameter doubleParam(String name, double defaultValue, double min, double max, double step) { DoubleRangeParameter p = new DoubleRangeParameter(); p.range(doubleRange(min, max)).step(step).defaultValue(defaultValue).name(name); return add(p); } public Map randomInstance() { Map map = new LinkedHashMap(); for (var param : parameterList) map.put(param.name(), param.randomValue()); return map; } public Map defaultInstance() { Map map = new LinkedHashMap(); for (var param : parameterList) map.put(param.name(), param.defaultValue()); return map; } public Scrd tryARandomCombination() { return tryInstance(randomInstance()); } public Scrd tryDefaultValues() { return tryInstance(defaultInstance()); } public List varyEachParameterOnce(Map instance) { if (instance == null) return null; List out = new ArrayList(); for (var param : parameterList) { Object value = param.randomValue(); if (eq(param.get(instance), value)) continue; Map instance2 = cloneMap(instance); instance2.put(param.name(), value); out.add(tryInstance(instance2)); } return out; } public Sc score(Map instance) { ++instancesTested; testingInstance(instance); return scoreFunction.get(instance); } public Scrd scored(Map instance) { Scrd scored = new Scrd(instance, score(instance)); fireInstanceScored(scored); return scored; } public Scrd tryInstance(Map instance) { if (instance == null) return null; Scrd scored = scored(instance); tryInstance(scored); return scored; } public void tryInstance(Scrd scored) { if (scored == null) return; if (best == null || compareScrd(scored, best) > 0) { best = scored; newBest(scored); } } public int compareScrd(Scrd a, Scrd b) { Sc scoreA = a.score(); Sc scoreB = b.score(); return comparisonFunction == null ? cmp(scoreA, scoreB) : comparisonFunction.get(actualScoreFunction.get(scoreA), actualScoreFunction.get(scoreB)); } public String toString() { return "Best: " + best + " (parameters: " + keys(parameters) + ")"; } public Map bestOrDefaultInstance() { if (best == null) tryDefaultValues(); return best.get(); } } static public class TickerSequences implements ByteIO, IntSize, Iterable { public TickerSequences() { } final public String getMarket() { return market(); } public String market() { return market; } public String market; final public List getTickers() { return tickers(); } public List tickers() { return tickers; } public List tickers = new ArrayList(); public TickerSequences(Iterable sequences) { loadableUtils.utils.addAll(tickers, sequences); } public TickerSequences(TickerSequence... sequences) { loadableUtils.utils.addAll(tickers, sequences); } public void add(TickerSequence ticker) { tickers.add(ticker); } public TickerSequence get(int i) { return tickers.get(i); } public void sort() { sortInPlaceByCalculatedField(tickers, __1 -> __1.startTime()); } public int size() { return tickers.size(); } public String toString() { return commaCombine(spaceCombine(n2(tickers, " ticker sequence"), empty(market) ? null : "for " + market), formatDays(totalTime()), n2(nPricePoints(), "price point")); } public long nPricePoints() { return longSum(map(tickers, t -> (long) t.size())); } public long totalTime() { return longSum(map(tickers, ticker -> { var tr = ticker.timeRange(); return tr == null ? 0 : tr.length(); })); } public TickerSequences dropOverlaps() { sort(); for (int i = 0; i + 1 < l(tickers); i++) { var t1 = tickers.get(i); var t2 = tickers.get(i + 1); long time2 = t2.startTime(); while (!t1.isEmpty() && t1.endTime() >= time2) t1.dropLastPricePoint(); t1.trimToSize(); } return this; } public TickerSequences merge() { return merge(120); } public TickerSequences merge(double maximumGapSeconds) { sort(); for (int i = 0; i + 1 < l(tickers); i++) { var t1 = tickers.get(i); var t2 = tickers.get(i + 1); if (t2.startTime() - t1.endTime() <= fromSeconds(maximumGapSeconds)) { t1.add(t2); tickers.remove(i + 1); --i; } } return this; } public double firstPrice() { var ticker = first(tickers); return ticker == null ? Double.NaN : ticker.firstPrice(); } public IterableIterator prices() { return nestedIterator(tickers, ticker -> ticker.prices.iterator()); } public long startTime() { return empty(tickers) ? null : first(tickers).startTime(); } public long endTime() { return empty(tickers) ? null : last(tickers).endTime(); } public TickerSequence longest() { return highestBy(tickers(), ticker -> duration(ticker.timeRange())); } public TickerSequences mapTickers(IF1 f) { TickerSequences ts = new TickerSequences(); for (var t : tickers()) ts.add(f.get(t)); return ts; } public TickerSequences filterTickers(IF1 pred) { TickerSequences ts = new TickerSequences(); for (var t : tickers()) if (pred.get(t)) ts.add(t); return ts; } public TickerSequences marketIfEmpty(String market) { if (empty(this.market)) market(market); return this; } public TickerSequences market(String market) { this.market = market; for (var t : tickers) t.market(market); return this; } public void write(ByteHead head) { for (var t : tickers) t.write(head); } public void read(ByteHead head) { TickerSequence t; while ((t = TickerSequence.read(head)) != null) add(t); if (empty(market) && nempty(tickers)) market(first(tickers).market); } public void readWrite(ByteHead head) { if (head.readMode()) read(head); if (head.writeMode()) write(head); } public Iterator iterator() { return tickers.iterator(); } } static public class RSI extends CandleBasedIndicator { final public RSI setSmoothingPeriod(int smoothingPeriod) { return smoothingPeriod(smoothingPeriod); } public RSI smoothingPeriod(int smoothingPeriod) { this.smoothingPeriod = smoothingPeriod; return this; } final public int getSmoothingPeriod() { return smoothingPeriod(); } public int smoothingPeriod() { return smoothingPeriod; } public int smoothingPeriod = 14; final public RSI setUpSum(double upSum) { return upSum(upSum); } public RSI upSum(double upSum) { this.upSum = upSum; return this; } final public double getUpSum() { return upSum(); } public double upSum() { return upSum; } public double upSum; final public RSI setDownSum(double downSum) { return downSum(downSum); } public RSI downSum(double downSum) { this.downSum = downSum; return this; } final public double getDownSum() { return downSum(); } public double downSum() { return downSum; } public double downSum; final public RSI setSteps(long steps) { return steps(steps); } public RSI steps(long steps) { this.steps = steps; return this; } final public long getSteps() { return steps(); } public long steps() { return steps; } public long steps; final public RSI setUp(SmoothedMovingAverage up) { return up(up); } public RSI up(SmoothedMovingAverage up) { this.up = up; return this; } final public SmoothedMovingAverage getUp() { return up(); } public SmoothedMovingAverage up() { return up; } public SmoothedMovingAverage up; final public RSI setDown(SmoothedMovingAverage down) { return down(down); } public RSI down(SmoothedMovingAverage down) { this.down = down; return this; } final public SmoothedMovingAverage getDown() { return down(); } public SmoothedMovingAverage down() { return down; } public SmoothedMovingAverage down; final public RSI setPostSmoother(SimpleMovingAverage postSmoother) { return postSmoother(postSmoother); } public RSI postSmoother(SimpleMovingAverage postSmoother) { this.postSmoother = postSmoother; return this; } final public SimpleMovingAverage getPostSmoother() { return postSmoother(); } public SimpleMovingAverage postSmoother() { return postSmoother; } public SimpleMovingAverage postSmoother; final public RSI setRsi(double rsi) { return rsi(rsi); } public RSI rsi(double rsi) { this.rsi = rsi; return this; } final public double getRsi() { return rsi(); } public double rsi() { return rsi; } public double rsi = Double.NaN; final public RSI setRsiSmoothed(double rsiSmoothed) { return rsiSmoothed(rsiSmoothed); } public RSI rsiSmoothed(double rsiSmoothed) { this.rsiSmoothed = rsiSmoothed; return this; } final public double getRsiSmoothed() { return rsiSmoothed(); } public double rsiSmoothed() { return rsiSmoothed; } public double rsiSmoothed = Double.NaN; final public TickerSequence getRsiHistory() { return rsiHistory(); } public TickerSequence rsiHistory() { return rsiHistory; } public TickerSequence rsiHistory = new TickerSequence("RSI"); final public TickerSequence getRsiSmoothedHistory() { return rsiSmoothedHistory(); } public TickerSequence rsiSmoothedHistory() { return rsiSmoothedHistory; } public TickerSequence rsiSmoothedHistory = new TickerSequence("RSI Smoothed"); public Double value() { return rsiSmoothed(); } public boolean complete() { return steps >= length(); } { length = 25; onCandleAdded((IVF1) candle -> { var x = candle.move(); var u = max(x, 0.0); var d = neg(min(x, 0.0)); if (!complete()) { upSum += u; downSum += d; } else { if (up == null) { up = new SmoothedMovingAverage(length()); down = new SmoothedMovingAverage(length()); up.add(upSum / steps); down.add(downSum / steps); } else { up().add(u); down().add(d); } var rs = div(up().get(), down().get()); rsi(100 - 100 / (1 + rs)); long time = candle.endTime().toLong(); { if (rsiHistory != null) rsiHistory.addIfPriceChanged(rsi, time); } if (postSmoother == null) postSmoother = new SimpleMovingAverage(smoothingPeriod); postSmoother.add(rsi); rsiSmoothed(postSmoother.get()); { if (rsiSmoothedHistory != null) rsiSmoothedHistory.addIfPriceChanged(rsiSmoothed, time); } } ++steps; }); } public TickerSequence asTicker(List candles) { feed(candles); return rsiHistory; } public void reset() { super.reset(); resetFields(this, "upSum downSum steps up down postSmoother rsi rsiSmoothed rsiHistory rsiSmoothedHistory"); } } static public class G22CriticalPixelSearch implements Steppable { final public G22CriticalPixelSearch setMasksHolder(IG22MasksHolder masksHolder) { return masksHolder(masksHolder); } public G22CriticalPixelSearch masksHolder(IG22MasksHolder masksHolder) { this.masksHolder = masksHolder; return this; } final public IG22MasksHolder getMasksHolder() { return masksHolder(); } public IG22MasksHolder masksHolder() { return masksHolder; } public IG22MasksHolder masksHolder; final public G22CriticalPixelSearch setKeepAllEntries(boolean keepAllEntries) { return keepAllEntries(keepAllEntries); } public G22CriticalPixelSearch keepAllEntries(boolean keepAllEntries) { this.keepAllEntries = keepAllEntries; return this; } final public boolean getKeepAllEntries() { return keepAllEntries(); } public boolean keepAllEntries() { return keepAllEntries; } public boolean keepAllEntries = false; final public G22CriticalPixelSearch setSortPixelsFirst(boolean sortPixelsFirst) { return sortPixelsFirst(sortPixelsFirst); } public G22CriticalPixelSearch sortPixelsFirst(boolean sortPixelsFirst) { this.sortPixelsFirst = sortPixelsFirst; return this; } final public boolean getSortPixelsFirst() { return sortPixelsFirst(); } public boolean sortPixelsFirst() { return sortPixelsFirst; } public boolean sortPixelsFirst = true; public int w, h; public Iterator pixelIterator; public Best bestPixel = new Best(); public Entry bestEntry; public Pt lastPixelLookedAt; public Entry lastEntry; public Entry[] pixelEntries; public float[] pixelScores; public int nPixelsTested; public CompactHashSet subSets; public G22CriticalPixelSearch() { } public G22CriticalPixelSearch(IG22MasksHolder masksHolder) { this.masksHolder = masksHolder; } public class Entry { public Pt pixel; final public List getDarkMasks() { return darkMasks(); } public List darkMasks() { return darkMasks; } public List darkMasks; final public List getBrightMasks() { return brightMasks(); } public List brightMasks() { return brightMasks; } public List brightMasks; public G22GhostImage darkGhost; public G22GhostImage brightGhost; public IG22MasksHolder darkHolder_cache; public IG22MasksHolder darkHolder() { if (darkHolder_cache == null) darkHolder_cache = darkHolder_load(); return darkHolder_cache; } public IG22MasksHolder darkHolder_load() { return new G22HashedMasks(darkMasks, darkGhost); } public IG22MasksHolder brightHolder_cache; public IG22MasksHolder brightHolder() { if (brightHolder_cache == null) brightHolder_cache = brightHolder_load(); return brightHolder_cache; } public IG22MasksHolder brightHolder_load() { return new G22HashedMasks(brightMasks, brightGhost); } public void calcGhosts() { if (l(darkMasks) < l(brightMasks)) { darkGhost = new G22GhostImage(lmapMethod(__192 -> __192.image(), darkMasks)); brightGhost = masksHolder().ghost().minus(darkGhost); } else { brightGhost = new G22GhostImage(lmapMethod(__193 -> __193.image(), brightMasks)); darkGhost = masksHolder().ghost().minus(brightGhost); } } public String toString() { return commaCombine("Split at " + pixel, "dark=" + darkHolder().renderCountAndCertainty(), "bright=" + brightHolder().renderCountAndCertainty()); } } public boolean step() { if (w == 0) { if (!masksHolder.canSplit()) return false; w = masksHolder.maskSize().w(); h = masksHolder.maskSize().h(); pixelEntries = new Entry[w * h]; pixelScores = new float[w * h]; arrayfill(pixelScores, -1); pixelIterator = makePixelIterator(); } if (!pixelIterator.hasNext()) return false; lastPixelLookedAt = pixelIterator.next(); testPixel(lastPixelLookedAt); return true; } public int idx(Pt p) { return p.y * w + p.x; } public void testPixel(Pt p) { double score; Entry e = null; ++nPixelsTested; float ghostBrightness = masksHolder.ghost().getFloatPixel(p); if (ghostBrightness == 0 || ghostBrightness == 1) score = -2; else { e = new Entry(); e.pixel = p; lastEntry = e; if (keepAllEntries) pixelEntries[idx(p)] = e; List masks = wideningListCast(masksHolder.masks()); int n = l(masks); byte[] brightBits = byteArrayForNBits(n); for (int i = 0; i < n; i++) if (masks.get(i).image().getBoolPixel(p)) setBit(brightBits, i); { if (subSets != null) subSets.add(new HashedByteArray(brightBits)); } var splitMasks = filterAntiFilterByBitSet(masks, brightBits); e.brightMasks = splitMasks.a; e.darkMasks = splitMasks.b; e.calcGhosts(); score = scoreEntry(e); } pixelScores[idx(p)] = (float) score; if (score > 0 && bestPixel.put(p, score)) bestEntry = e; } transient public IF1 scoreEntry; public double scoreEntry(Entry e) { return scoreEntry != null ? scoreEntry.get(e) : scoreEntry_base(e); } final public double scoreEntry_fallback(IF1 _f, Entry e) { return _f != null ? _f.get(e) : scoreEntry_base(e); } public double scoreEntry_base(Entry e) { double c1 = e.darkGhost.certainty(); double c2 = e.brightGhost.certainty(); return min(c1, c2); } public double bestScore() { return bestPixel.score(); } public BWImage scoreImage() { double min = masksHolder.certainty(); double max = bestPixel.score(); return bwImageFromFunction(w, h, (x, y) -> transformToZeroToOne(pixelScores[y * w + x], max, min)); } public G22PixelSplitMasks splitMasksHolder() { if (!bestPixel.has()) return null; return new G22PixelSplitMasks().splitPixel(bestPixel.get()).darkHolder(bestEntry.darkHolder()).brightHolder(bestEntry.brightHolder()); } final public IG22MasksHolder bestTree() { return makeBestTree(); } final public IG22MasksHolder get() { return makeBestTree(); } public IG22MasksHolder makeBestTree() { stepAll(this); G22PixelSplitMasks split = splitMasksHolder(); if (split == null) return masksHolder; split.transformSubHolders(subHolder -> new G22CriticalPixelSearch(subHolder).makeBestTree()); return split; } public void collectSubSets() { if (subSets == null) subSets = new CompactHashSet(); } public Iterator makePixelIterator() { if (sortPixelsFirst) return iterator(pixelsByBrightness(masksHolder().ghost().certaintyImage())); else return new WeightlessShuffledIterator(pixelsInImage(w, h)); } } static public class G22TravelLogPanel implements Swingable, IFieldsToList { public G22Utils g22utils; public G22TravelLogPanel() { } public G22TravelLogPanel(G22Utils g22utils) { this.g22utils = g22utils; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")"; } public Object[] _fieldsToList() { return new Object[] { g22utils }; } public SimpleCRUD_v2 crud; public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { crud = new SimpleCRUD_v2(g22utils.concepts(), G22TravelLogEntry.class); return jCenteredSection("Project Travel Log [" + g22utils.projectName() + "]", crud.visualize()); } } static public class TreeSetWithChangeListeners extends SetWithChangeListeners { public TreeSetWithChangeListeners() { super(new TreeSet()); } } static public class TradingCandles extends NotifyingList { public TradingCandles() { } public TradingCandles(List list) { super(list); this.list = list; } public IntPair highLevel(int idx) { return intPair(highLeft(idx), highRight(idx)); } public int highLeft(int idx) { double high = get(idx).high(); for (int j = 1; j < idx; j++) if (get(idx - j).high() > high) return j - 1; return idx; } public int highRight(int idx) { double high = get(idx).high(); int n = size(); for (int j = 1; j < n - idx; j++) if (get(idx + j).high() > high) return j - 1; return n - idx; } public IntPair lowLevel(int idx) { return intPair(lowLeft(idx), lowRight(idx)); } public int lowLeft(int idx) { double low = get(idx).low(); for (int j = 1; j < idx; j++) if (get(idx - j).low() < low) return j - 1; return idx; } public int lowRight(int idx) { double low = get(idx).low(); int n = size(); for (int j = 1; j < n - idx; j++) if (get(idx + j).low() < low) return j - 1; return n - idx; } } static public class GazAICredentials { final public GazAICredentials setUser(String user) { return user(user); } public GazAICredentials user(String user) { this.user = user; return this; } final public String getUser() { return user(); } public String user() { return user; } public String user; final public GazAICredentials setPassword(String password) { return password(password); } public GazAICredentials password(String password) { this.password = password; return this; } final public String getPassword() { return password(); } public String password() { return password; } public String password; public String toString() { return joinNempties(" with ", shortClassName(this), nempty(user) ? "user " + user : null, nempty(password) ? "password" : null); } static public GazAICredentials fromFile(File f) { var credMap = parseColonPropertyCIMap(loadTextFile(f)); var cred = new GazAICredentials(); cred.user(credMap.get("user")); cred.password(credMap.get("password")); return cred; } public void save(File f) { saveTextFile(f, formatColonProperties(litorderedmap("user", user, "password", password))); } public Map asParams() { return litorderedmap("user", user, "pw", password); } } static public class G22ScriptsFromAllDBsPanel { public G22Utils g22utils; public JObjectTable table; public ReliableSingleThread rstUpdate = new ReliableSingleThread(new Runnable() { public void run() { try { _updateTable(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "_updateTable();"; } }); transient public SingleComponentPanel scpDetail = singleComponentPanel(); public G22ScriptsFromAllDBsPanel(G22Utils g22utils) { this.g22utils = g22utils; } public JComponent visualize() { table = new JObjectTable(); table.itemToMap = (script) -> { return joinMaps(litorderedmap("Project", fileName(scriptToDBDir(script)), "ID", str(script.id)), g22utils.scriptToMap(script)); }; var tbl = table.visualize(); rstUpdate.get(); tablePopupMenuItem_top(table.table, "Open database", runnableThread(new Runnable() { public void run() { try { g22utils.masterStuff.openDatabase(table.selected()._concepts.conceptsDir()); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "g22utils.masterStuff.openDatabase(table.selected()._concepts.conceptsDir());"; } })); table.onSelect(script -> { if (script == null) scpDetail.clear(); else { var tabs = jtabs(); String editedText = script.editedText(); if (editedText != null) addTab(tabs, "Editing", makeDisabledTextArea(editedText)); if (script.text != null) addTab(tabs, "Saved", makeDisabledTextArea(script.text)); String codeForAutoRun = script.codeForAutoRun(); if (codeForAutoRun != null) addTab(tabs, "Clear for auto-run", makeDisabledTextArea(codeForAutoRun)); scpDetail.set(tabs); } }); return withTopAndBottomMargin(jCenteredRaisedSection("Scripts from all databases", jvsplit(withRightAlignedButtons(tbl, "Show all scripts as one long text", runnableThread(new Runnable() { public void run() { try { showHugeText(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "showHugeText();"; } })), scpDetail))); } public File scriptToDBDir(G22LeftArrowScript script) { return script == null ? null : script._concepts.conceptsDir(); } public JComponent makeDisabledTextArea(String text) { var ta = g22utils.newSyntaxTextArea(); ta.setText(text); uneditableBlack(ta.textArea()); return ta.visualize(); } public void _updateTable() { table.setData_force(concatLists(mapCloseables_pcall(g22utils.peekAllProjectsConcepts(), cc -> list(cc, G22LeftArrowScript.class)))); } public String makeHugeText() { return g22utils.evalRegisteredCode("Make text from all scripts", () -> { rstUpdate.waitUntilDone(); return new G22ScriptUtil(g22utils).makeHugeText(table.getList()); }); } public void showHugeText() { String text = makeHugeText(); showFrame("Scripts from all DBs", g22utils.newSyntaxTextArea(text)); } } static public class SignalWithStrength { public SignalWithStrength() { } final public SignalWithStrength setType(String type) { return type(type); } public SignalWithStrength type(String type) { this.type = type; return this; } final public String getType() { return type(); } public String type() { return type; } public String type; final public SignalWithStrength setReason(String reason) { return reason(reason); } public SignalWithStrength reason(String reason) { this.reason = reason; return this; } final public String getReason() { return reason(); } public String reason() { return reason; } public String reason; final public SignalWithStrength setStrength(double strength) { return strength(strength); } public SignalWithStrength strength(double strength) { this.strength = strength; return this; } final public double getStrength() { return strength(); } public double strength() { return strength; } public double strength; final public SignalWithStrength setCreatedBy(Object createdBy) { return createdBy(createdBy); } public SignalWithStrength createdBy(Object createdBy) { this.createdBy = createdBy; return this; } final public Object getCreatedBy() { return createdBy(); } public Object createdBy() { return createdBy; } public Object createdBy; public String toString() { return (nempty(reason) ? reason : or2(type, "Unspecified ") + " signal") + appendRoundBracketed(strength >= 100 ? null : iround(strength) + "%"); } public boolean isTrigger() { return strength >= 100; } public boolean nonNegative() { return strength >= 0; } public boolean positive() { return strength > 0; } } static public class JLeftArrowScriptIDE extends MetaWithChangeListeners implements Swingable { final public JLeftArrowScriptIDE setLvScript(IVarWithNotify lvScript) { return lvScript(lvScript); } public JLeftArrowScriptIDE lvScript(IVarWithNotify lvScript) { this.lvScript = lvScript; return this; } final public IVarWithNotify getLvScript() { return lvScript(); } public IVarWithNotify lvScript() { return lvScript; } public IVarWithNotify lvScript = stringLiveValue(); final public JLeftArrowScriptIDE setSectionTitle(String sectionTitle) { return sectionTitle(sectionTitle); } public JLeftArrowScriptIDE sectionTitle(String sectionTitle) { this.sectionTitle = sectionTitle; return this; } final public String getSectionTitle() { return sectionTitle(); } public String sectionTitle() { return sectionTitle; } public String sectionTitle = "Left arrow script"; final public JLeftArrowScriptIDE setWithResultPanel(boolean withResultPanel) { return withResultPanel(withResultPanel); } public JLeftArrowScriptIDE withResultPanel(boolean withResultPanel) { this.withResultPanel = withResultPanel; return this; } final public boolean getWithResultPanel() { return withResultPanel(); } public boolean withResultPanel() { return withResultPanel; } public boolean withResultPanel = true; final public JLeftArrowScriptIDE setCompileDelay(double compileDelay) { return compileDelay(compileDelay); } public JLeftArrowScriptIDE compileDelay(double compileDelay) { this.compileDelay = compileDelay; return this; } final public double getCompileDelay() { return compileDelay(); } public double compileDelay() { return compileDelay; } public double compileDelay = 0.1; static public String helpText = "Gazelle 22 \"Left Arrow Script\"\r\n------------------------------\r\n\r\n\"Left arrow script\" is one of Gazelle 22's two scripting languages. It is the powerful one of the two. It can do anything Java can do except for defining classes or lambdas.\r\n\r\n-Usually, you write one command per line\r\n-Each command contains at most one action and at most one assignment\r\n-The language is case-sensitive\r\n-You can add comments like in Java with /* */ or //\r\n-You can write multiple commands in one line by separating them with a semicolon\r\n-Arguments to functions are separated by spaces\r\n-You can use integer and string literals like in Java\r\n-You can use true, false and null\r\n\r\nIt's called \"left arrow script\" because the left arrow (variable assignment) is its only actual operator (not counting ; and {}).\r\n\r\n\r\nOperations\r\n----------\r\n\r\nYou can call any global function defined in Gazelle. Example:\r\n\r\n infoBox \"hello\" // show a popup with the text \"hello\"\r\n \r\nYou can assign the result of a function call to a variable:\r\n\r\n time <- tsNow // get current time as a Timestamp object\r\n infoBox time // show as popup\r\n \r\nNote that this script requires 2 lines because only one operation is allowed per command.\r\n \r\nVariables can be overwritten and don't have to be declared.\r\n\r\n\r\nCreating objects\r\n----------------\r\n\r\nYou can create an instance of any Java class and call methods on the object:\r\n\r\n list <- new ArrayList\r\n list add \"hello\"\r\n list add \"world\"\r\n infoBox list // shows [hello, world]\r\n \r\n(Currently you can also say \"list <- ArrayList\", but this is ambiguous and may be removed in a future version.)\r\n \r\nYou can pass parameters to the constructor:\r\n\r\n pair <- new Pair \"hello\" \"world\"\r\n infoBox pair // shows \r\n \r\n\r\nJava operators (+, * etc)\r\n-------------------------\r\n \r\nJava operators can't be used directly but we have functions that do the same thing (if we don't, we'll add them):\r\n\r\n x <- plus 1 2\r\n infoBox x\r\n\r\n\r\nFunction definitions\r\n--------------------\r\n\r\nYou can define functions in your script, with arguments. The function can return a value (which is the result of the last command in the function).\r\n\r\n def doubleMe x { mul x 2 }\r\n\r\n x <- doubleMe 5\r\n infoBox x // shows 10\r\n"; public transient FieldVar varCompileResult_cache; public FieldVar varCompileResult() { if (varCompileResult_cache == null) varCompileResult_cache = varCompileResult_load(); return varCompileResult_cache; } public FieldVar varCompileResult_load() { return new FieldVar(this, "compileResult", () -> compileResult(), compileResult -> compileResult(compileResult)); } final public JLeftArrowScriptIDE setCompileResult(LASCompileResult compileResult) { return compileResult(compileResult); } public JLeftArrowScriptIDE compileResult(LASCompileResult compileResult) { if (!eq(this.compileResult, compileResult)) { this.compileResult = compileResult; change(); } return this; } final public LASCompileResult getCompileResult() { return compileResult(); } public LASCompileResult compileResult() { return compileResult; } transient public LASCompileResult compileResult; transient volatile public RSyntaxTextAreaWithSearch taScript; transient public RSTADummyParser dummyParser = new RSTADummyParser(); transient public ReliableSingleThread rstCompile = new ReliableSingleThread(() -> compile()); final public JPanel getButtons() { return buttons(); } public JPanel buttons() { return buttons; } transient public JPanel buttons = jline(); transient public JButton btnRun; transient public CollapsibleLeftPanel collapsibleResultPanel; transient public G22ScriptResultPanel resultPanel; transient public JPopDownButton popDownButton; transient public LeftArrowCompletionProvider completionProvider; final public JLeftArrowScriptIDE setG22utils(G22Utils g22utils) { return g22utils(g22utils); } public JLeftArrowScriptIDE g22utils(G22Utils g22utils) { this.g22utils = g22utils; return this; } final public G22Utils getG22utils() { return g22utils(); } public G22Utils g22utils() { return g22utils; } transient public G22Utils g22utils; final public JLeftArrowScriptIDE setScriptTimeout(double scriptTimeout) { return scriptTimeout(scriptTimeout); } public JLeftArrowScriptIDE scriptTimeout(double scriptTimeout) { this.scriptTimeout = scriptTimeout; return this; } final public double getScriptTimeout() { return scriptTimeout(); } public double scriptTimeout() { return scriptTimeout; } public double scriptTimeout = 10.0; final public JLeftArrowScriptIDE setShowTitle(boolean showTitle) { return showTitle(showTitle); } public JLeftArrowScriptIDE showTitle(boolean showTitle) { this.showTitle = showTitle; return this; } final public boolean getShowTitle() { return showTitle(); } public boolean showTitle() { return showTitle; } transient public boolean showTitle = true; final public JLeftArrowScriptIDE setSourceInfo(Object sourceInfo) { return sourceInfo(sourceInfo); } public JLeftArrowScriptIDE sourceInfo(Object sourceInfo) { this.sourceInfo = sourceInfo; return this; } final public Object getSourceInfo() { return sourceInfo(); } public Object sourceInfo() { return sourceInfo; } transient public Object sourceInfo; transient public Runnable rRecompileIfError = () -> recompileIfError(); transient public IF0 makeParser; public GazelleV_LeftArrowScriptParser makeParser() { return makeParser != null ? makeParser.get() : makeParser_base(); } final public GazelleV_LeftArrowScriptParser makeParser_fallback(IF0 _f) { return _f != null ? _f.get() : makeParser_base(); } public GazelleV_LeftArrowScriptParser makeParser_base() { return g22utils.leftArrowParser().sourceInfo(sourceInfo); } public interface GoToDefinitionHandler { public Runnable get(ListAndIndex tokPtr); } final public List getGoToDefinitionHandlers() { return goToDefinitionHandlers(); } public List goToDefinitionHandlers() { return goToDefinitionHandlers; } transient public List goToDefinitionHandlers = syncL(); public class LeftArrowCompletionProvider extends DefaultCompletionProvider { @Override public List getCompletionsImpl(JTextComponent comp) { try { String text = loadableUtils.utils.getText(comp); GazelleV_LeftArrowScriptParser parser = makeParser(); LeftArrowScriptAutoCompleter completer = new LeftArrowScriptAutoCompleter(g22utils, parser); completer.onAdaptingSearcher(() -> g22utils.addingAdditionalAutoCompletes(completer)); completer.seek(text, getCaretPosition(comp)); return map(completer.searcher().withScores(), completion -> { BasicCompletion c = new BasicCompletion(this, completion.get()); c.setRelevance((int) completion.score()); return c; }); } catch (Throwable e) { printStackTrace(e); return ll(); } } } public void goToPosition_noFocus(LineAndColumn lineAndCol) { if (lineAndCol == null) return; try { moveCaretAndScroll(textArea(), lineAndCol); } catch (Throwable e) { print("Trying again: " + e); awtLater(1.0, () -> { moveCaretAndScroll(textArea(), lineAndCol); }); } } public void goToPosition(LineAndColumn lineAndCol) { focus(textArea()); goToPosition_noFocus(lineAndCol); } public JComponent wrapStatusLabel(JComponent lbl) { onLeftClick(lbl, () -> goToPosition(compileResult == null ? null : compileResult.errorLineAndCol())); popDownButton = swing(() -> new JPopDownButton("Help")); popDownButton.onFillingMenu(menu -> addMenuItems(menu, "Show Scripting Help", runnableThread(new Runnable() { public void run() { try { showTextWordWrapped("Gazelle 'Left arrow script' Help", helpText); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "showTextWordWrapped(\"Gazelle 'Left arrow script' Help\", helpText)"; } }), "Show Global Class Names", runnableThread(new Runnable() { public void run() { try { showGlobalClassNames(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "showGlobalClassNames();"; } }), "Convert to Java", runnableThread(new Runnable() { public void run() { try { convertToJava(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "convertToJava();"; } }))); return centerAndEastWithMargin(jBorderlessHigherScrollPane(lbl), jfullcenter(buttons)); } public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { return swing(() -> { taScript = g22utils.newSyntaxTextArea(__3 -> wrapStatusLabel(__3)); bindToComponent(textArea(), () -> g22utils.masterStuff().onNewClassesDefined(rRecompileIfError), () -> g22utils.masterStuff().removeNewClassesDefinedListener(rRecompileIfError)); bindTextComponentToVarWithNotify_noInitialUndo(textArea(), lvScript); dummyParser.install(textArea()); addKeyListener(textArea(), functionKeyListener(5, runnableThread(new Runnable() { public void run() { try { runScript(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "runScript();"; } }))); addKeyListener(textArea(), ctrlLetterKeyListener('b', runnableThread(new Runnable() { public void run() { try { goToDefinition(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "goToDefinition();"; } }))); awtCalcEvery(textArea(), compileDelay, rstCompile); installCompletionProvider(completionProvider = new LeftArrowCompletionProvider(), textArea()); JComponent vis = taScript.visualize(); if (showTitle) vis = jCenteredSection(sectionTitle, vis); vis = wrapSection(vis); addAll(buttons, btnRun = toolTip("Run script (F5)", jbutton("Run", runnableThread(new Runnable() { public void run() { try { runScript(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "runScript();"; } }))), popDownButton); if (withResultPanel) { resultPanel = new G22ScriptResultPanel(); collapsibleResultPanel = new CollapsibleLeftPanel(false, "Output", resultPanel.visualize(), vis); collapsibleResultPanel.sidePanelMargins = c -> withTopAndLeftMargin(c); return collapsibleResultPanel.visualize(); } else return vis; }); } transient public IF1 wrapSection; public JComponent wrapSection(JComponent c) { return wrapSection != null ? wrapSection.get(c) : wrapSection_base(c); } final public JComponent wrapSection_fallback(IF1 _f, JComponent c) { return _f != null ? _f.get(c) : wrapSection_base(c); } public JComponent wrapSection_base(JComponent c) { return c; } public RSyntaxTextArea textArea() { if (taScript == null) visualize(); return taScript.textArea(); } public void setText(String text) { loadableUtils.utils.setText(textArea(), text); } private void compile() { var script = lvScript.get(); var result = compileResult; if (!g22utils().compileResultValid(result, script)) { result = newCompileResult(); result.script = script; result.makeParser = () -> makeParser(); result.compile(); compileResult(result); showStatus(str(compileResult)); updateRunButtonState(); List errors = new ArrayList(); if (result.compileError != null) { LineAndColumn lineAndCol = result.errorLineAndCol(); if (lineAndCol != null) errors.add(new RSTADummyParser.Error().msg(result.errorToString()).start(lineAndCol).end(new LineAndColumn(lineAndCol.line + 1, 1))); } dummyParser.setErrors(result.script, errors, textArea()); } } public void updateRunButtonState() { setEnabled(btnRun, runButtonShouldBeEnabled()); } transient public IF0 runButtonShouldBeEnabled; public boolean runButtonShouldBeEnabled() { return runButtonShouldBeEnabled != null ? runButtonShouldBeEnabled.get() : runButtonShouldBeEnabled_base(); } final public boolean runButtonShouldBeEnabled_fallback(IF0 _f) { return _f != null ? _f.get() : runButtonShouldBeEnabled_base(); } public boolean runButtonShouldBeEnabled_base() { return compileResult != null && compileResult.runnable(); } public LASCompileResult freshCompileResult() { rstCompile.triggerAndWait(); return compileResult; } public GazelleV_LeftArrowScript.Script parsedScript() { return freshCompileResult().parsedScript; } transient public Runnable runScript; public void runScript() { if (runScript != null) runScript.run(); else runScript_base(); } final public void runScript_fallback(Runnable _f) { if (_f != null) _f.run(); else runScript_base(); } public void runScript_base() { var result = freshCompileResult(); if (result.parsedScript != null) { var value = runResultWithTimestamps(() -> callCompiledObjectWithTimeout(result.parsedScript)); showScriptResult(value); } } public void showScriptResult(OKOrError result) { if (result instanceof RunResultWithTimestamps) { if (resultPanel != null) resultPanel.logView.setText(str(((RunResultWithTimestamps) result).printOutput())); } if (result.isOK()) { setStatus(shorten(g22utils.stringify(result.get()))); var objVisualizer = makeObjectVisualizer(result.get()); if (result instanceof RunResultWithTimestamps) { var duration = ((RunResultWithTimestamps) result).duration(); if (duration != null) { long nanos = ((RunResultWithTimestamps) result).duration().toNanos(); objVisualizer.nanos(nanos); } } if (collapsibleResultPanel != null) objVisualizer.withTypeAndTime(false); { if (resultPanel != null) resultPanel.scpResult.set(objVisualizer); } if (collapsibleResultPanel != null) collapsibleResultPanel.sidePanelName("Output" + appendBracketed(objVisualizer.objectInfos())); } else { setStatus(exceptionToStringShorter(result.error())); { if (resultPanel != null) resultPanel.scpResult.set(jErrorView(result.getError())); } } { if (collapsibleResultPanel != null) collapsibleResultPanel.expand(); } } final public void showStatus(String status) { setStatus(status); } public void setStatus(String status) { { if (taScript != null) taScript.setStatus(" " + unnull(status)); } } public void showRuntimeError(Throwable e) { showStatus(exceptionToStringShorter(e)); } transient public IF0 makeVarContextForExecution; public VarContext makeVarContextForExecution() { return makeVarContextForExecution != null ? makeVarContextForExecution.get() : makeVarContextForExecution_base(); } final public VarContext makeVarContextForExecution_fallback(IF0 _f) { return _f != null ? _f.get() : makeVarContextForExecution_base(); } public VarContext makeVarContextForExecution_base() { return new FlexibleVarContext(); } public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script script) { return callCompiledObjectWithTimeout(scriptTimeout, script); } public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script script) { return callCompiledObjectWithTimeout(timeoutSeconds, script, makeVarContextForExecution()); } public Object callCompiledObjectWithTimeout(GazelleV_LeftArrowScript.Script script, VarContext ctx) { return callCompiledObjectWithTimeout(scriptTimeout, script, ctx); } public Object callCompiledObjectWithTimeout(double timeoutSeconds, GazelleV_LeftArrowScript.Script script, VarContext ctx) { return g22utils.evalRegisteredCode(timeoutSeconds, str(script), () -> script.get(ctx)); } public void showGlobalClassNames() { showText("Global Class Names", pnlToString(toCIMap(makeParser().globalClassNames()))); } public void setEditable(boolean b) { loadableUtils.utils.setEditable(textArea(), b); } transient public IF0 newCompileResult; public LASCompileResult newCompileResult() { return newCompileResult != null ? newCompileResult.get() : newCompileResult_base(); } final public LASCompileResult newCompileResult_fallback(IF0 _f) { return _f != null ? _f.get() : newCompileResult_base(); } public LASCompileResult newCompileResult_base() { return new LASCompileResult(); } public void convertToJava() { try { ConvertLASToJava converter = new ConvertLASToJava(); showText("Java conversion - " + sectionTitle(), strOrNull(converter.get(parsedScript(), true))); } catch (Throwable __e) { infoBox(__e); } } public void goToDefinition() { String text; int iChar; Pair __2 = textAndCaretPosition(textArea()); text = __2.a; iChar = __2.b; List tok = lasTok(text); int iTok = charToTokenIndex_left(tok, iChar); ListAndIndex tokPtr = new ListAndIndex(tok, iTok); var action = goToDefinitionAction(tokPtr); if (action != null) pcallF(action); else flatInfoBox("No definition found"); } public Runnable goToDefinitionAction(ListAndIndex tokPtr) { for (var handler : cloneList(goToDefinitionHandlers())) { var __1 = handler.get(tokPtr); if (__1 != null) return __1; } List tok = tokPtr.list(); int iTok = tokPtr.idx(); String id = lastIdentifier(subList(tok, iTok - 2, iTok + 1)); if (id != null) { String name = lookupStandardFunctionOrClassNameIC(id); if (name != null) { String snippetID = sfOrSCSnippet(id); if (snippetID != null) { return () -> { infoBox("Opening " + quote(name)); g22utils.openInBrowser(snippetURL(snippetID)); }; } } } return null; } public void recompile() { compileResult = null; rstCompile.trigger(); } public void recompileIfError() { var result = compileResult; if (result != null && result.hasError()) recompile(); } transient public IF1 makeObjectVisualizer; public G22JavaObjectVisualizer makeObjectVisualizer(Object result) { return makeObjectVisualizer != null ? makeObjectVisualizer.get(result) : makeObjectVisualizer_base(result); } final public G22JavaObjectVisualizer makeObjectVisualizer_fallback(IF1 _f, Object result) { return _f != null ? _f.get(result) : makeObjectVisualizer_base(result); } public G22JavaObjectVisualizer makeObjectVisualizer_base(Object result) { return new G22JavaObjectVisualizer(g22utils, result).allowDescendingIntoListElements(true); } public void addGoToDefinitionHandler(GoToDefinitionHandler handler) { goToDefinitionHandlers.add(handler); } final public boolean isShowing() { return visible(); } public boolean visible() { var ta = taScript; return ta != null && loadableUtils.utils.isShowing(ta.textArea); } public String getText() { var ta = taScript; if (ta == null) return null; return loadableUtils.utils.getText(ta.textArea); } } static public class G22SystemInfoPanel implements Swingable, IFieldsToList { public G22Utils g22utils; public G22SystemInfoPanel() { } public G22SystemInfoPanel(G22Utils g22utils) { this.g22utils = g22utils; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")"; } public Object[] _fieldsToList() { return new Object[] { g22utils }; } public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { var gazelleJar = g22utils.gazelleJar(); File conceptsFile = g22utils.concepts().conceptsFile(); var projectLibs = g22utils.projectActions().projectLibs(); var selfTests = g22utils.projectActions().selfTests(); return jscrollVertical(makeForm3("Java Version", jlabel(javaVersion()), "Gazelle Jar", new JFilePathLabel(gazelleJar).visualize(), "Gazelle Jar Size", str_toMB_oneDigit(fileSize(gazelleJar)), "Memory use (objects)", jline(jLabelShortCalcedEvery(1.0, () -> str_toMB(usedMemory())), jThreadedButton("Collect garbage", () -> gc())), "Max heap", jLabelShortCalcedEvery(1.0, () -> str_toMB(maxMemory())), "Threads", jReloadEvery(1.0, () -> jLabel(n2(threadCount()))), "Java VM arguments", joinWithSpace(vmArguments()), "Using Custom Classloader", yesNoShort(usingStarter(mc())), "Compilation Date", jlabel(g22utils.compilationDate()), "Project Libraries", joinWithCommaOr(projectLibs, "-"), "Project Database", new JFilePathLabel(conceptsFile).visualize(), "Project Database Size", str_toKB(fileSize(conceptsFile)), "Self-Tests", jlabel(selfTests == null ? "Not run" : selfTests.status()), "Gazelle Count", toolTip("How many Gazelles are running in the world", jLiveValueLabel((LiveValue) dm_callOSOpt("lvComputerCount"))))); } } static public class MakerAndTakerGame { public Boolean priceIsUp; public int takersCurrentBet; public int takersScore; public int roundsPlayed; public boolean takersTurn = true; public List protocol = new ArrayList(); transient public IF0 nextCryptoMove; public boolean nextCryptoMove() { return nextCryptoMove != null ? nextCryptoMove.get() : nextCryptoMove_base(); } final public boolean nextCryptoMove_fallback(IF0 _f) { return _f != null ? _f.get() : nextCryptoMove_base(); } public boolean nextCryptoMove_base() { throw fail("Put something here"); } public void make() { priceIsUp = nextCryptoMove(); takersScore += takersCurrentBet * (priceIsUp ? 1 : -1); ++roundsPlayed; protocol.add((MakerAndTakerGame) unstructure(print(structure(this)))); takersTurn = true; } transient public Runnable magicJuice; public void magicJuice() { if (magicJuice != null) magicJuice.run(); else magicJuice_base(); } final public void magicJuice_fallback(Runnable _f) { if (_f != null) _f.run(); else magicJuice_base(); } public void magicJuice_base() { } public void take() { magicJuice(); takersTurn = false; } public void step() { if (takersTurn) take(); else make(); } } static public class RegularPriceCells implements PriceCells { public RegularPriceCells() { } final public RegularPriceCells setInterval(double interval) { return interval(interval); } public RegularPriceCells interval(double interval) { this.interval = interval; return this; } final public double getInterval() { return interval(); } public double interval() { return interval; } public double interval; final public RegularPriceCells setBase(double base) { return base(base); } public RegularPriceCells base(double base) { this.base = base; return this; } final public double getBase() { return base(); } public double base() { return base; } public double base; public RegularPriceCells(double interval) { this.interval = interval; } public RegularPriceCells(double base, double interval) { this.interval = interval; this.base = base; } public double remainder(double price) { return mod(price - base, interval); } public boolean isCellLimit(double price) { return remainder(price) == 0; } public double nextCellLimit(double price) { double r = remainder(price); return price + interval - r; } public double previousCellLimit(double price) { double r = remainder(price); return price - (r == 0 ? interval : r); } public double nCellLimitsDown(double price, int n) { return previousCellLimit(price) - (n - 1) * interval; } public double nCellLimitsUp(double price, int n) { return nextCellLimit(price) + n * interval; } public double priceToCellNumber(double price) { return (price - base) / interval; } public double cellNumberToPrice(double cellNumber) { return cellNumber * interval + base; } } static public class PrintingWebSocketClient extends WebSocketClient { public PrintingWebSocketClient(URI uri) { super(uri); } public PrintingWebSocketClient(URI uri, Map httpHeaders) { super(uri, httpHeaders); } public void onMessage(String s) { print("WebSocket received: " + s); } public void onOpen(ServerHandshake handshake) { print("WebSocket opened"); } public void onClose(int code, String reason, boolean remote) { print("WebSocket closed, code " + code + ", reason: " + reason + ", remote: " + remote); } public void onError(Exception e) { printStackTrace(e); } } static public class G22DatabasesPanel implements IFieldsToList { public G22Utils g22utils; public G22DatabasesPanel() { } public G22DatabasesPanel(G22Utils g22utils) { this.g22utils = g22utils; } public Object[] _fieldsToList() { return new Object[] { g22utils }; } public JObjectTable table; public FileWatchService dirWatcher; public ReliableSingleThread rstUpdate = new ReliableSingleThread(new Runnable() { public void run() { try { _updateTable(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "_updateTable();"; } }); public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { table = swing(() -> new JObjectTable()); table.defaultAction(runnableToIVF1(runnableThread(new Runnable() { public void run() { try { openDB(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "openDB();"; } }))); table.itemToMap = db -> { IG22LoadedDB loaded = db.loadedDB(); return litorderedmap("Name", db.name, "Directory", f2s(db.dir), "Loaded", loaded == null ? "No" : (loaded.hidden() ? "Yes (hidden)" : "Yes")); }; var tbl = table.visualize(); bindToComponent(tbl, () -> { dirWatcher = new FileWatchService(); dirWatcher.addNonRecursiveListener(g22utils.databasesMotherDir(), file -> { rstUpdate.get(); }); g22utils.masterStuff().onLoadedDBsChange(rstUpdate); rstUpdate.get(); }, () -> { g22utils.masterStuff().removeLoadedDBsChangeListener(rstUpdate); { cleanUp(dirWatcher); dirWatcher = null; } }); return withTopAndBottomMargin(jCenteredRaisedSection("Gazelle projects on this computer", northAndCenterWithMargins(jline(toolTip("Create a new Gazelle project", jbutton("New project...", runnableThread(new Runnable() { public void run() { try { newDatabase(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "newDatabase();"; } })))), centerAndEastWithMargin(tbl, jscroll_vertical_borderless(vstackWithSpacing_fixed(new DefaultButtonBorder(toolTip("Open selected project, keep other projects open too", tableDependentButton(table.table, "Open project", runnableThread(new Runnable() { public void run() { try { openDB(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "openDB();"; } })))), toolTip("Open selected project in hidden mode [without a window]", tableDependentButton(table.table, "Open hidden", runnableThread(new Runnable() { public void run() { try { openDBHidden(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "openDBHidden();"; } }))), toolTip("Open selected project, close all other projects", tableDependentButton(table.table, "Switch to project", runnableThread(new Runnable() { public void run() { try { switchToDB(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "switchToDB();"; } }))), tableDependentButton(table.table, "Close project", runnableThread(new Runnable() { public void run() { try { closeDB(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "closeDB();"; } })), tableDependentButton(table.table, "Rename project", runnableThread(new Runnable() { public void run() { try { renameDB(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "renameDB();"; } })), tableDependentButton(table.table, "Delete project...", runnableThread(new Runnable() { public void run() { try { deleteDB(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "deleteDB();"; } })), tableDependentButton(table.table, "Browse files", runnableThread(new Runnable() { public void run() { try { browse(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "browse();"; } })), tableDependentButton(table.table, "Export project as zip...", runnableThread(new Runnable() { public void run() { try { exportAsZip(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "exportAsZip();"; } })), jThreadedButton("Import project from zip...", runnableThread(new Runnable() { public void run() { try { importZip(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "importZip();"; } })), jThreadedButton("Download project from Gaz.AI...", runnableThread(new Runnable() { public void run() { try { downloadProject(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "downloadProject();"; } })))))))); } public void newDatabase() { AutoCloseable __1 = g22utils.enter(); try { var tf = jtextfield(); var lblDir = jlabel(" "); var lblStatus = jlabel(" "); var button = jThreadedButton("Create project", () -> { AutoCloseable __2 = g22utils.enter(); try { String name = trim(tf.getText()); File dir = newFile(g22utils.databasesMotherDir(), name); createEmptyConceptsFileInDir(dir); disposeFrame(tf); g22utils.masterStuff().openDatabase(dir); } finally { _close(__2); } }); disableButton(button); onEnter(tf, button); onChange(tf, new Runnable() { public void run() { try { String name = trim(tf.getText()); boolean ok = false; String status = " ", path = " "; if (isValidFileName(name)) { File dir = newFile(g22utils.databasesMotherDir(), name); path = f2s(dir); if (dirExists(dir)) status = "A project with that name exists"; else ok = true; } else if (!empty(name)) status = "Project name must be a valid file name"; setEnabled(button, ok); setText(lblStatus, status); setText(lblDir, path); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "String name = trim(tf.getText());\r\n boolean ok;\r\n String status = \"..."; } }); showForm_makeFrame("New Gazelle Project", vstackWithSpacing(withLabel("Name for new project", tf), lblDir, lblStatus, button)); } finally { _close(__1); } } public void _updateTable() { table.setData_force(g22utils.gazelleDBs()); } public void browse() { desktopOpen(table.selected().dir); } public void openDB() { g22utils.masterStuff().openDatabase(table.selected().dir); } public void openDBHidden() { g22utils.masterStuff().openDatabase(table.selected().dir, true); } public void switchToDB() { g22utils.masterStuff().switchToDatabase(table.selected().dir); } public void closeDB() { g22utils.masterStuff().closeDatabase(table.selected().dir); } public void deleteDB() { var db = table.selected(); if (db == null) return; var dir = db.dir(); if (g22utils.isConceptsDir(dir)) { messageBox("Can't delete current project"); return; } g22utils.masterStuff().closeDatabase(dir); new DeleteFilesDialog("Delete Gazelle project " + db.name()).wholeDirectory(dir).show(); } public void exportAsZip() { File dir = table.selected().dir; JFileChooser fileChooser = new JFileChooser(); fileChooser.setDialogTitle("Export project as zip"); fileChooser.setSelectedFile(javaxBackupDir(dir.getName() + "-" + ymdMinusHMS() + ".zip")); if (fileChooser.showSaveDialog(visualize()) == JFileChooser.APPROVE_OPTION) { File zip = fileChooser.getSelectedFile(); dir2zip(dir, zip, dir.getName() + "/"); fileSavedInfoBox(zip); desktopOpen(dirOfFile(zip)); } } public void importZip() { try { JFileChooser fc = new JFileChooser(); fc.setDialogTitle("Import project from zip"); fc.setCurrentDirectory(javaxBackupDir()); if (fc.showOpenDialog(visualize()) == JFileChooser.APPROVE_OPTION) { File zip = fc.getSelectedFile(); g22utils.importProjectFromZip(zip); } } catch (Throwable __e) { messageBox(__e); } } public void downloadProject() { if (gazAICredentialsFromJavaXSecret() == null) { messageBox("Please enter Gaz.AI credentials first"); return; } inputText("Project to download", projectName -> { try { var zip = g22utils.downloadProjectFromGazAI(gazAICredentialsFromJavaXSecret(), projectName); if (swingConfirm("Install downloaded project?")) g22utils.importProjectFromZip(zip); } catch (Throwable __e) { messageBox(__e); } }); } public void renameDB() { File dir = table.selected().dir; inputText("New name", fileName(dir), newName -> { assertValidFileName(newName); if (!eq(newName, fileName(dir))) { boolean open = g22utils.masterStuff().isConceptDirLoaded(dir); if (open) g22utils.masterStuff().closeDatabase(dir); renameFileVerbose(dir, newName); if (open) g22utils.masterStuff().openDatabase(dir); } }); } } static public class JMultiColorBar extends JComponentWithChangeListeners { public class Entry { final public Entry setValue(double value) { return value(value); } public Entry value(double value) { this.value = value; return this; } final public double getValue() { return value(); } public double value() { return value; } public double value; final public Entry setColor(Color color) { return color(color); } public Entry color(Color color) { this.color = color; return this; } final public Color getColor() { return color(); } public Color color() { return color; } public Color color; final public Entry setText(String text) { return text(text); } public Entry text(String text) { this.text = text; return this; } final public String getText() { return text(); } public String text() { return text; } public String text; final public Entry setToolTip(String toolTip) { return toolTip(toolTip); } public Entry toolTip(String toolTip) { this.toolTip = toolTip; return this; } final public String getToolTip() { return toolTip(); } public String toolTip() { return toolTip; } public String toolTip; public Entry previous() { return elementBefore(entries, this); } public double relativeValue() { Entry p = previous(); return p == null ? value : value - p.value; } } public List entries = notifyingList(() -> repaint()); public transient FieldVar varMax_cache; public FieldVar varMax() { if (varMax_cache == null) varMax_cache = varMax_load(); return varMax_cache; } public FieldVar varMax_load() { return new FieldVar(this, "max", () -> max(), max -> max(max)); } final public JMultiColorBar setMax(double max) { return max(max); } public JMultiColorBar max(double max) { if (!eq(this.max, max)) { this.max = max; change(); } return this; } final public double getMax() { return max(); } public double max() { return max; } public double max = 100; final public JMultiColorBar setDefaultColors(List defaultColors) { return defaultColors(defaultColors); } public JMultiColorBar defaultColors(List defaultColors) { this.defaultColors = defaultColors; return this; } final public List getDefaultColors() { return defaultColors(); } public List defaultColors() { return defaultColors; } public List defaultColors = ll(Color.red, Color.blue); public InstantNeverHideToolTip toolTipMaker; transient public IF1 defaultColor; public Color defaultColor(int index) { return defaultColor != null ? defaultColor.get(index) : defaultColor_base(index); } final public Color defaultColor_fallback(IF1 _f, int index) { return _f != null ? _f.get(index) : defaultColor_base(index); } public Color defaultColor_base(int index) { return getCyclic(defaultColors, index); } public Entry makeEntry(double relativeValue) { Entry prev = last(entries); double value = prev == null ? relativeValue : relativeValue + prev.value; return new Entry().value(value).color(defaultColor(l(entries))); } final public Entry add(String text, double relativeValue) { return addEntry(text, relativeValue); } public Entry addEntry(String text, double relativeValue) { return addAndReturn(entries, makeEntry(relativeValue).text(text)); } final public Entry add(double relativeValue, Color color) { return addEntry(relativeValue, color); } public Entry addEntry(double relativeValue, Color color) { return addAndReturn(entries, makeEntry(relativeValue).color(color)); } public String toolTipForEntry(Entry e) { return e == null ? null : spaceCombine(or2(e.toolTip, e.text), renderValue(e.relativeValue())); } transient public IF1 renderValue; public String renderValue(double value) { return renderValue != null ? renderValue.get(value) : renderValue_base(value); } final public String renderValue_fallback(IF1 _f, double value) { return _f != null ? _f.get(value) : renderValue_base(value); } public String renderValue_base(double value) { return str(value); } public String toolTipForPosition(Pt p) { if (metaGet("scaffolding") != null) scaffoldCalled(this, "toolTipForPosition", p); int w = getWidth(); Entry e = firstThat(entries, _e -> p.x < xForEntry(_e, w)); if (scaffolded()) printVars("e", e, "xs", map(entries, _e -> xForEntry(_e, w))); return toolTipForEntry(e); } public JMultiColorBar() { varMax().onChange(() -> repaint()); jMinSize(50, 10, this); toolTipMaker = new InstantNeverHideToolTip(__1 -> toolTipForPosition(__1), this); } public int xForEntry(Entry e, int w) { return iround(w * clampZeroToOne(doubleRatio(e.value, max))); } public void paintComponent(Graphics g) { super.paintComponent(g); int w = getWidth(), h = getHeight(); int x = 0; for (var e : entries) { int x2 = loadableUtils.utils.max(x, xForEntry(e, w)); if (x2 > x) fillRect(g, x + 1, 0, x2 - x, h, e.color); x = x2; } } } static public class FollowTickerFile implements AutoCloseable, IFieldsToList { public File tickerFile; public FollowTickerFile() { } public FollowTickerFile(File tickerFile) { this.tickerFile = tickerFile; } public Object[] _fieldsToList() { return new Object[] { tickerFile }; } final public FollowTickerFile setHistoryEntriesToGrab(int historyEntriesToGrab) { return historyEntriesToGrab(historyEntriesToGrab); } public FollowTickerFile historyEntriesToGrab(int historyEntriesToGrab) { this.historyEntriesToGrab = historyEntriesToGrab; return this; } final public int getHistoryEntriesToGrab() { return historyEntriesToGrab(); } public int historyEntriesToGrab() { return historyEntriesToGrab; } public int historyEntriesToGrab; final public FollowTickerFile setInterval(int interval) { return interval(interval); } public FollowTickerFile interval(int interval) { this.interval = interval; return this; } final public int getInterval() { return interval(); } public int interval() { return interval; } public int interval = 250; final public FollowTickerFile setSleeper(ISleeper_v2 sleeper) { return sleeper(sleeper); } public FollowTickerFile sleeper(ISleeper_v2 sleeper) { this.sleeper = sleeper; return this; } final public ISleeper_v2 getSleeper() { return sleeper(); } public ISleeper_v2 sleeper() { return sleeper; } public ISleeper_v2 sleeper = defaultSleeper(); public TailFile tailFile; transient public Set> onHistoricLine; public FollowTickerFile onHistoricLine(IVF1 f) { onHistoricLine = createOrAddToSyncLinkedHashSet(onHistoricLine, f); return this; } public FollowTickerFile removeHistoricLineListener(IVF1 f) { loadableUtils.utils.remove(onHistoricLine, f); return this; } public void historicLine(String line) { if (onHistoricLine != null) for (var listener : onHistoricLine) pcallF_typed(listener, line); } transient public Set> onLiveLine; public FollowTickerFile onLiveLine(IVF1 f) { onLiveLine = createOrAddToSyncLinkedHashSet(onLiveLine, f); return this; } public FollowTickerFile removeLiveLineListener(IVF1 f) { loadableUtils.utils.remove(onLiveLine, f); return this; } public void liveLine(String line) { if (onLiveLine != null) for (var listener : onLiveLine) pcallF_typed(listener, line); } final public long getLiveTimestamp() { return liveTimestamp(); } public long liveTimestamp() { return liveTimestamp; } volatile public long liveTimestamp; final public String getLastLiveLine() { return lastLiveLine(); } public String lastLiveLine() { return lastLiveLine; } volatile public String lastLiveLine; final public FollowTickerFile setStarted(boolean started) { return started(started); } public FollowTickerFile started(boolean started) { this.started = started; return this; } final public boolean getStarted() { return started(); } public boolean started() { return started; } transient public boolean started = false; transient public Set onStarted; public FollowTickerFile onStarted(Runnable r) { onStarted = createOrAddToSyncLinkedHashSet(onStarted, r); return this; } public FollowTickerFile removeStartedListener(Runnable r) { loadableUtils.utils.remove(onStarted, r); return this; } public void fireStarted() { if (onStarted != null) for (var listener : onStarted) pcallF_typed(listener); } final public FollowTickerFile setMaxLineLengthForTickerEntry(int maxLineLengthForTickerEntry) { return maxLineLengthForTickerEntry(maxLineLengthForTickerEntry); } public FollowTickerFile maxLineLengthForTickerEntry(int maxLineLengthForTickerEntry) { this.maxLineLengthForTickerEntry = maxLineLengthForTickerEntry; return this; } final public int getMaxLineLengthForTickerEntry() { return maxLineLengthForTickerEntry(); } public int maxLineLengthForTickerEntry() { return maxLineLengthForTickerEntry; } public int maxLineLengthForTickerEntry = 200; final public FollowTickerFile setQ(Q q) { return q(q); } public FollowTickerFile q(Q q) { this.q = q; return this; } final public Q getQ() { return q(); } public Q q() { return q; } public Q q = startQ(); public boolean isLive() { return liveTimestamp != 0; } public void start() { q.add(new Runnable() { public void run() { try { if (started()) return; started(true); fireStarted(); onLiveLine(line -> { lastLiveLine = line; liveTimestamp = now(); }); long fileSize = l(tickerFile); long start = max(0, fileSize - maxLineLengthForTickerEntry * historyEntriesToGrab); if (historyEntriesToGrab > 0) { String text = loadTextFilePart(tickerFile, start, fileSize); List lastTickerLines = takeLast(historyEntriesToGrab, lines(text)); print("Have historic lines: " + l(lastTickerLines) + "/" + historyEntriesToGrab); for (var line : lastTickerLines) historicLine(line); } makeTailFile(fileSize); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (started()) return;\r\n started(true);\r\n fireStarted();\r\n \r\n ..."; } }); } public void makeTailFile(long fileSize) { started(true); print("Following " + tickerFile + " (" + n2(l(tickerFile)) + " bytes) from position " + n2(fileSize)); tailFile = tailFileLinewiseFromPosition(tickerFile, interval, fileSize, __1 -> liveLine(__1), sleeper); } public void close() { try { started(false); if (tailFile != null) { print("Done " + tailFile); { cleanUp(tailFile); tailFile = null; } } } catch (Exception __e) { throw rethrow(__e); } } public void switchToFile(File newFile) { if (eq(tickerFile, newFile)) return; q.add(new Runnable() { public void run() { try { if (eq(tickerFile, newFile)) return; print("Switching to ticker file: " + newFile); if (started()) { close(); tickerFile = newFile; started(true); makeTailFile(0); } else tickerFile = newFile; } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (eq(tickerFile, newFile)) return;\r\n print(\"Switching to ticker file: ..."; } }); } public FollowTickerFile onLine(IVF1 l) { onHistoricLine(l); return onLiveLine(l); } public String toString() { return commaCombine("FollowTickerFile", stringIf(started(), "started"), !isLive() ? null : "Last live line at " + formatLocalDateWithSeconds(liveTimestamp), tickerFile); } } static public class MountainsAndValleys { final public MountainsAndValleys setValues(double[] values) { return values(values); } public MountainsAndValleys values(double[] values) { this.values = values; return this; } final public double[] getValues() { return values(); } public double[] values() { return values; } public double[] values; final public IntBuffer getHighs() { return highs(); } public IntBuffer highs() { return highs; } public IntBuffer highs = new IntBuffer(); final public IntBuffer getLows() { return lows(); } public IntBuffer lows() { return lows; } public IntBuffer lows = new IntBuffer(); public MountainsAndValleys() { } public MountainsAndValleys(double[] values) { this.values = values; } public void run() { try { int n = l(values); if (n == 0) return; highs.add(0); lows.add(0); int i = 1; while (i < n) { var value = values[i]; int j = i + 1; while (j < n && values[j] == value) ++j; var last = values[i - 1]; var list = value > last ? highs : lows; if (values[list.last()] == last) list.popLast(); list.add(i); i = j; } } catch (Exception __e) { throw rethrow(__e); } } public double get(int idx) { return values[idx]; } public int prev(IntBuffer highsOrLows, int idx) { int j = intBufferBinarySearch(highsOrLows, idx - 1); if (j >= 0) return idx - 1; j = -j - 1; j--; return j >= 0 ? highsOrLows.get(j) : -1; } public int next(IntBuffer highsOrLows, int idx) { int j = intBufferBinarySearch(highsOrLows, idx + 1); if (j >= 0) return idx + 1; j = -j - 1; return j < l(highsOrLows) ? highsOrLows.get(j) : -1; } public int prevLowerOrHigher(IntBuffer highsOrLows, int idx, int direction) { double value = get(idx); while (true) { int j = prev(highsOrLows, idx); if (j < 0 || cmp(get(j), value) == direction) return j; idx = j; } } public int nextLowerOrHigher(IntBuffer highsOrLows, int idx, int direction) { double value = get(idx); while (true) { int j = next(highsOrLows, idx); if (j < 0 || cmp(get(j), value) == direction) return j; idx = j; } } public int prevHigh(int idx) { return prev(highs, idx); } public int nextHigh(int idx) { return next(highs, idx); } public int prevLow(int idx) { return prev(lows, idx); } public int nextLow(int idx) { return next(lows, idx); } public int prevLowerHigh(int idx) { return prevLowerOrHigher(highs, idx, 1); } public int prevLowerLow(int idx) { return prevLowerOrHigher(lows, idx, 1); } public int nextLowerHigh(int idx) { return nextLowerOrHigher(highs, idx, 1); } public int nextLowerLow(int idx) { return nextLowerOrHigher(lows, idx, 1); } public int nextLowOrHigh(int idx) { int low = nextLow(idx), high = nextHigh(idx); return high < 0 || low < high ? low : high; } } static public Object jsonDecode(String text) { return new jsonDecode_Y(text).parse(); } static public class jsonDecode_Y { public String text; public List tok; public boolean useOrderedMaps = false; public int i = 1; public jsonDecode_Y(String text) { this.text = text; tok = jsonTok(text); } transient public IF1 fail; public RuntimeException fail(String msg) { return fail != null ? fail.get(msg) : fail_base(msg); } final public RuntimeException fail_fallback(IF1 _f, String msg) { return _f != null ? _f.get(msg) : fail_base(msg); } public RuntimeException fail_base(String msg) { return loadableUtils.utils.fail(msg); } public Object parse() { if (l(tok) == 1) return null; return parseExpr(); } public Object parseExpr() { String t = tok.get(i); if (t.startsWith("\"") || t.startsWith("'")) { String s = unquote(tok.get(i)); i += 2; return s; } if (t.equals("{")) return parseMap(); if (t.equals("[")) return this.parseList(); if (t.equals("null")) { i += 2; return null; } if (t.equals("false")) { i += 2; return false; } if (t.equals("true")) { i += 2; return true; } boolean minus = false; if (t.equals("-")) { minus = true; i += 2; t = get(tok, i); } if (isInteger(t)) { int j = i; i += 2; if (eqOneOf(get(tok, i), ".", "e", "E")) { while (isInteger(get(tok, i)) || eqOneOf(get(tok, i), ".", "e", "E", "-")) i += 2; double d = parseDouble(joinSubList(tok, j, i - 1)); if (minus) d = -d; return d; } else { long l = parseLong(t); return boxedIntOrLong(minus ? -l : l); } } throw fail("Unknown token " + (i + 1) + ": " + t + ": " + text); } public Object parseList() { consume("["); List list = new ArrayList(); while (!tok.get(i).equals("]")) { list.add(parseExpr()); if (tok.get(i).equals(",")) i += 2; } consume("]"); return list; } public Object parseMap() { consume("{"); Map map = useOrderedMaps ? new LinkedHashMap() : new TreeMap(); while (!tok.get(i).equals("}")) { String key = unquote(tok.get(i)); i += 2; consume(":"); Object value = parseExpr(); map.put(key, value); if (tok.get(i).equals(",")) i += 2; } consume("}"); return map; } public void consume(String s) { if (!tok.get(i).equals(s)) { String prevToken = i - 2 >= 0 ? tok.get(i - 2) : ""; String nextTokens = join(tok.subList(i, Math.min(i + 4, tok.size()))); throw fail(quote(s) + " expected: " + prevToken + " " + nextTokens + " (" + i + "/" + tok.size() + ")"); } i += 2; } } static public class GazelleV_LeftArrowScript { abstract static public class Base extends HasTokenRangeWithSrc { public RuntimeException rethrowWithSrc(Throwable e) { return rethrowWithSrc("", e); } public RuntimeException rethrowWithSrc(String msg, Throwable e) { if (tokenRangeWithSrc() != null) throw new ScriptError(tokenRangeWithSrc(), msg, e); else throw rethrow(e); } public String indented() { return indentedScriptStruct(this); } public String shortenedSrc() { return shortenSrc(tokenRangeWithSrc()); } } static public class ScriptError extends RuntimeException implements IHasTokenRangeWithSrc { public ScriptError(TokenRangeWithSrc src, Throwable reason) { super(reason); tokenRangeWithSrc(src); } public ScriptError(TokenRangeWithSrc src, String msg, Throwable reason) { super(msg, reason); tokenRangeWithSrc(src); } final public ScriptError setTokenRangeWithSrc(TokenRangeWithSrc tokenRangeWithSrc) { return tokenRangeWithSrc(tokenRangeWithSrc); } public ScriptError tokenRangeWithSrc(TokenRangeWithSrc tokenRangeWithSrc) { this.tokenRangeWithSrc = tokenRangeWithSrc; return this; } final public TokenRangeWithSrc getTokenRangeWithSrc() { return tokenRangeWithSrc(); } public TokenRangeWithSrc tokenRangeWithSrc() { return tokenRangeWithSrc; } public TokenRangeWithSrc tokenRangeWithSrc; public TokenRangeWithSrc src() { return tokenRangeWithSrc(); } public String toString() { return super.toString() + "\n " + src() + " {{ " + shortenSrc(src()) + " }}"; } } static public String shortenSrc(TokenRangeWithSrc src) { return src == null ? null : shorten(nlToSpace(src.text())); } public interface Evaluable extends IF0, IHasTokenRangeWithSrc { public default Object get() { return get(new FlexibleVarContext()); } public Object get(VarContext ctx); public default LASValueDescriptor returnType() { return null; } public default Evaluable optimize() { return this; } public default Evaluable optimizeForReturnValueNotNeeded() { return this; } } abstract static public class EvaluableBase extends Base implements Evaluable { final public EvaluableBase setReturnType(LASValueDescriptor returnType) { return returnType(returnType); } public EvaluableBase returnType(LASValueDescriptor returnType) { this.returnType = returnType; return this; } final public LASValueDescriptor getReturnType() { return returnType(); } public LASValueDescriptor returnType() { return returnType; } public LASValueDescriptor returnType; public boolean returnValueNeeded = true; public Evaluable optimizeForReturnValueNotNeeded() { returnValueNeeded = false; return optimize(); } } static public AtomicLong scriptIDCounter = new AtomicLong(); static public long scriptID() { return incAtomicLong(scriptIDCounter); } static public class ListFromScript extends EvaluableBase implements IFieldsToList { public Script script; public ListFromScript() { } public ListFromScript(Script script) { this.script = script; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + script + ")"; } public Object[] _fieldsToList() { return new Object[] { script }; } public Object get(VarContext ctx) { return script.getAsList(ctx); } } static public class Script extends EvaluableBase { transient public long id = scriptID(); public Map functionDefs; public Evaluable[] steps; public Map params; public Script() { } public Script(List steps) { this.steps = toTypedArray(Evaluable.class, steps); } public Object get(VarContext ctx) { Object result = null; var pingSource = pingSource(); for (var step : steps) { ping(pingSource); result = step.get(ctx); var exiting = ctx.exitFromScript; if (exiting != null) { if (exiting == this) { ctx.exitFromScript = null; result = ctx.returnValue; ctx.returnValue(null); return result; } return null; } } return result; } public Object getAsList(VarContext ctx) { Object result = null; var pingSource = pingSource(); List list = new ArrayList(); for (var step : steps) { ping(pingSource); list.add(step.get(ctx)); var exiting = ctx.exitFromScript; if (exiting != null) { if (exiting == this) { ctx.exitFromScript = null; result = ctx.returnValue; ctx.returnValue(null); list.add(result); return list; } return null; } } return list; } public String toStringLong() { return pnlToLines(steps); } public String toString() { return "Script " + n2(id); } public FunctionDef getFunction(String name) { return mapGet(functionDefs, name); } final public Script optimize() { return optimizeScript(); } public Script optimizeScript() { int n = returnValueNeeded ? steps.length - 1 : steps.length; for (int i = 0; i < n; i++) steps[i] = steps[i].optimizeForReturnValueNotNeeded(); for (var f : values(functionDefs)) f.optimize(); return this; } } static public class FunctionDef extends Base implements IFieldsToList { public String name; public String[] args; public Script body; public FunctionDef() { } public FunctionDef(String name, String[] args, Script body) { this.body = body; this.args = args; this.name = name; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + name + ", " + args + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { name, args, body }; } final public FunctionDef setReturnType(Type returnType) { return returnType(returnType); } public FunctionDef returnType(Type returnType) { this.returnType = returnType; return this; } final public Type getReturnType() { return returnType(); } public Type returnType() { return returnType; } public Type returnType = Object.class; final public FunctionDef setArgTypes(LASValueDescriptor[] argTypes) { return argTypes(argTypes); } public FunctionDef argTypes(LASValueDescriptor[] argTypes) { this.argTypes = argTypes; return this; } final public LASValueDescriptor[] getArgTypes() { return argTypes(); } public LASValueDescriptor[] argTypes() { return argTypes; } public LASValueDescriptor[] argTypes; final public FunctionDef setSynthetic(boolean synthetic) { return synthetic(synthetic); } public FunctionDef synthetic(boolean synthetic) { this.synthetic = synthetic; return this; } final public boolean getSynthetic() { return synthetic(); } public boolean synthetic() { return synthetic; } public boolean synthetic = false; public FunctionDef(String name, List args, Script body) { this.args = toStringArray(args); this.body = body; this.name = name; } public Object callFromOutside(Object... args) { return call(new FlexibleVarContext(), args); } public Object call(VarContext ctx, Object... args) { VarContext ctx2 = new FlexibleVarContext(ctx); int n = min(l(args), l(this.args)); for (int i = 0; i < n; i++) ctx2.put(this.args[i], args[i]); return body.get(ctx2); } public void optimize() { body = body.optimize(); } public boolean isConstructor() { return eq(name, ""); } } static public class Assignment extends EvaluableBase implements IFieldsToList { public String var; public Evaluable expression; public Assignment() { } public Assignment(String var, Evaluable expression) { this.expression = expression; this.var = var; } public Object[] _fieldsToList() { return new Object[] { var, expression }; } public Object get(VarContext ctx) { Object o = expression.get(ctx); ctx.set(var, o); return o; } public String toString() { return var + " <- " + expression; } } static public class VarDeclaration extends EvaluableBase implements IFieldsToList { public String var; public Class type; public Evaluable expression; public VarDeclaration() { } public VarDeclaration(String var, Class type, Evaluable expression) { this.expression = expression; this.type = type; this.var = var; } public Object[] _fieldsToList() { return new Object[] { var, type, expression }; } public Object get(VarContext ctx) { try { Object o = expression == null ? null : expression.get(ctx); ctx.set(var, o); return o; } catch (Throwable e) { throw rethrowWithSrc(e); } } public String toString() { return "var " + var + " <- " + expression; } } static public class AssignmentToOuterVar extends EvaluableBase implements IFieldsToList { public String var; public Evaluable expression; public AssignmentToOuterVar() { } public AssignmentToOuterVar(String var, Evaluable expression) { this.expression = expression; this.var = var; } public Object[] _fieldsToList() { return new Object[] { var, expression }; } public Object get(VarContext ctx) { var parent = ctx.parent(); assertNotNull("No outer variable context", parent); Object o = expression.get(ctx); parent.set(var, o); return o; } public String toString() { return "outer " + var + " <- " + expression; } } static public class NewObject extends EvaluableBase { public NewObject() { } public Class c; public Evaluable[] args; public NewObject(Class c) { this(c, null); } public NewObject(Class c, Evaluable[] args) { this.args = args; this.c = c; returnType(new LASValueDescriptor.Exact(c, false)); } public Object get(VarContext ctx) { try { return preciseNuObject(c, evalArgs(args, ctx)); } catch (Throwable e) { throw rethrowWithSrc(e); } } public String toString() { return "new " + formatFunctionCall(className(c), args); } } static public class NewObject_LASClass extends NewObject { public NewObject_LASClass() { } public ResolvableLASClass lasClass; public NewObject_LASClass(ResolvableLASClass lasClass) { this.lasClass = lasClass; } public NewObject_LASClass(ResolvableLASClass lasClass, Evaluable[] args) { this.args = args; this.lasClass = lasClass; } public void resolve() { if (c == null) c = lasClass.get(); } public Object get(VarContext ctx) { resolve(); return super.get(ctx); } public String toString() { return "new " + formatFunctionCall(str(lasClass), args); } } static public class NewObject_UnknownClass extends NewObject implements IFieldsToList { public Evaluable classExpr; public Evaluable[] args; public NewObject_UnknownClass() { } public NewObject_UnknownClass(Evaluable classExpr, Evaluable[] args) { this.args = args; this.classExpr = classExpr; } public Object[] _fieldsToList() { return new Object[] { classExpr, args }; } public Object get(VarContext ctx) { try { Class c = (Class) (classExpr.get(ctx)); return preciseNuObject(c, evalArgs(args, ctx)); } catch (Throwable e) { throw rethrowWithSrc(e); } } public String toString() { return "new " + formatFunctionCall(classExpr, args); } } static public class CallFunction extends EvaluableBase implements IFieldsToList { public FunctionDef f; public Evaluable[] args; public CallFunction() { } public CallFunction(FunctionDef f, Evaluable[] args) { this.args = args; this.f = f; } public Object[] _fieldsToList() { return new Object[] { f, args }; } public Object get(VarContext ctx) { var evaledArgs = evalArgs(args, ctx); if (ctx.exiting()) return null; return f.call(ctx, evaledArgs); } public String toString() { return formatFunctionCall(f.name, args); } public LASValueDescriptor returnType() { return LASValueDescriptor.fromType(f.getReturnType()); } } static public class GetVar extends EvaluableBase implements IFieldsToList { public String var; public GetVar() { } public GetVar(String var) { this.var = var; } public Object[] _fieldsToList() { return new Object[] { var }; } public Object get(VarContext ctx) { return ctx.get(var); } public String toString() { return var; } } static public class Const extends EvaluableBase implements IFieldsToList { public Object value; public Const() { } public Const(Object value) { this.value = value; } public Object[] _fieldsToList() { return new Object[] { value }; } public Object get(VarContext ctx) { return value; } public String toString() { return strOrClassName(value); } public LASValueDescriptor returnType() { return new LASValueDescriptor.KnownValue(value); } public Object _serialize() { boolean ok = isUnproblematicValue(value); return ok ? this : toStringWithClass(value); } } static public class GetStaticField extends EvaluableBase implements IFieldsToList { public Field field; public GetStaticField() { } public GetStaticField(Field field) { this.field = field; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + field + ")"; } public Object[] _fieldsToList() { return new Object[] { field }; } public Object get(VarContext ctx) { try { return field.get(null); } catch (Exception __e) { throw rethrow(__e); } } public String _serialize() { return str(field); } } abstract static public class CallOnTarget extends EvaluableBase implements IFieldsToList { public Evaluable target; public CallOnTarget() { } public CallOnTarget(Evaluable target) { this.target = target; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + target + ")"; } public Object[] _fieldsToList() { return new Object[] { target }; } final public CallOnTarget setAllowNullReference(boolean allowNullReference) { return allowNullReference(allowNullReference); } public CallOnTarget allowNullReference(boolean allowNullReference) { this.allowNullReference = allowNullReference; return this; } final public boolean getAllowNullReference() { return allowNullReference(); } public boolean allowNullReference() { return allowNullReference; } public boolean allowNullReference = false; public Object handleNullReference() { if (allowNullReference) return null; else throw new NullPointerException(); } abstract public Object evalOnTarget(VarContext ctx, Object object); public Object get(VarContext ctx) { try { Object object = target.get(ctx); if (object == null) return handleNullReference(); return evalOnTarget(ctx, object); } catch (Throwable e) { throw rethrowWithSrc(e); } } } static public class CallMethodOrGetField extends CallOnTarget { public CallMethodOrGetField() { } public String name; public CallMethodOrGetField(Evaluable target, String name) { this.name = name; this.target = target; } public Object evalOnTarget(VarContext ctx, Object object) { try { return preciseGetOrCallMethod(object, name); } catch (Throwable e) { throw rethrowWithSrc("Was getting " + name, e); } } } static public class GetField extends CallOnTarget { public GetField() { } public String name; public GetField(Evaluable target, String name) { this.name = name; this.target = target; } public Object evalOnTarget(VarContext ctx, Object object) { try { return _get(object, name); } catch (Throwable e) { throw rethrowWithSrc("Was getting " + name, e); } } } static public class GetVarContext extends EvaluableBase { public Object get(VarContext ctx) { return ctx; } } static public class ThrowMethodNotFoundException extends EvaluableBase implements IFieldsToList { public CallMethod instruction; public ThrowMethodNotFoundException() { } public ThrowMethodNotFoundException(CallMethod instruction) { this.instruction = instruction; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + instruction + ")"; } public Object[] _fieldsToList() { return new Object[] { instruction }; } public Object get(VarContext ctx) { throw fail("Method not found: " + instruction); } } static public class ThrowNullPointerException extends EvaluableBase implements IFieldsToList { public CallMethod instruction; public ThrowNullPointerException() { } public ThrowNullPointerException(CallMethod instruction) { this.instruction = instruction; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + instruction + ")"; } public Object[] _fieldsToList() { return new Object[] { instruction }; } public Object get(VarContext ctx) { throw fail("Null pointer exception: " + instruction); } } static public class CallMethod extends CallOnTarget { public CallMethod() { } public String methodName; public Evaluable[] args; public CallMethod(Evaluable target, String methodName, Evaluable[] args) { this.args = args; this.methodName = methodName; this.target = target; } public Object evalOnTarget(VarContext ctx, Object object) { return newPreciseCall(object, methodName, evalArgs(args, ctx)); } public String toString() { return target + "." + formatFunctionCall(methodName, args); } public Evaluable optimize() { var targetType = target.returnType(); if (targetType != null && targetType.knownValue()) { Object o = targetType.value(); if (o == null) return allowNullReference ? _const(null) : new ThrowNullPointerException(this); Class[] argTypes = new Class[l(args)]; for (int i = 0; i < l(args); i++) { var type = args[i].returnType(); if (type == null || !type.javaClassIsExact()) return this; argTypes[i] = type.javaClass(); } List methods = findMethodsNamed_cached(o, methodName); if (any(methods, m -> m.isVarArgs())) return this; var __4 = findMethod_withPrimitiveWidening_onTypes(o, methodName, argTypes); var method = __4.a; var widening = __4.b; if (method == null) return new ThrowMethodNotFoundException(this); return new DirectMethodCallOnKnownTarget(widening, o instanceof Class ? null : o, method, args); } return this; } } static public Object[] evalArgs(Evaluable[] args, VarContext ctx) { return mapToArrayOrNull(args, arg -> arg.get(ctx)); } static public class CallMethodOrGlobalFunction extends CallMethod { public CallMethodOrGlobalFunction() { } public MethodOnObject globalFunction; static final public Object methodNotFoundSentinel = new Object(); public CallMethodOrGlobalFunction(Evaluable target, String methodName, MethodOnObject globalFunction, Evaluable[] args) { this.args = args; this.globalFunction = globalFunction; this.methodName = methodName; this.target = target; } public String toString() { return target + "." + formatFunctionCall(methodName + "+", args); } public Object evalOnTarget(VarContext ctx, Object o) { Object[] realArgs = evalArgs(args, ctx); Object result = newPreciseCall_sentinel(o, methodName, methodNotFoundSentinel, realArgs); if (result != methodNotFoundSentinel) return result; return newPreciseCall(globalFunction.object, globalFunction.method, itemPlusArray(o, realArgs)); } } static public class CallMethodOrGetFieldOrGlobalFunction extends CallMethodOrGetField { public CallMethodOrGetFieldOrGlobalFunction() { } public MethodOnObject globalFunction; static final public Object notFoundSentinel = new Object(); public CallMethodOrGetFieldOrGlobalFunction(Evaluable target, String name, MethodOnObject globalFunction) { this.globalFunction = globalFunction; this.name = name; this.target = target; } public String toString() { return target + "." + name + "+"; } public Object evalOnTarget(VarContext ctx, Object o) { try { Object result = preciseGetOrCallMethod_sentinel(o, name, notFoundSentinel); if (result != notFoundSentinel) return result; return newPreciseCall(globalFunction.object, globalFunction.method, o); } catch (Throwable e) { throw rethrowWithSrc("Was getting " + name, e); } } } abstract static public class LambdaBase extends EvaluableBase implements IFieldsToList { public Class intrface; public LambdaBase() { } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + intrface + ")"; } public Object[] _fieldsToList() { return new Object[] { intrface }; } transient public Method implementedMethod; public LambdaBase(Class intrface) { this.intrface = intrface; implementedMethod = findSingleInterfaceMethodOrFail(intrface); } } static public class LambdaMethodOnArgument extends LambdaBase { public String methodName; public Evaluable[] args; public LambdaMethodOnArgument(Class intrface, String methodName, Evaluable[] args) { super(intrface); this.args = args; this.methodName = methodName; } public Object get(VarContext ctx) { return proxyFromInvocationHandler(intrface, (proxy, method, actualArgs) -> { if (method.getDeclaringClass() == intrface) return forwardCall(actualArgs[0], ctx); else return handleObjectMethodsInProxyInvocationHandler(this, implementedMethod, method, proxy, actualArgs); }); } public Object forwardCall(Object target, VarContext ctx) { return call(target, methodName, evalArgs(args, ctx)); } } static public class LambdaDef extends EvaluableBase implements IFieldsToList { public Class intrface; public String[] args; public Evaluable body; public LambdaDef() { } public Object[] _fieldsToList() { return new Object[] { intrface, args, body }; } public Map argTypes = new HashMap(); transient public Method implementedMethod; public LambdaDef(Class intrface, String[] args, Evaluable body) { this.body = body; this.args = args; this.intrface = intrface; implementedMethod = findSingleInterfaceMethodOrFail(intrface); if (implementedMethod.getParameterCount() != l(args)) throw fail("Bad parameter count for lambda: " + implementedMethod + " vs: " + joinWithComma(args)); } public Object get(VarContext ctx) { return proxyFromInvocationHandler(intrface, (proxy, method, actualArgs) -> { ping(); if (method.getDeclaringClass() == intrface) { var ctx2 = new FlexibleVarContext(ctx); var argNames = args; for (int i = 0; i < l(args); i++) ctx2.put(argNames[i], actualArgs[i]); return body.get(ctx2); } else return handleObjectMethodsInProxyInvocationHandler(this, implementedMethod, method, proxy, actualArgs); }); } public String toString() { return "Lambda(" + shortenedSrc() + ")"; } } abstract static public class CurriedLambdaBase extends EvaluableBase implements IFieldsToList { public Class intrface; public Evaluable[] curriedArgs; public CurriedLambdaBase() { } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + intrface + ", " + curriedArgs + ")"; } public Object[] _fieldsToList() { return new Object[] { intrface, curriedArgs }; } transient public Method implementedMethod; public CurriedLambdaBase(Class intrface, Evaluable[] curriedArgs) { this.curriedArgs = curriedArgs; this.intrface = intrface; implementedMethod = findSingleInterfaceMethodOrFail(intrface); } public Object get(VarContext ctx) { try { Object[] curriedArguments = evalArgs(curriedArgs, ctx); return proxyFromInvocationHandler(intrface, (proxy, method, actualArgs) -> { try { if (method.getDeclaringClass() == intrface) return forwardCall(ctx, concatMethodArgs(curriedArguments, actualArgs)); else return handleObjectMethodsInProxyInvocationHandler(this, implementedMethod, method, proxy, actualArgs); } catch (Throwable e) { throw rethrowWithSrc(e); } }); } catch (Throwable e) { throw rethrowWithSrc(e); } } abstract public Object forwardCall(VarContext ctx, Object[] args); } static public class CurriedMethodLambda extends CurriedLambdaBase { public CurriedMethodLambda() { } public Object target; public String targetMethod; public CurriedMethodLambda(Class intrface, Object target, String targetMethod, Evaluable[] curriedArgs) { super(intrface, curriedArgs); this.targetMethod = targetMethod; this.target = target; } public Object forwardCall(VarContext ctx, Object[] args) { return newPreciseCall(target, targetMethod, args); } } static public class CurriedScriptFunctionLambda extends CurriedLambdaBase { public FunctionDef f; public CurriedScriptFunctionLambda(Class intrface, FunctionDef f, Evaluable[] curriedArgs) { super(intrface, curriedArgs); this.f = f; } public Object forwardCall(VarContext ctx, Object[] args) { return f.call(ctx, args); } } static public class CurriedConstructorLambda extends CurriedLambdaBase { public Constructor[] ctors; public CurriedConstructorLambda(Class intrface, Constructor[] ctors, Evaluable[] curriedArgs) { super(intrface, curriedArgs); this.ctors = ctors; } public Object forwardCall(VarContext ctx, Object[] args) { return preciseNuObject(ctors, args); } } static public class DirectMethodCallOnKnownTarget extends EvaluableBase implements IFieldsToList { public boolean widening = false; public Object target; public Method method; public Evaluable[] args; public DirectMethodCallOnKnownTarget() { } public DirectMethodCallOnKnownTarget(boolean widening, Object target, Method method, Evaluable[] args) { this.args = args; this.method = method; this.target = target; this.widening = widening; } public Object[] _fieldsToList() { return new Object[] { widening, target, method, args }; } public Object get(VarContext ctx) { var evaluatedArgs = evalArgs(args, ctx); return widening ? invokeMethodWithWidening(method, target, evaluatedArgs) : invokeMethod(method, target, evaluatedArgs); } public String toString() { return (target == null ? "" : target + ".") + formatFunctionCall(str(method), args); } public LASValueDescriptor returnType() { return LASValueDescriptor.fromClass(method.getReturnType()); } } static public class While extends EvaluableBase implements IFieldsToList { public Evaluable condition; public Evaluable body; public While() { } public While(Evaluable condition, Evaluable body) { this.body = body; this.condition = condition; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + condition + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { condition, body }; } public Object get(VarContext ctx) { while (!ctx.exiting() && (Boolean) condition.get(ctx)) { body.get(ctx); } return null; } } abstract static public class ForEachBase extends EvaluableBase implements IFieldsToList { public Evaluable collection; public Evaluable body; public ForEachBase() { } public ForEachBase(Evaluable collection, Evaluable body) { this.body = body; this.collection = collection; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + collection + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { collection, body }; } public Object get(VarContext ctx) { var coll = collection.get(ctx); Iterator iterator; List out; try { if (coll == null) out = new ArrayList(); else if (coll.getClass().isArray()) { if (coll instanceof Object[]) { var array = (Object[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof byte[]) { var array = (byte[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof short[]) { var array = (short[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof double[]) { var array = (double[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof float[]) { var array = (float[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof int[]) { var array = (int[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof long[]) { var array = (long[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof char[]) { var array = (char[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else if (coll instanceof boolean[]) { var array = (boolean[]) coll; out = emptyList(array.length); for (var element : array) { if (ctx.exiting()) return null; processElement(ctx, out, element); } } else throw fail("todo for each with: " + coll); } else if (coll instanceof Iterable) { out = emptyList((Iterable) coll); iterator = ((Iterable) coll).iterator(); try { while (iterator.hasNext()) { if (ctx.exiting()) return null; var element = iterator.next(); processElement(ctx, out, element); } } finally { if (iterator instanceof AutoCloseable) { try { ((AutoCloseable) iterator).close(); } catch (Exception __e) { throw rethrow(__e); } } } } else throw fail("Not iterable: " + className(coll)); } finally { loopDone(ctx); } return out; } abstract public void processElement(VarContext ctx, List out, Object o); abstract public void loopDone(VarContext ctx); } static public class ForEach extends ForEachBase { public ForEach() { } public String var; final public ForEach setVarType(LASValueDescriptor varType) { return varType(varType); } public ForEach varType(LASValueDescriptor varType) { this.varType = varType; return this; } final public LASValueDescriptor getVarType() { return varType(); } public LASValueDescriptor varType() { return varType; } public LASValueDescriptor varType; public ForEach(Evaluable collection, String var, Evaluable body) { this.body = body; this.var = var; this.collection = collection; } public void processElement(VarContext ctx, List out, Object o) { ctx.set(var, o); out.add(body.get(ctx)); } public void loopDone(VarContext ctx) { ctx.unset(var); } } static public class ForIterator extends EvaluableBase implements IFieldsToList { static final public String _fieldOrder = "iterable var body"; public Evaluable iterable; public String var; public Evaluable body; public ForIterator() { } public ForIterator(Evaluable iterable, String var, Evaluable body) { this.body = body; this.var = var; this.iterable = iterable; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + iterable + ", " + var + ", " + body + ")"; } public boolean equals(Object o) { if (!(o instanceof ForIterator)) return false; ForIterator __5 = (ForIterator) o; return eq(iterable, __5.iterable) && eq(var, __5.var) && eq(body, __5.body); } public int hashCode() { int h = -214906825; h = boostHashCombine(h, _hashCode(iterable)); h = boostHashCombine(h, _hashCode(var)); h = boostHashCombine(h, _hashCode(body)); return h; } public Object[] _fieldsToList() { return new Object[] { iterable, var, body }; } public Object get(VarContext ctx) { VarContext subContext = new FlexibleVarContext(ctx); var iterable = this.iterable.get(ctx); Iterator iterator = iterator_gen(iterable); return new MapI(value -> { subContext.set(var, value); return body.get(subContext); }, iterator); } } static public class ForNested extends EvaluableBase implements IFieldsToList { static final public String _fieldOrder = "iterable var body"; public Evaluable iterable; public String var; public Evaluable body; public ForNested() { } public ForNested(Evaluable iterable, String var, Evaluable body) { this.body = body; this.var = var; this.iterable = iterable; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + iterable + ", " + var + ", " + body + ")"; } public boolean equals(Object o) { if (!(o instanceof ForNested)) return false; ForNested __6 = (ForNested) o; return eq(iterable, __6.iterable) && eq(var, __6.var) && eq(body, __6.body); } public int hashCode() { int h = -1363247360; h = boostHashCombine(h, _hashCode(iterable)); h = boostHashCombine(h, _hashCode(var)); h = boostHashCombine(h, _hashCode(body)); return h; } public Object[] _fieldsToList() { return new Object[] { iterable, var, body }; } public Object get(VarContext ctx) { VarContext subContext = new FlexibleVarContext(ctx); var iterable = this.iterable.get(ctx); Iterator iterator = iterator_gen(iterable); return nestedIterator(iterator, value -> { subContext.set(var, value); return iterator_gen(body.get(subContext)); }); } } static public class ForPairs extends ForEachBase { public ForPairs() { } public String varA, varB; public ForPairs(Evaluable collection, Evaluable body, String varA, String varB) { this.varB = varB; this.varA = varA; this.body = body; this.collection = collection; } public void processElement(VarContext ctx, List out, Object o) { Pair p = (Pair) o; ctx.set(varA, p.a); ctx.set(varB, p.b); out.add(body.get(ctx)); } public void loopDone(VarContext ctx) { ctx.unset(varA); ctx.unset(varB); } } static public class ForKeyValue extends EvaluableBase implements IFieldsToList { public Evaluable map; public Evaluable body; public String varA; public String varB; public ForKeyValue() { } public ForKeyValue(Evaluable map, Evaluable body, String varA, String varB) { this.varB = varB; this.varA = varA; this.body = body; this.map = map; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + map + ", " + body + ", " + varA + ", " + varB + ")"; } public Object[] _fieldsToList() { return new Object[] { map, body, varA, varB }; } public Object get(VarContext ctx) { Map theMap = (Map) map.get(ctx); List out; try { if (theMap != null) { out = emptyList(theMap.size()); for (var entry : theMap.entrySet()) { if (ctx.exiting()) return null; ctx.set(varA, entry.getKey()); ctx.set(varB, entry.getValue()); out.add(body.get(ctx)); } } else out = new ArrayList(); } finally { ctx.unset(varA); ctx.unset(varB); } return out; } } static public class ForIntTo extends EvaluableBase implements IFieldsToList { public Evaluable endValue; public String var; public Evaluable body; public ForIntTo() { } public ForIntTo(Evaluable endValue, String var, Evaluable body) { this.body = body; this.var = var; this.endValue = endValue; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + endValue + ", " + var + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { endValue, var, body }; } public Evaluable optimize() { if (!returnValueNeeded) body = body.optimizeForReturnValueNotNeeded(); return this; } public Object get(VarContext ctx) { int n = (Integer) endValue.get(ctx), i = 0; List out = returnValueNeeded ? new ArrayList() : null; try { ctx.put(var, i); while (i < n) { if (ctx.exiting()) return null; Object o = body.get(ctx); { if (out != null) out.add(o); } ctx.set(var, i = (Integer) ctx.get(var) + 1); } } finally { ctx.unset(var); } return out; } } static public class ForIndex extends EvaluableBase { public ForIndex() { } public Evaluable collection, body; public String varIndex, varElement; public ForIndex(Evaluable collection, Evaluable body, String varIndex, String varElement) { this.varElement = varElement; this.varIndex = varIndex; this.body = body; this.collection = collection; } public Object get(VarContext ctx) { return new ForIndex_instance(collection, body, varIndex, varElement).get(ctx); } } static public class ForIndex_instance extends ForEachBase { public String varIndex, varElement; public int index; public ForIndex_instance(Evaluable collection, Evaluable body, String varIndex, String varElement) { this.varElement = varElement; this.varIndex = varIndex; this.body = body; this.collection = collection; } public void processElement(VarContext ctx, List out, Object o) { ctx.set(varIndex, index++); ctx.set(varElement, o); out.add(body.get(ctx)); } public void loopDone(VarContext ctx) { ctx.unset(varIndex); ctx.unset(varElement); } } static public class IfThen extends EvaluableBase implements IFieldsToList { public Evaluable condition; public Evaluable body; public Evaluable elseBranch; public IfThen() { } public IfThen(Evaluable condition, Evaluable body, Evaluable elseBranch) { this.elseBranch = elseBranch; this.body = body; this.condition = condition; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + condition + ", " + body + ", " + elseBranch + ")"; } public Object[] _fieldsToList() { return new Object[] { condition, body, elseBranch }; } public IfThen(Evaluable condition, Evaluable body) { this.condition = condition; this.body = body; } public Object get(VarContext ctx) { if ((Boolean) condition.get(ctx)) return body.get(ctx); else if (elseBranch != null) return elseBranch.get(ctx); else return null; } } static public class ReturnFromScript extends EvaluableBase implements IFieldsToList { public Script script; public Evaluable value; public ReturnFromScript() { } public ReturnFromScript(Script script, Evaluable value) { this.value = value; this.script = script; } public Object[] _fieldsToList() { return new Object[] { script, value }; } public Object get(VarContext ctx) { Object result = value.get(ctx); ctx.exitFromScript(script); ctx.returnValue(result); return null; } public String toString() { return formatFunctionCall("ReturnFromScript", script, value); } } static public class Continue extends EvaluableBase implements IFieldsToList { public Script loopBody; public Continue() { } public Continue(Script loopBody) { this.loopBody = loopBody; } public Object[] _fieldsToList() { return new Object[] { loopBody }; } public Object get(VarContext ctx) { ctx.exitFromScript(loopBody); ctx.returnValue(null); return null; } public String toString() { return formatFunctionCall("Continue", loopBody); } } static public class RepeatN extends EvaluableBase implements IFieldsToList { public Evaluable n; public Evaluable body; public RepeatN() { } public RepeatN(Evaluable n, Evaluable body) { this.body = body; this.n = n; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + n + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { n, body }; } public Object get(VarContext ctx) { long count = ((Number) n.get(ctx)).longValue(); for (int _repeat_0 = 0; _repeat_0 < count; _repeat_0++) { if (ctx.exiting()) return null; body.get(ctx); } return null; } } static public class BoolAnd extends EvaluableBase implements IFieldsToList { public Evaluable a; public Evaluable b; public BoolAnd() { } public BoolAnd(Evaluable a, Evaluable b) { this.b = b; this.a = a; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + a + ", " + b + ")"; } public boolean equals(Object o) { if (!(o instanceof BoolAnd)) return false; BoolAnd __7 = (BoolAnd) o; return eq(a, __7.a) && eq(b, __7.b); } public int hashCode() { int h = 1729330797; h = boostHashCombine(h, _hashCode(a)); h = boostHashCombine(h, _hashCode(b)); return h; } public Object[] _fieldsToList() { return new Object[] { a, b }; } public Object get(VarContext ctx) { if (!((Boolean) a.get(ctx))) return false; return b.get(ctx); } } static public class BoolOr extends EvaluableBase implements IFieldsToList { public Evaluable a; public Evaluable b; public BoolOr() { } public BoolOr(Evaluable a, Evaluable b) { this.b = b; this.a = a; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + a + ", " + b + ")"; } public boolean equals(Object o) { if (!(o instanceof BoolOr)) return false; BoolOr __8 = (BoolOr) o; return eq(a, __8.a) && eq(b, __8.b); } public int hashCode() { int h = 1995447949; h = boostHashCombine(h, _hashCode(a)); h = boostHashCombine(h, _hashCode(b)); return h; } public Object[] _fieldsToList() { return new Object[] { a, b }; } public Object get(VarContext ctx) { if (((Boolean) a.get(ctx))) return true; return b.get(ctx); } } static public class TempBlock extends EvaluableBase implements IFieldsToList { public Evaluable tempExpr; public Evaluable body; public TempBlock() { } public TempBlock(Evaluable tempExpr, Evaluable body) { this.body = body; this.tempExpr = tempExpr; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + tempExpr + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { tempExpr, body }; } public Object get(VarContext ctx) { AutoCloseable __2 = (AutoCloseable) (tempExpr.get(ctx)); try { return body.get(ctx); } finally { _close(__2); } } } static public class WillReturn extends EvaluableBase implements IFieldsToList { public Evaluable exp; public Evaluable body; public WillReturn() { } public WillReturn(Evaluable exp, Evaluable body) { this.body = body; this.exp = exp; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + exp + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { exp, body }; } public Object get(VarContext ctx) { body.get(ctx); return exp.get(ctx); } } static public class ClassDef extends EvaluableBase implements IFieldsToList { public ResolvableLASClass lasClass; public ClassDef() { } public ClassDef(ResolvableLASClass lasClass) { this.lasClass = lasClass; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + lasClass + ")"; } public boolean equals(Object o) { if (!(o instanceof ClassDef)) return false; ClassDef __9 = (ClassDef) o; return eq(lasClass, __9.lasClass); } public int hashCode() { int h = 757052301; h = boostHashCombine(h, _hashCode(lasClass)); return h; } public Object[] _fieldsToList() { return new Object[] { lasClass }; } public Object get(VarContext ctx) { return lasClass.get(); } } static public class SetField extends EvaluableBase implements IFieldsToList { public Evaluable target; public String name; public Evaluable expr; public SetField() { } public SetField(Evaluable target, String name, Evaluable expr) { this.expr = expr; this.name = name; this.target = target; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + target + ", " + name + ", " + expr + ")"; } public Object[] _fieldsToList() { return new Object[] { target, name, expr }; } final public SetField setAllowNullReference(boolean allowNullReference) { return allowNullReference(allowNullReference); } public SetField allowNullReference(boolean allowNullReference) { this.allowNullReference = allowNullReference; return this; } final public boolean getAllowNullReference() { return allowNullReference(); } public boolean allowNullReference() { return allowNullReference; } public boolean allowNullReference = false; public Object handleNullReference() { if (allowNullReference) return null; else throw new NullPointerException(); } public Object get(VarContext ctx) { try { Object value = expr.get(ctx); Object object = target.get(ctx); if (object == null) handleNullReference(); else set(object, name, value); return value; } catch (Throwable e) { throw rethrowWithSrc(e); } } } static public class SetStaticField extends EvaluableBase implements IFieldsToList { public Field field; public Evaluable expr; public SetStaticField() { } public SetStaticField(Field field, Evaluable expr) { this.expr = expr; this.field = field; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + field + ", " + expr + ")"; } public Object[] _fieldsToList() { return new Object[] { field, expr }; } public Object get(VarContext ctx) { try { Object value = expr.get(ctx); field.set(null, value); return value; } catch (Throwable e) { throw rethrowWithSrc(e); } } } static public class Throw extends EvaluableBase implements IFieldsToList { public Evaluable expr; public Throw() { } public Throw(Evaluable expr) { this.expr = expr; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + expr + ")"; } public Object[] _fieldsToList() { return new Object[] { expr }; } public Object get(VarContext ctx) { throw asRuntimeException((Throwable) expr.get(ctx)); } } static public class TryCatch extends EvaluableBase implements IFieldsToList { public Evaluable body; public String var; public Evaluable catchBlock; public TryCatch() { } public TryCatch(Evaluable body, String var, Evaluable catchBlock) { this.catchBlock = catchBlock; this.var = var; this.body = body; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + body + ", " + var + ", " + catchBlock + ")"; } public Object[] _fieldsToList() { return new Object[] { body, var, catchBlock }; } public Object get(VarContext ctx) { try { return body.get(ctx); } catch (Throwable e) { var addVar = var == null ? null : ctx.tempPut(var, e); AutoCloseable __3 = addVar; try { return catchBlock.get(ctx); } finally { _close(__3); } } } } static public class TryFinally extends EvaluableBase implements IFieldsToList { public Evaluable body; public Evaluable finallyBlock; public TryFinally() { } public TryFinally(Evaluable body, Evaluable finallyBlock) { this.finallyBlock = finallyBlock; this.body = body; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + body + ", " + finallyBlock + ")"; } public Object[] _fieldsToList() { return new Object[] { body, finallyBlock }; } public Object get(VarContext ctx) { try { return body.get(ctx); } finally { finallyBlock.get(ctx); } } } static public structure_Data structureDataForLAS() { structure_Data d = new structure_Data(); d.skipDefaultValues(true); d.shouldIncludeField = field -> { String c = shortClassName(field.getDeclaringClass()); String f = field.getName(); boolean shouldInclude = !(eq(c, "HasTokenRangeWithSrc") && eq(f, "src")); return shouldInclude; }; return d; } static public boolean isUnproblematicValue(Object o) { return o == null || o instanceof Number || o instanceof String || o instanceof Boolean || o instanceof Class; } static public String scriptStruct(Object o) { String s = struct(o, structureDataForLAS()); List tok = structTok(s); String prefix = shortName(GazelleV_LeftArrowScript.class) + "$"; for (int i = 1; i < l(tok); i += 2) tok.set(i, replacePrefix(prefix, "$", tok.get(i))); return join(tok); } static public String indentedScriptStruct(Object o) { return indentStructureString(scriptStruct(o)); } static public Evaluable _const(Object o) { return new Const(o); } static public class Then extends CallOnTarget { public CallOnTarget call1, call2; public Then(CallOnTarget call1, CallOnTarget call2) { this.call2 = call2; this.call1 = call1; target = call1.target; call1.target = null; } public Object evalOnTarget(VarContext ctx, Object object) { call1.evalOnTarget(ctx, object); return call2.evalOnTarget(ctx, object); } } static public class Synchronized extends EvaluableBase implements IFieldsToList { public Evaluable target; public Evaluable body; public Synchronized() { } public Synchronized(Evaluable target, Evaluable body) { this.body = body; this.target = target; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + target + ", " + body + ")"; } public Object[] _fieldsToList() { return new Object[] { target, body }; } public Evaluable optimize() { if (!returnValueNeeded) body = body.optimizeForReturnValueNotNeeded(); return this; } public Object get(VarContext ctx) { synchronized (target.get(ctx)) { return body.get(ctx); } } } } static public class AbstractFastRegions_ShuffledScan implements Steppable { public AbstractFastRegions regionMaker; public WeightlessShuffledIterator iterator; public AbstractFastRegions_ShuffledScan(AbstractFastRegions regionMaker) { this.regionMaker = regionMaker; regionMaker.init(); iterator = new WeightlessShuffledIterator(regionMaker.size); } public boolean step() { return findNextRegion() > 0; } public int findNextRegion() { var regionMatrix = regionMaker.regionMatrix; int pixel; while ((pixel = iterator.nextIndex()) >= 0) if (regionMatrix[pixel] == 0) { regionMaker.runner = pixel; return regionMaker.makeRegion(); } return 0; } public IImageRegion nextRegion() { int iRegion = findNextRegion(); return iRegion > 0 ? regionMaker.getRegion(iRegion) : null; } } static public class ServeHttp_CookieHandler { public int days = 365; public String cookieName = "cookie"; public boolean verbose = false; public String cookieValue; public String metaParams; public boolean shareCookiesBetweenApexDomains = false; public String handle() { NanoHTTPD.IHTTPSession session = NanoHTTPD.currentSession.get(); if (session == null) return null; NanoHTTPD.CookieHandler cookies = session.getCookies(); if (empty(cookieValue)) cookieValue = cookies.read(cookieName); String existingValue = cookieValue; var headers = session.getHeaders(); if (empty(cookieValue) && empty((String) mapGet(headers, "x-no-cookies"))) { cookieValue = createNewCookie(); if (verbose) print("New cookie."); } if (verbose) print("IP " + session.remoteIp() + ", cookie: " + cookieValue); if (!eq_nullIfEmpty(existingValue, cookieValue)) { var cookie = cookies.set(cookieName, cookieValue + prependIfNempty("; ", metaParams), days); String apexDomain = apexDomain(dropPortFromHost(session.getHeaders().get("host"))); if (shareCookiesBetweenApexDomains && nempty(apexDomain)) cookie.domain = apexDomain; } return cookieValue; } transient public IF0 createNewCookie; public String createNewCookie() { return createNewCookie != null ? createNewCookie.get() : createNewCookie_base(); } final public String createNewCookie_fallback(IF0 _f) { return _f != null ? _f.get() : createNewCookie_base(); } public String createNewCookie_base() { return randomID(20); } } static public class LazyVar implements IF0 { public LazyVar() { } public LazyVar(A v) { this.v = v; if (v == null) calculating = new Var(); } public LazyVar(IF0 f) { this.f = f; } public IF0 f; public Var> calculating; public A v; public A get() { boolean meCalc = false; if (v != null) return v; synchronized (this) { meCalc = calculating == null; if (meCalc) calculating = new Var(); } if (meCalc) { OKOrError b = okOrError(() -> f.get()); calculating.set(b); synchronized (this) { return v = b.get(); } } else { waitUntilNotNull(calculating); return v; } } public synchronized boolean isEvaluated() { return f == null; } public synchronized boolean has() { return get() != null; } public String toString() { return isEvaluated() ? str(get()) : "LazyVar"; } } static public class G22MeshGroup implements MakesBufferedImage, IFieldsToList { public List meshes; public G22MeshGroup() { } public G22MeshGroup(List meshes) { this.meshes = meshes; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + meshes + ")"; } public Object[] _fieldsToList() { return new Object[] { meshes }; } public Rect bounds() { return mergeRects(map(meshes, m -> m.bounds())); } public int getWidth() { return bounds().w; } public int getHeight() { return bounds().h; } public BufferedImage getBufferedImage() { var r = bounds(); if (r == null) return null; return new G22VisualizeMeshes(widthAndHeight(r.x2(), r.y2()), meshes).get(); } } public interface G22MasterStuff { public RunnablesReferenceQueue runnablesReferenceQueue(); public EphemeralObjectIDs ephemeralObjectIDs(); public File databasesMotherDir(); public boolean projectExists(String name); default public IG22LoadedDB openDatabase(File dir) { return openDatabase(dir, false); } public IG22LoadedDB openDatabase(File dir, boolean hidden); default public IG22LoadedDB openDB(String dbName) { return openDB(dbName, false); } public IG22LoadedDB openDB(String dbName, boolean hidden); public void closeDatabase(File dir); public void switchToDatabase(File dir); public Collection openConceptDirs(); public IG22LoadedDB getLoadedDB(Concepts concepts); public IG22LoadedDB getLoadedDBForConceptDir(File dir); default public Collection openProjects() { return getLoadedDBs(); } public Collection getLoadedDBs(); public G22MasterStuff onLoadedDBsChange(Runnable r); public G22MasterStuff removeLoadedDBsChangeListener(Runnable r); public IG22LoadedDB reopenDB(IG22LoadedDB db); public IF1 makeClassFinder(); public IF0WithChangeListeners lvGazelleUserCount(); public ILASClassLoader lasClassLoader(); public boolean devMode(); public void newClassesDefined(); public G22MasterStuff onNewClassesDefined(Runnable r); public G22MasterStuff removeNewClassesDefinedListener(Runnable r); default public boolean isConceptDirLoaded(File dir) { return getLoadedDBForConceptDir(dir) != null; } public void restart(); } static public class G22HolePaths implements IFieldsToList { public IImageRegion region; public G22HolePaths() { } public G22HolePaths(IImageRegion region) { this.region = region; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + region + ")"; } public Object[] _fieldsToList() { return new Object[] { region }; } public List get() { List outlines = region.createdWithDiagonals() ? g22_allBorderTraces_withDiagonals(region) : g22_allBorderTraces(region); return map(dropFirst(outlines), points -> new OnePathWithOrigin(points, false)); } } static public class _SimulatedArrayStub { public int len; } static public class Gazelle22_GradientImage { public BWImage posterized; public double gradientThreshold = .25; public BWImage out; public PosterizeBWImage op; public BWImage unposterized; public int w, h, brightnessLevels, singleStep; public Gazelle22_GradientImage(BWImage posterized) { this.posterized = posterized; } public boolean init() { op = (PosterizeBWImage) getMetaSrc(posterized); if (op == null) return false; unposterized = op.img; brightnessLevels = op.brightnessLevels; assertSameSize(unposterized, posterized); w = posterized.getWidth(); h = posterized.getHeight(); singleStep = iceil(doubleRatio(255, brightnessLevels - 1)); return true; } public BWImage get() { init(); out = new BWImage(w * 2 + 1, h * 2 + 1); for (int y = 0; y < h; y++) for (int x = 0; x < w; x++) { if (x < w - 1) checkPair(x, y, x + 1, y); if (y < h - 1) checkPair(x, y, x, y + 1); } return out; } public boolean isGradientPoint(int x, int y) { if (op == null) return false; IntMinMax posterizedMinMax = new IntMinMax(); IntMinMax unposterizedMinMax = new IntMinMax(); for (int y2 = max(0, y - 1); y2 <= min(h - 1, y + 1); y2++) for (int x2 = max(0, x - 1); x2 <= min(w - 1, x + 1); x2++) { posterizedMinMax.add(posterized.getInt(x2, y2)); unposterizedMinMax.add(unposterized.getInt(x2, y2)); } int posterizedContrast = posterizedMinMax.rangeLength(); if (posterizedContrast > singleStep) return false; if (posterizedContrast == 0) return true; int unposterizedContrast = unposterizedMinMax.rangeLength(); return unposterizedContrast <= posterizedContrast * gradientThreshold; } public void checkPair(int x, int y, int x2, int y2) { int posterizedContrast = absDiff(posterized.getInt(x, y), posterized.getInt(x2, y2)); if (posterizedContrast == 0) return; if (posterizedContrast > singleStep) return; int realContrast = absDiff(unposterized.getInt(x, y), unposterized.getInt(x2, y2)); double ratio = doubleRatio(realContrast, singleStep); float result = (float) ((.5 - ratio) * 2); { out.setPixel(x * 2 + 1 - (y2 - y), y * 2 + 1, result); out.setPixel(x * 2 + 1, y * 2 + 1 - (x2 - x), result); } } } static public class Welford implements IFieldsToList { static final public String _fieldOrder = "count mean m2"; public long count; public double mean; public double m2; public Welford() { } public Welford(long count, double mean, double m2) { this.m2 = m2; this.mean = mean; this.count = count; } public boolean equals(Object o) { if (!(o instanceof Welford)) return false; Welford __1 = (Welford) o; return count == __1.count && mean == __1.mean && m2 == __1.m2; } public int hashCode() { int h = -1397124871; h = boostHashCombine(h, _hashCode(count)); h = boostHashCombine(h, _hashCode(mean)); h = boostHashCombine(h, _hashCode(m2)); return h; } public Object[] _fieldsToList() { return new Object[] { count, mean, m2 }; } public void add(double newValue) { count++; double delta = newValue - mean; mean += delta / count; double delta2 = newValue - mean; m2 += delta * delta2; } public void remove(double valueToRemove) { guarantee(count > 0); double newValue = valueToRemove; double delta2 = newValue - mean; mean = (mean - newValue / count) / (1 - 1.0 / count); double delta = newValue - mean; m2 -= delta * delta2; --count; } public boolean isEmpty() { return count == 0; } final public double avg() { return average(); } final public double mean() { return average(); } public double average() { return count == 0 ? Double.NaN : mean; } public double variance() { return count == 0 ? Double.NaN : m2 / count; } public double sampleVariance() { return count < 2 ? Double.NaN : m2 / (count - 1); } public double standardDeviation() { return sqrt(variance()); } public String toString() { String s = nValues(count); if (!isEmpty()) s += ", avg: " + avg() + ", std dev: " + standardDeviation(); return s; } public AverageAndStandardDeviation get() { return new AverageAndStandardDeviation(avg(), standardDeviation()); } } static public class G22AnalyzersPanel extends G22CRUDAndDetailPanel { public SimpleCRUD_v2 makeCRUD() { var crud = new SimpleCRUD_v2<>(g22utils.concepts(), G22Analyzer.class); crud.entityName = () -> "Analyzer"; g22utils.setupScriptCRUD(crud); return crud; } public void crudVisualized() { super.crudVisualized(); crud.addButton(jPopDownButton_noText("Copy to other project...", runnableThread(new Runnable() { public void run() { try { copyToOtherProject(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "copyToOtherProject();"; } }))); } public void copyToOtherProject() { var analyzer = crud.selected(); var srcProject = g22utils.getLoadedDB(); var projects = g22utils.masterStuff().getLoadedDBs(); var cbProject = jTypedComboBox(listMinus(projects, srcProject)); packFrame(showFormTitled3("Copy analyzer to other project", "Copy analyzer", str(analyzer), "From project", str(srcProject), "To project", cbProject, "", jThreadedButton("Copy", () -> copyToOtherProject(analyzer, getSelectedItem_typed(cbProject)))).visualize()); } public void copyToOtherProject(G22Analyzer src, IG22LoadedDB project) { G22Analyzer clone = new G22Analyzer(); clone.description(src.description).text(src.text); clone.clearedForAutoRun(src.clearedForAutoRun).editingText(src.editingText).importNote("Copied from project " + quote(g22utils.masterStuff().getLoadedDB(src.concepts())) + " on " + localDateWithSeconds()); registerConcept(project.concepts(), clone); infoBox("Made clone: " + clone); } public JComponent makeDetailView(G22Analyzer script) { var scriptIDE = new G22AnalyzerIDE(g22utils); scriptIDE.setScript(script); return scriptIDE.visualize(); } public SimpleCRUD_v2 scriptCRUD() { return crud(); } public G22AnalyzersPanel g22utils(G22Utils g22utils) { super.g22utils(g22utils); return this; } } static public class ConvexHull2D { final public ConvexHull2D setPoints(IDoublePt[] points) { return points(points); } public ConvexHull2D points(IDoublePt[] points) { this.points = points; return this; } final public IDoublePt[] getPoints() { return points(); } public IDoublePt[] points() { return points; } public IDoublePt[] points; final public List getHull() { return hull(); } public List hull() { return hull; } public List hull; public ConvexHull2D() { } public ConvexHull2D(Collection points) { this.points = toTypedArray(IDoublePt.class, points); } public int orientation(IDoublePt p, IDoublePt q, IDoublePt r) { double val = (q.y_double() - p.y_double()) * (r.x_double() - q.x_double()) - (q.x_double() - p.x_double()) * (r.y_double() - q.y_double()); if (val == 0) return 0; return val > 0 ? 1 : 2; } public void run() { try { if (hull != null) return; int n = l(points); hull = new ArrayList(); if (n < 3) { addAll(hull, points); return; } int l = 0; for (int i = 1; i < n; i++) if (points[i].x_double() < points[l].x_double()) l = i; int p = l, q; do { hull.add(points[p]); q = (p + 1) % n; for (int i = 0; i < n; i++) { if (orientation(points[p], points[i], points[q]) == 2) q = i; } p = q; } while (p != l); } catch (Exception __e) { throw rethrow(__e); } } public List get() { run(); return hull; } } static public class G22StrategyRun { final public G22StrategyRun setStrategy(G22TradingStrategy strategy) { return strategy(strategy); } public G22StrategyRun strategy(G22TradingStrategy strategy) { this.strategy = strategy; return this; } final public G22TradingStrategy getStrategy() { return strategy(); } public G22TradingStrategy strategy() { return strategy; } public G22TradingStrategy strategy; final public G22StrategyRun setTicker(TickerSequence ticker) { return ticker(ticker); } public G22StrategyRun ticker(TickerSequence ticker) { this.ticker = ticker; return this; } final public TickerSequence getTicker() { return ticker(); } public TickerSequence ticker() { return ticker; } public TickerSequence ticker; final public G22StrategyRun setProfitTicker(TickerSequence profitTicker) { return profitTicker(profitTicker); } public G22StrategyRun profitTicker(TickerSequence profitTicker) { this.profitTicker = profitTicker; return this; } final public TickerSequence getProfitTicker() { return profitTicker(); } public TickerSequence profitTicker() { return profitTicker; } public TickerSequence profitTicker = new TickerSequence(); final public G22StrategyRun setFinalProfit(double finalProfit) { return finalProfit(finalProfit); } public G22StrategyRun finalProfit(double finalProfit) { this.finalProfit = finalProfit; return this; } final public double getFinalProfit() { return finalProfit(); } public double finalProfit() { return finalProfit; } public double finalProfit; final public G22StrategyRun setIteratorMonitor(IIteratorMonitor iteratorMonitor) { return iteratorMonitor(iteratorMonitor); } public G22StrategyRun iteratorMonitor(IIteratorMonitor iteratorMonitor) { this.iteratorMonitor = iteratorMonitor; return this; } final public IIteratorMonitor getIteratorMonitor() { return iteratorMonitor(); } public IIteratorMonitor iteratorMonitor() { return iteratorMonitor; } transient public IIteratorMonitor iteratorMonitor = dummyIteratorMonitor(); public double totalProfit() { return finalProfit; } public void run() { try { strategy(strategy.emptyClone()); strategy.logToPrint(false); strategy.actualTicker(ticker); strategy.primed(true); strategy.active(true); var it = iteratorMonitor.monitorIterator("Backtest", ticker.pricePoints()); try { for (var pricePoint : it) { if (!strategy.active()) break; strategy.feed(pricePoint); double profit = strategy.coinProfit(); profitTicker.addIfPriceChanged(profit, pricePoint.timestamp); } strategy.closeMyself(); finalProfit(strategy.coinProfit()); } finally { _close(it); } } catch (Exception __e) { throw rethrow(__e); } } } static public class MouseInComponentMonitor extends BoolVarWithNotify implements MouseListener, MouseMotionListener { public JComponent component; final public MouseInComponentMonitor setVerbose(boolean verbose) { return verbose(verbose); } public MouseInComponentMonitor verbose(boolean verbose) { this.verbose = verbose; return this; } final public boolean getVerbose() { return verbose(); } public boolean verbose() { return verbose; } public boolean verbose = false; public MouseInComponentMonitor() { } public MouseInComponentMonitor(JComponent component) { init(component); } public void init(JComponent component) { if (this.component != null) throw fail("Already initialized"); this.component = component; addMouseListener(component, this); addMouseMotionListener(component, this); } public void print(String s) { if (verbose) loadableUtils.utils.print(s); } public void mouseClicked(MouseEvent e) { } public void mousePressed(MouseEvent e) { } public void mouseReleased(MouseEvent e) { } public void mouseEntered(MouseEvent e) { print("mouseEntered"); set(true); } public void mouseExited(MouseEvent e) { print("mouseExited"); set(false); } public void mouseMoved(MouseEvent e) { print("mouseMoved"); set(true); } public void mouseDragged(MouseEvent e) { } } static public class G22Mesh extends Meta implements MakesBufferedImage { public G22Mesh() { } public LinkedHashMap anchorMap = new LinkedHashMap(); final public LinkedHashSet getCurves() { return curves(); } public LinkedHashSet curves() { return curves; } public LinkedHashSet curves = new LinkedHashSet(); public String cachedSignature; static public class Curve { public Curve() { } final public Anchor getStart() { return start(); } public Anchor start() { return start; } public Anchor start; final public Anchor getEnd() { return end(); } public Anchor end() { return end; } public Anchor end; final public OnePathWithOrigin getPath() { return path(); } public OnePathWithOrigin path() { return path; } public OnePathWithOrigin path; public Curve(Anchor start, Anchor end, List points) { this(start, end, new OnePathWithOrigin(points, false)); } public Curve(Anchor start, Anchor end, OnePathWithOrigin path) { this.path = path; this.end = end; this.start = start; start.outgoingCurves.add(this); end.incomingCurves.add(this); } public String toString() { return "Curve of length " + n2(path.nSteps()) + " connecting " + (start == null ? null : start.shortToString() + " and " + (end == null ? null : end.shortToString())); } public int length() { return path.nSteps(); } public List anchors() { return ll(start, end); } public boolean connectedTo(Anchor a) { return start == a || end == a; } public Anchor anchor(boolean endAnchor) { return endAnchor ? end : start; } public Anchor anchorOpposite(Anchor a) { return a == start ? end : a == end ? start : null; } } static public class Anchor { public Anchor() { } public int index; final public Pt getPt() { return pt(); } public Pt pt() { return pt; } public Pt pt; public List outgoingCurves = new ArrayList(); public List incomingCurves = new ArrayList(); public Anchor(int index, Pt pt) { this.pt = pt; this.index = index; } public int arity() { return l(outgoingCurves) + l(incomingCurves); } public String shortToString() { return "Anchor " + index + " at " + pt; } public String toString() { List connections = sorted(map(connectedToAnchors(), a -> a.index)); return shortToString() + ", arity " + arity() + stringIf(isRingAnchor(), " [arbitrarily chosen ring anchor]") + (empty(connections) ? "" : ", connected to " + joinWithComma(connections)); } public Set curves() { return joinSets(outgoingCurves, incomingCurves); } public Set connectedToAnchors() { return joinSets(map(outgoingCurves, c -> c.end), map(incomingCurves, c -> c.start)); } public boolean isRingAnchor() { return l(outgoingCurves) == 1 && l(incomingCurves) == 1 && first(outgoingCurves) == first(incomingCurves); } } public Collection anchorPts() { return keys(anchorMap); } public Collection anchors() { return values(anchorMap); } public int nAnchors() { return l(anchorMap); } public List anchorList() { return valuesList(anchorMap); } public Anchor getAnchor(Pt p) { return anchorMap.get(p); } public Anchor getAnchor(int idx) { return anchorList().get(idx); } public void checkArities() { MultiMap outgoing = new MultiMap(); MultiMap incoming = new MultiMap(); for (Curve curve : curves) { outgoing.add(curve.start, curve); if (!anchorMap.containsKey(curve.start.pt)) throw fail("Start of curve not found: " + curve); incoming.add(curve.end, curve); if (!anchorMap.containsKey(curve.end.pt)) throw fail("End of curve not found: " + curve); } for (Anchor anchor : anchors()) { assertSetEquals(anchor + " outgoing", outgoing.get(anchor), anchor.outgoingCurves); assertSetEquals(anchor + " incoming", incoming.get(anchor), anchor.incomingCurves); } } final public Anchor addAnchor(Pt p) { return newAnchor(p); } public Anchor newAnchor(Pt p) { Anchor anchor = new Anchor(l(anchorMap) + 1, p); anchorMap.put(p, anchor); _invalidateSignature(); return anchor; } public void removeAnchor(Anchor anchor) { anchorMap.remove(anchor.pt); } public Curve addCurve(Curve curve) { curves.add(curve); _invalidateSignature(); return curve; } public void removeCurve(Curve curve) { curves.remove(curve); curve.start.outgoingCurves.remove(curve); curve.end.incomingCurves.remove(curve); _invalidateSignature(); } public int[] sortedArities() { int[] array = mapToIntArray(anchors(), a -> a.arity()); return sortIntArrayInPlaceDesc(array); } final public String aritySignature() { return sortedAritiesToString(); } final public String signature() { return sortedAritiesToString(); } public String sortedAritiesToString() { { var __1 = cachedSignature; if (__1 != null) return __1; } int[] arities = sortedArities(); boolean compact = all(arities, arity -> arity < 10); return cachedSignature = compact ? join(asList(arities)) : roundBracket(joinWithComma(asList(arities))); } public String toString() { return "Mesh type " + sortedAritiesToString(); } public void renumberAnchors() { int i = 0; for (var anchor : anchors()) anchor.index = ++i; } public Rect bounds() { BoundsFinder bf = new BoundsFinder(); for (var p : keys(anchorMap)) bf.add(p); for (var curve : curves) for (var p : curve.path.pointIterator()) bf.add(p); return bf.get(); } public int getWidth() { return bounds().w; } public int getHeight() { return bounds().h; } public BufferedImage getBufferedImage() { var r = bounds(); return new G22VisualizeMeshes(widthAndHeight(r.x2() + 2, r.y2() + 2), ll(this)).get(); } public void _invalidateSignature() { cachedSignature = null; } public boolean containsAnchor(Anchor a) { return a != null && anchorMap.get(a.pt) == a; } public boolean containsCurve(Curve c) { return curves.contains(c); } public List curveList() { return asList(curves); } public void moveAnchor(Anchor a, Pt p) { if (eq(a.pt(), p)) return; assertNotNull(p); anchorMap.remove(a.pt); a.pt = p; anchorMap.put(p, a); } public void mergeAnchorInto(Anchor a1, Anchor a2) { mergeAnchors(a1, a2, a2.pt); } public void mergeAnchors(Anchor a1, Anchor a2, Pt newPosition) { if (scaffoldingEnabled()) printVars("mergeAnchors", "mesh", this, "a1", a1, "a2", a2, "newPosition", newPosition); assertNotSame(a1, a2); assertNotNull(a1); assertNotNull(a2); for (Curve curve : a1.outgoingCurves) { curve.path.insertStep(0, ptMinus(a1.pt, a2.pt)); curve.path.origin(a2.pt); curve.start = a2; a2.outgoingCurves.add(curve); } for (Curve curve : a1.incomingCurves) { curve.path.addStep(ptMinus(a2.pt, a1.pt)); curve.end = a2; a2.incomingCurves.add(curve); } moveAnchor(a2, newPosition); removeAnchor(a1); } } static public class G22_RegionToSSI implements IFieldsToList { public IImageRegion region; public G22_RegionToSSI() { } public G22_RegionToSSI(IImageRegion region) { this.region = region; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + region + ")"; } public Object[] _fieldsToList() { return new Object[] { region }; } public SSI get() { if (region == null) return null; Rect r = region.bounds(); int x1 = r.x1(), y1 = r.y1(), y2 = r.y2(), h = y2 - y1, w = r.w; SSI ssi = new SSI(y1, y2); ssi.color(region.color()); short[] data = new short[h * 2]; for (int y = y1; y < y2; y++) { var _y_1 = y; List streaks = genericStreaks(w, x -> region.contains(x1 + x, _y_1)); IntRange range = selectHorizontalPart(streaks); int i = (_y_1 - y1) * 2; data[i] = toShort_enforce(x1 + range.start); data[i + 1] = toShort_enforce(x1 + range.end); } ssi.data(data); return ssi; } transient public IF1, IntRange> selectHorizontalPart; public IntRange selectHorizontalPart(List parts) { return selectHorizontalPart != null ? selectHorizontalPart.get(parts) : selectHorizontalPart_base(parts); } final public IntRange selectHorizontalPart_fallback(IF1, IntRange> _f, List parts) { return _f != null ? _f.get(parts) : selectHorizontalPart_base(parts); } public IntRange selectHorizontalPart_base(List parts) { return first(parts); } } static public class JS implements IF0, Htmlable { public JS() { } public String code; public Set requiredLibraries; public Set requiredLibraries() { return requiredLibraries; } public JS(String code, Object... dollarVars) { this.code = jsDollarVars(code, dollarVars); } public String get() { return code; } public String toString() { return unnull(code); } public void requireJQuery() { require("jquery"); } public void require(Object library) { requiredLibraries = addToSet_create(requiredLibraries, library); } public String html() { return hjs(code); } } static public class MPM2 implements IFieldsToList { public float[] ticker; public long[] timestamps; public MPM2() { } public MPM2(float[] ticker, long[] timestamps) { this.timestamps = timestamps; this.ticker = ticker; } public Object[] _fieldsToList() { return new Object[] { ticker, timestamps }; } static public class Market implements IFieldsToList { public double adversity; public Market() { } public Market(double adversity) { this.adversity = adversity; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + adversity + ")"; } public boolean equals(Object o) { if (!(o instanceof Market)) return false; Market __2 = (Market) o; return adversity == __2.adversity; } public int hashCode() { int h = -1997438884; h = boostHashCombine(h, _hashCode(adversity)); return h; } public Object[] _fieldsToList() { return new Object[] { adversity }; } } static public class Position implements IFieldsToList { static final public String _fieldOrder = "openingTime direction"; public double openingTime; public double direction; public Position() { } public Position(double openingTime, double direction) { this.direction = direction; this.openingTime = openingTime; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + openingTime + ", " + direction + ")"; } public boolean equals(Object o) { if (!(o instanceof Position)) return false; Position __3 = (Position) o; return openingTime == __3.openingTime && direction == __3.direction; } public int hashCode() { int h = 812449097; h = boostHashCombine(h, _hashCode(openingTime)); h = boostHashCombine(h, _hashCode(direction)); return h; } public Object[] _fieldsToList() { return new Object[] { openingTime, direction }; } } public class ClosedPosition implements IFieldsToList { public Position p; public double closingTime; public ClosedPosition() { } public ClosedPosition(Position p, double closingTime) { this.closingTime = closingTime; this.p = p; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + p + ", " + closingTime + ")"; } public boolean equals(Object o) { if (!(o instanceof ClosedPosition)) return false; ClosedPosition __0 = (ClosedPosition) o; return eq(p, __0.p) && eq(closingTime, __0.closingTime); } public int hashCode() { int h = 1899462357; h = boostHashCombine(h, _hashCode(p)); h = boostHashCombine(h, _hashCode(closingTime)); return h; } public Object[] _fieldsToList() { return new Object[] { p, closingTime }; } final public ClosedPosition setTicker(Ticker ticker) { return ticker(ticker); } public ClosedPosition ticker(Ticker ticker) { this.ticker = ticker; return this; } final public Ticker getTicker() { return ticker(); } public Ticker ticker() { return ticker; } public Ticker ticker; final public ClosedPosition setProfit(double profit) { return profit(profit); } public ClosedPosition profit(double profit) { this.profit = profit; return this; } final public double getProfit() { return profit(); } public double profit() { return profit; } public double profit; public MPM2 mpm() { return MPM2.this; } public double openingPrice() { return MPM2.this.ticker(p.openingTime); } public double closingPrice() { return MPM2.this.ticker(closingTime); } } static public class Juicer implements IFieldsToList { public double lossTolerance; public double pullback; public Juicer() { } public Juicer(double lossTolerance, double pullback) { this.pullback = pullback; this.lossTolerance = lossTolerance; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + lossTolerance + ", " + pullback + ")"; } public boolean equals(Object o) { if (!(o instanceof Juicer)) return false; Juicer __4 = (Juicer) o; return lossTolerance == __4.lossTolerance && pullback == __4.pullback; } public int hashCode() { int h = -2065131726; h = boostHashCombine(h, _hashCode(lossTolerance)); h = boostHashCombine(h, _hashCode(pullback)); return h; } public Object[] _fieldsToList() { return new Object[] { lossTolerance, pullback }; } } abstract static public class Eye { abstract public double adviseDirection(Ticker ticker); } static public class Ticker implements IFieldsToList { public float[] data; public long[] timestamps; public int length; public long currentTime; public Ticker() { } public Ticker(float[] data, long[] timestamps, int length, long currentTime) { this.currentTime = currentTime; this.length = length; this.timestamps = timestamps; this.data = data; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + data + ", " + timestamps + ", " + length + ", " + currentTime + ")"; } public Object[] _fieldsToList() { return new Object[] { data, timestamps, length, currentTime }; } public double currentPrice() { return data[length - 1]; } public Double lookback(double time) { int index = binarySearch_insertionPoint(wrapLongArrayAsList(timestamps), lceil(currentTime - time)); return index >= 0 ? (double) data[index] : null; } } static public class LiveTicker extends Ticker { public void add(float value, long timestamp) { data = addToArrayWithDoublingStrategy(data, length, value); timestamps = addToArrayWithDoublingStrategy(timestamps, length, timestamp); length++; } } public Ticker ticker() { return new Ticker(ticker, timestamps, l(timestamps), last(timestamps)); } static public class SimpleEye extends Eye implements IFieldsToList { static final public String _fieldOrder = "time minMove"; public double time; public double minMove; public SimpleEye() { } public SimpleEye(double time, double minMove) { this.minMove = minMove; this.time = time; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + time + ", " + minMove + ")"; } public boolean equals(Object o) { if (!(o instanceof SimpleEye)) return false; SimpleEye __5 = (SimpleEye) o; return time == __5.time && minMove == __5.minMove; } public int hashCode() { int h = -120435969; h = boostHashCombine(h, _hashCode(time)); h = boostHashCombine(h, _hashCode(minMove)); return h; } public Object[] _fieldsToList() { return new Object[] { time, minMove }; } public double adviseDirection(Ticker ticker) { Double currentPrice = ticker.currentPrice(); if (currentPrice == null) return 0; Double before = ticker.lookback(time); if (before == null) return 0; double move = currentPrice / before * 100 - 100; if (abs(move) >= minMove) return (double) sign(move); return 0; } } public double ticker(double time) { return ticker[iceil(time)]; } public double openingPrice(Position p) { return ticker(p.openingTime); } public double profit(Position p, double time, Market m) { return (ticker(time) / openingPrice(p) * 100 - 100) * p.direction - m.adversity; } public Double closingTime(Position p, Juicer j, Market m) { int time = iceil(p.openingTime); double openingPrice = ticker(time); double crest = -infinity(); while (time < ticker.length - 1) { double profit = profit(p, time, m); crest = max(crest, profit); if (profit < (profit < 0 ? -j.lossTolerance : crest - j.pullback)) return (double) time; ++time; } return null; } public Double profit(Position p, Juicer j, Market m) { Double closingTime = closingTime(p, j, m); return closingTime == null ? null : profit(p, closingTime, m); } public Double profitability(double time, Juicer j, Market m) { return maxAllowingNull(profit(new Position(time, -1), j, m), profit(new Position(time, 1), j, m)); } public class Backtest extends Convergent implements IFieldsToList { public Eye eye; public Juicer j; public Market m; public Backtest() { } public Backtest(Eye eye, Juicer j, Market m) { this.m = m; this.j = j; this.eye = eye; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + eye + ", " + j + ", " + m + ")"; } public Object[] _fieldsToList() { return new Object[] { eye, j, m }; } public Iterator openingTimes = new WeightlessShuffledIterator(intRangeList(ticker.length)); public Average profitPerPosition = new Average(); public Average positionsOpenedPercentage = new Average(); public Average positionsClosedPercentage = new Average(); public List closedPositions = new ArrayList(); public Backtest(Juicer j, Market m) { this.m = m; this.j = j; } public void step() { if (!openingTimes.hasNext()) { done = true; return; } int openingTime = openingTimes.next(); Double profit = null; ClosedPosition closedPosition = null; if (eye == null) profit = profitability(openingTime, j, m); else { double direction = eye.adviseDirection(new Ticker(ticker, timestamps, openingTime, timestamps[openingTime])); positionsOpenedPercentage.addSample(direction != 0 ? 100 : 0); if (direction != 0) { Position position = new Position(openingTime, direction); Double closingTime = closingTime(position, j, m); if (closingTime != null) { profit = profit(position, closingTime, m); closedPosition = new ClosedPosition(position, closingTime).ticker(ticker()).profit(profit); closedPositions.add(closedPosition); } } } positionsClosedPercentage.addSample(profit != null ? 100 : 0); if (profit != null) { profitPerPosition.addSample(profit); } else profitPerPosition.addSample(0); value = profitPerPosition.get(); } } } static public class MPM3 { public MPM3() { } final public MPM3 setMarketAdversity(double marketAdversity) { return marketAdversity(marketAdversity); } public MPM3 marketAdversity(double marketAdversity) { this.marketAdversity = marketAdversity; return this; } final public double getMarketAdversity() { return marketAdversity(); } public double marketAdversity() { return marketAdversity; } public double marketAdversity = 0.12 + 0.08; final public double getMaxPositionDuration() { return maxPositionDuration(); } public double maxPositionDuration() { return maxPositionDuration; } public double maxPositionDuration = minutesToMS(60); public double minimalMaxDuration() { return minutesToMS(1); } public MPM3 maxPositionDuration(double whatUserWants) { maxPositionDuration = max(whatUserWants, minimalMaxDuration()); return this; } public class Position implements IFieldsToList { transient public TickerSequence ticker; public double openingTime; public double direction; public Position() { } public Position(TickerSequence ticker, double openingTime, double direction) { this.direction = direction; this.openingTime = openingTime; this.ticker = ticker; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + ticker + ", " + openingTime + ", " + direction + ")"; } public boolean equals(Object o) { if (!(o instanceof Position)) return false; Position __0 = (Position) o; return eq(ticker, __0.ticker) && eq(openingTime, __0.openingTime) && eq(direction, __0.direction); } public int hashCode() { int h = 812449097; h = boostHashCombine(h, _hashCode(ticker)); h = boostHashCombine(h, _hashCode(openingTime)); h = boostHashCombine(h, _hashCode(direction)); return h; } public Object[] _fieldsToList() { return new Object[] { ticker, openingTime, direction }; } final public Position setIrlInfo(Object irlInfo) { return irlInfo(irlInfo); } public Position irlInfo(Object irlInfo) { this.irlInfo = irlInfo; return this; } final public Object getIrlInfo() { return irlInfo(); } public Object irlInfo() { return irlInfo; } public Object irlInfo; final public Position setEye(Eye eye) { return eye(eye); } public Position eye(Eye eye) { this.eye = eye; return this; } final public Eye getEye() { return eye(); } public Eye eye() { return eye; } public Eye eye; public double openingPrice() { return ticker.priceAtTimestamp(openingTime); } public double profitAtTime(double time) { return (ticker.priceAtTimestamp(time) / openingPrice() * 100 - 100) * direction - marketAdversity; } public double openingTime() { return openingTime; } public String directionString() { return direction > 0 ? "long" : direction < 0 ? "short" : ""; } public void restoreTicker(TickerSequence ticker) { this.ticker = ticker; } public TickerPoint openingTickerPoint() { return new TickerPoint(ticker, lround(openingTime)); } } public class LivePosition implements IFieldsToList { public Position p; public LivePosition() { } public LivePosition(Position p) { this.p = p; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + p + ")"; } public boolean equals(Object o) { if (!(o instanceof LivePosition)) return false; LivePosition __1 = (LivePosition) o; return eq(p, __1.p); } public int hashCode() { int h = -1546561963; h = boostHashCombine(h, _hashCode(p)); return h; } public Object[] _fieldsToList() { return new Object[] { p }; } final public LivePosition setJuicer(Juicer juicer) { return juicer(juicer); } public LivePosition juicer(Juicer juicer) { this.juicer = juicer; return this; } final public Juicer getJuicer() { return juicer(); } public Juicer juicer() { return juicer; } public Juicer juicer; final public LivePosition setCrest(double crest) { return crest(crest); } public LivePosition crest(double crest) { this.crest = crest; return this; } final public double getCrest() { return crest(); } public double crest() { return crest; } public double crest = -infinity(); final public LivePosition setTime(double time) { return time(time); } public LivePosition time(double time) { this.time = time; return this; } final public double getTime() { return time(); } public double time() { return time; } public double time; final public LivePosition setProfit(double profit) { return profit(profit); } public LivePosition profit(double profit) { this.profit = profit; return this; } final public double getProfit() { return profit(); } public double profit() { return profit; } public double profit; public TickerSequence ticker() { return p.ticker; } public void restoreTicker(TickerSequence ticker) { p.restoreTicker(ticker); } public double direction() { return p.direction; } public String directionString() { return p.directionString(); } public double openingTime() { return p.openingTime; } public double openingPrice() { return p.openingPrice(); } public Eye eye() { return p.eye(); } public boolean update(double time) { if (time <= this.time) return false; this.time = time; profit = p.profitAtTime(time); crest = max(crest, profit); return true; } transient public Double maxClosingTime_cache; public double maxClosingTime() { if (maxClosingTime_cache == null) maxClosingTime_cache = maxClosingTime_load(); return maxClosingTime_cache; } public double maxClosingTime_load() { return p.ticker.live() ? infinity() : min(p.openingTime + maxPositionDuration, p.ticker.endTime()); } public boolean shouldClose() { return time >= maxClosingTime() || profit < (profit < 0 ? -juicer.lossTolerance : crest - juicer.pullback); } public double closeSignal() { CloseSignal strongestSignal = closeSignalWithDescription(); return strongestSignal == null ? 0 : strongestSignal.trigger; } public CloseSignal closeSignalWithDescription() { return highestBy(closeSignals(), signal -> signal.trigger); } public class CloseSignal implements IFieldsToList { public String reason; public double trigger; public CloseSignal() { } public CloseSignal(String reason, double trigger) { this.trigger = trigger; this.reason = reason; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + reason + ", " + trigger + ")"; } public Object[] _fieldsToList() { return new Object[] { reason, trigger }; } } public List closeSignals() { List signals = new ArrayList(); if (maxClosingTime() < infinity()) signals.add(new CloseSignal("Age", transformToZeroToOne(time, p.openingTime(), maxClosingTime()))); if (profit < 0) signals.add(new CloseSignal("Loss", doubleRatio(-profit, juicer.lossTolerance))); else signals.add(new CloseSignal("Profit", transformToZeroToOne(profit, crest, crest - juicer.pullback))); return signals; } } public class ClosedPosition implements IFieldsToList { public Position p; public double closingTime; public ClosedPosition() { } public ClosedPosition(Position p, double closingTime) { this.closingTime = closingTime; this.p = p; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + p + ", " + closingTime + ")"; } public boolean equals(Object o) { if (!(o instanceof ClosedPosition)) return false; ClosedPosition __2 = (ClosedPosition) o; return eq(p, __2.p) && eq(closingTime, __2.closingTime); } public int hashCode() { int h = 1899462357; h = boostHashCombine(h, _hashCode(p)); h = boostHashCombine(h, _hashCode(closingTime)); return h; } public Object[] _fieldsToList() { return new Object[] { p, closingTime }; } public double profit = Double.NaN; public MPM3 mpm() { return MPM3.this; } public TickerSequence ticker() { return p.ticker; } public void restoreTicker(TickerSequence ticker) { p.restoreTicker(ticker); } public double direction() { return p.direction; } public String directionString() { return p.directionString(); } public double openingTime() { return p.openingTime; } public double openingPrice() { return p.openingPrice(); } public Eye eye() { return p.eye(); } public double closingTime() { return closingTime; } public double closingPrice() { return ticker().priceAtTimestamp(closingTime); } public double duration() { return closingTime() - openingTime(); } public double profit() { if (isNaN(profit)) profit = p.profitAtTime(closingTime); return profit; } } static public class LivePositions { public List positions = syncL(); } static public class ClosedPositions { public List positions = syncL(); } static public class Juicer implements IFieldsToList { public double lossTolerance; public double pullback; public Juicer() { } public Juicer(double lossTolerance, double pullback) { this.pullback = pullback; this.lossTolerance = lossTolerance; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + lossTolerance + ", " + pullback + ")"; } public boolean equals(Object o) { if (!(o instanceof Juicer)) return false; Juicer __4 = (Juicer) o; return lossTolerance == __4.lossTolerance && pullback == __4.pullback; } public int hashCode() { int h = -2065131726; h = boostHashCombine(h, _hashCode(lossTolerance)); h = boostHashCombine(h, _hashCode(pullback)); return h; } public Object[] _fieldsToList() { return new Object[] { lossTolerance, pullback }; } } abstract static public class Eye { abstract public double adviseDirection(TickerPoint tickerPoint); } static public class SimpleEye extends Eye implements IFieldsToList { public long lookbackTime; public double minMove; public SimpleEye() { } public SimpleEye(long lookbackTime, double minMove) { this.minMove = minMove; this.lookbackTime = lookbackTime; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + lookbackTime + ", " + minMove + ")"; } public boolean equals(Object o) { if (!(o instanceof SimpleEye)) return false; SimpleEye __5 = (SimpleEye) o; return lookbackTime == __5.lookbackTime && minMove == __5.minMove; } public int hashCode() { int h = -120435969; h = boostHashCombine(h, _hashCode(lookbackTime)); h = boostHashCombine(h, _hashCode(minMove)); return h; } public Object[] _fieldsToList() { return new Object[] { lookbackTime, minMove }; } final public SimpleEye setRelativeVerificationTime(double relativeVerificationTime) { return relativeVerificationTime(relativeVerificationTime); } public SimpleEye relativeVerificationTime(double relativeVerificationTime) { this.relativeVerificationTime = relativeVerificationTime; return this; } final public double getRelativeVerificationTime() { return relativeVerificationTime(); } public double relativeVerificationTime() { return relativeVerificationTime; } public double relativeVerificationTime; final public SimpleEye setVerificationThreshold(double verificationThreshold) { return verificationThreshold(verificationThreshold); } public SimpleEye verificationThreshold(double verificationThreshold) { this.verificationThreshold = verificationThreshold; return this; } final public double getVerificationThreshold() { return verificationThreshold(); } public double verificationThreshold() { return verificationThreshold; } public double verificationThreshold; public double verificationTime() { return lookbackTime * relativeVerificationTime; } public double verificationMoveThreshold() { return minMove * relativeVerificationTime * verificationThreshold; } public double verificationMove(TickerPoint tickerPoint) { return calculateMove(tickerPoint, verificationTime()); } public double relativeVerificationMove(TickerPoint tickerPoint) { return doubleRatio(verificationMove(tickerPoint) * lookbackTime, verificationTime()); } public double verificationSignal(TickerPoint tickerPoint) { return doubleRatio(verificationMove(tickerPoint), verificationMoveThreshold()); } public boolean verificationEnabled() { return relativeVerificationTime != 0; } public double adviseDirection(TickerPoint tickerPoint) { double move = calculateMove(tickerPoint); if (isNaN(move)) return 0; double relativeMove = doubleRatio(move, minMove); int sign = sign(relativeMove); double absRelativeMove = abs(relativeMove); if (verificationEnabled()) { double verification = max(0, sign * verificationSignal(tickerPoint)); absRelativeMove = min(absRelativeMove, verification); } return sign * absRelativeMove; } public double calculateMove(TickerPoint tickerPoint) { return calculateMove(tickerPoint, this.lookbackTime); } public double calculateMove(TickerPoint tickerPoint, double lookbackTime) { if (!tickerPoint.canLookback(lround(lookbackTime))) return Double.NaN; double currentPrice = tickerPoint.currentPrice(); double before = tickerPoint.lookback(lround(lookbackTime)); return currentPrice / before * 100 - 100; } } static public class TradingBot implements IFieldsToList { public Eye eye; public Juicer juicer; public TradingBot() { } public TradingBot(Eye eye, Juicer juicer) { this.juicer = juicer; this.eye = eye; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + eye + ", " + juicer + ")"; } public boolean equals(Object o) { if (!(o instanceof TradingBot)) return false; TradingBot __6 = (TradingBot) o; return eq(eye, __6.eye) && eq(juicer, __6.juicer); } public int hashCode() { int h = -297894650; h = boostHashCombine(h, _hashCode(eye)); h = boostHashCombine(h, _hashCode(juicer)); return h; } public Object[] _fieldsToList() { return new Object[] { eye, juicer }; } public TradingBot(double lookbackMinutes, double minMove, double maxLoss, double pullback) { eye = new SimpleEye(minutesToMS(lookbackMinutes), minMove); juicer = new Juicer(maxLoss, pullback); } } public class BotInAction extends MetaWithChangeListeners { final public BotInAction setBotConfiguration(TradingBot botConfiguration) { return botConfiguration(botConfiguration); } public BotInAction botConfiguration(TradingBot botConfiguration) { this.botConfiguration = botConfiguration; return this; } final public TradingBot getBotConfiguration() { return botConfiguration(); } public TradingBot botConfiguration() { return botConfiguration; } public TradingBot botConfiguration; transient public TickerSequence ticker; public ListWithChangeListeners openPositions = new ListWithChangeListeners(); public ListWithChangeListeners closedPositions = new ListWithChangeListeners(); public LivePosition openPosition(TickerPoint tickerPoint, double direction) { var p = new Position(tickerPoint.ticker(), tickerPoint.time(), direction); var livePosition = new LivePosition(p).juicer(botConfiguration.juicer); livePosition.update(tickerPoint.time()); openPositions.add(livePosition); change(); return livePosition; } public void closePosition(LivePosition position) { if (openPositions.remove(position)) { change(); } } public void restoreTicker(TickerSequence ticker) { if (ticker == this.ticker) return; this.ticker = ticker; ticker.onPricePointAdded(time -> updatePositions(time)); for (var p : openPositions) p.restoreTicker(ticker); for (var p : closedPositions) p.restoreTicker(ticker); } public void updatePositions(double time) { boolean anyChange = false; for (var p : openPositions) anyChange |= p.update(time); if (anyChange) change(); } } public ClosedPosition runJuicer(Position p, Juicer j) { TickerSequence ticker = p.ticker; long time = lround(p.openingTime); double maxClosingTime = min(time + maxPositionDuration, ticker.endTime()); double crest = -infinity(); while (time < maxClosingTime) { time = ticker.nextTimestamp(time); double profit = p.profitAtTime(time); crest = max(crest, profit); if (profit < (profit < 0 ? -j.lossTolerance : crest - j.pullback)) break; } return new ClosedPosition(p, time); } public class Backtest extends Convergent implements IFieldsToList { public TickerSequence ticker; public TradingBot bot; public Backtest() { } public Backtest(TickerSequence ticker, TradingBot bot) { this.bot = bot; this.ticker = ticker; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + ticker + ", " + bot + ")"; } public Object[] _fieldsToList() { return new Object[] { ticker, bot }; } public List closedPositions = new ArrayList(); public long time; public double latestAllowedOpeningTime() { return ticker.endTime() - maxPositionDuration; } public void step() { if (time == 0) time = ticker.startTime(); if (time > latestAllowedOpeningTime()) { done = true; return; } TickerPoint tickerPoint = new TickerPoint(ticker, time); double direction = bot.eye.adviseDirection(tickerPoint); if (abs(direction) < 1) time = ticker.nextTimestamp(time); else { var position = new Position(ticker, time, direction).eye(bot.eye); var closedPosition = runJuicer(position, bot.juicer); closedPositions.add(closedPosition); time = ticker.nextTimestamp(closedPosition.closingTime); } } } } public interface ILASClassLoader { public Class defineLASClass(String name, IF0 generateClass); public Object rememberClassBytes(boolean rememberClassBytes); } static public class GazelleV_LeftArrowScriptParser extends SimpleLeftToRightParser { final public GazelleV_LeftArrowScriptParser setMagicSwitch(boolean magicSwitch) { return magicSwitch(magicSwitch); } public GazelleV_LeftArrowScriptParser magicSwitch(boolean magicSwitch) { this.magicSwitch = magicSwitch; return this; } final public boolean getMagicSwitch() { return magicSwitch(); } public boolean magicSwitch() { return magicSwitch; } public boolean magicSwitch = true; final public GazelleV_LeftArrowScriptParser setObjectScopesEnabled(boolean objectScopesEnabled) { return objectScopesEnabled(objectScopesEnabled); } public GazelleV_LeftArrowScriptParser objectScopesEnabled(boolean objectScopesEnabled) { this.objectScopesEnabled = objectScopesEnabled; return this; } final public boolean getObjectScopesEnabled() { return objectScopesEnabled(); } public boolean objectScopesEnabled() { return objectScopesEnabled; } public boolean objectScopesEnabled = true; public ClassNameResolver classNameResolver; public List functionContainers = new ArrayList(); final public GazelleV_LeftArrowScriptParser setLasClassLoader(ILASClassLoader lasClassLoader) { return lasClassLoader(lasClassLoader); } public GazelleV_LeftArrowScriptParser lasClassLoader(ILASClassLoader lasClassLoader) { this.lasClassLoader = lasClassLoader; return this; } final public ILASClassLoader getLasClassLoader() { return lasClassLoader(); } public ILASClassLoader lasClassLoader() { return lasClassLoader; } public ILASClassLoader lasClassLoader; final public GazelleV_LeftArrowScriptParser setClassDefPrefix(String classDefPrefix) { return classDefPrefix(classDefPrefix); } public GazelleV_LeftArrowScriptParser classDefPrefix(String classDefPrefix) { this.classDefPrefix = classDefPrefix; return this; } final public String getClassDefPrefix() { return classDefPrefix(); } public String classDefPrefix() { return classDefPrefix; } public String classDefPrefix; final public GazelleV_LeftArrowScriptParser setSourceInfo(Object sourceInfo) { return sourceInfo(sourceInfo); } public GazelleV_LeftArrowScriptParser sourceInfo(Object sourceInfo) { this.sourceInfo = sourceInfo; return this; } final public Object getSourceInfo() { return sourceInfo(); } public Object sourceInfo() { return sourceInfo; } public Object sourceInfo; final public GazelleV_LeftArrowScriptParser setOptimize(boolean optimize) { return optimize(optimize); } public GazelleV_LeftArrowScriptParser optimize(boolean optimize) { this.optimize = optimize; return this; } final public boolean getOptimize() { return optimize(); } public boolean optimize() { return optimize; } public boolean optimize = true; final public GazelleV_LeftArrowScriptParser setUseFixedVarContexts(boolean useFixedVarContexts) { return useFixedVarContexts(useFixedVarContexts); } public GazelleV_LeftArrowScriptParser useFixedVarContexts(boolean useFixedVarContexts) { this.useFixedVarContexts = useFixedVarContexts; return this; } final public boolean getUseFixedVarContexts() { return useFixedVarContexts(); } public boolean useFixedVarContexts() { return useFixedVarContexts; } public boolean useFixedVarContexts = false; public Scope scope; public LinkedHashMap knownVars = new LinkedHashMap(); public Set closerTokens = litset(";", "}", ")"); public BuildingScript currentReturnableScript; public BuildingScript currentLoop; public boolean inParens = false; public int idCounter; public Map classDefs = new HashMap(); final public Map getFunctionDefs() { return functionDefs(); } public Map functionDefs() { return functionDefs; } public Map functionDefs = new HashMap(); public Set flags = ciSet(); transient public Set>> onKnownVarsSnapshot; public GazelleV_LeftArrowScriptParser onKnownVarsSnapshot(IVF1> f) { onKnownVarsSnapshot = createOrAddToSyncLinkedHashSet(onKnownVarsSnapshot, f); return this; } public GazelleV_LeftArrowScriptParser removeKnownVarsSnapshotListener(IVF1> f) { loadableUtils.utils.remove(onKnownVarsSnapshot, f); return this; } public void knownVarsSnapshot(Map knownVars) { if (onKnownVarsSnapshot != null) for (var listener : onKnownVarsSnapshot) pcallF_typed(listener, knownVars); } transient public Set> onTypeHook; public GazelleV_LeftArrowScriptParser onTypeHook(IVF1 f) { onTypeHook = createOrAddToSyncLinkedHashSet(onTypeHook, f); return this; } public GazelleV_LeftArrowScriptParser removeTypeHookListener(IVF1 f) { loadableUtils.utils.remove(onTypeHook, f); return this; } public void typeHook(LASValueDescriptor type) { if (onTypeHook != null) for (var listener : onTypeHook) pcallF_typed(listener, type); } static public class EvaluableWrapper implements IFieldsToList { public GazelleV_LeftArrowScript.Evaluable expr; public EvaluableWrapper() { } public EvaluableWrapper(GazelleV_LeftArrowScript.Evaluable expr) { this.expr = expr; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + expr + ")"; } public boolean equals(Object o) { if (!(o instanceof EvaluableWrapper)) return false; EvaluableWrapper __21 = (EvaluableWrapper) o; return eq(expr, __21.expr); } public int hashCode() { int h = 700525824; h = boostHashCombine(h, _hashCode(expr)); return h; } public Object[] _fieldsToList() { return new Object[] { expr }; } } public class BuildingScript { public int id = ++idCounter; final public BuildingScript setReturnable(boolean returnable) { return returnable(returnable); } public BuildingScript returnable(boolean returnable) { this.returnable = returnable; return this; } final public boolean getReturnable() { return returnable(); } public boolean returnable() { return returnable; } public boolean returnable = false; final public BuildingScript setIsLoopBody(boolean isLoopBody) { return isLoopBody(isLoopBody); } public BuildingScript isLoopBody(boolean isLoopBody) { this.isLoopBody = isLoopBody; return this; } final public boolean getIsLoopBody() { return isLoopBody(); } public boolean isLoopBody() { return isLoopBody; } public boolean isLoopBody = false; public BuildingScript returnableParent, loopParent; public GazelleV_LeftArrowScript.Script script = new GazelleV_LeftArrowScript.Script(); public List steps = new ArrayList(); public Map functionDefs = new HashMap(); public BuildingScript(boolean returnable) { this(); this.returnable = returnable; } public BuildingScript(boolean returnable, boolean isLoopBody) { this(); this.isLoopBody = isLoopBody; this.returnable = returnable; } public BuildingScript() { } public void add(GazelleV_LeftArrowScript.Evaluable step) { if (step != null) steps.add(step); } public GazelleV_LeftArrowScript.Evaluable get() { var lastStep = last(steps); if (lastStep instanceof GazelleV_LeftArrowScript.ReturnFromScript) if (((GazelleV_LeftArrowScript.ReturnFromScript) lastStep).script == script) replaceLast(steps, ((GazelleV_LeftArrowScript.ReturnFromScript) lastStep).value); if (!returnable && l(steps) == 1 && empty(functionDefs)) return first(steps); if (nempty(functionDefs)) script.functionDefs = functionDefs; script.steps = toTypedArray(GazelleV_LeftArrowScript.Evaluable.class, steps); return script; } public String toStringLong() { return pnlToLines(steps); } public String toString() { return formatRecordVars("BuildingScript", "id", id, "returnable", returnable, "returnableParent", returnableParent, "script", script); } } { tokenize = text -> { List tok = tokenize_base(text); tok = preprocess(tok); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("=== PREPROCESSED\n" + indentx(join(tok)) + "\n==="); return tok; }; } public List preprocess(List tok) { tok = tokenIndexedList3(tok); tok_ifdef(tok, __20 -> getFlag(__20)); tok_pcall_script(tok); tok_script_settable(tok); jreplace(tok, "LS", "L"); jreplace(tok, ", +", ", $3 $3"); return cloneList(tok); } public GazelleV_LeftArrowScript.Script parse(String text) { setText(text); init(); return parse(); } public GazelleV_LeftArrowScript.Script parse() { GazelleV_LeftArrowScript.Script script = parseReturnableScript(); if (optimize) script = script.optimizeScript(); return script; } public GazelleV_LeftArrowScript.Script parseReturnableScript() { return (GazelleV_LeftArrowScript.Script) parseScript(new BuildingScript().returnable(true)); } public GazelleV_LeftArrowScript.Evaluable parseScript(BuildingScript script) { return linkToSrc(() -> { script.returnableParent = currentReturnableScript; script.loopParent = currentLoop; if (script.returnable) currentReturnableScript = script; if (script.isLoopBody) currentLoop = script; return parseBuildingScript(script); }); } public GazelleV_LeftArrowScript.Evaluable parseBuildingScript(BuildingScript script) { try { parseScript_2(script); var builtScript = script.get(); currentReturnableScript = script.returnableParent; currentLoop = script.loopParent; return builtScript; } catch (Throwable e) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Parsed so far:\n" + script); throw rethrowAndAppendToMessage(e, squareBracketed(spaceCombine(sourceInfo, lineAndColumn(-1)))); } } public void parseScript_2(BuildingScript script) { AutoCloseable __10 = tempRestoreMap(knownVars); try { AssureAdvance assure = new AssureAdvance(); while (assure.get()) { knownVarsSnapshot(knownVars); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("parseScript_2: Next token is " + quote(token())); if (is(";")) { next(); continue; } if (isOneOf("}", ")")) break; GazelleV_LeftArrowScript.Evaluable instruction = linkToSrc(() -> parseInstruction(script)); if (instruction != null) script.add(instruction); } if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("parseScript_2 done"); knownVarsSnapshot(knownVars); } finally { _close(__10); } } public GazelleV_LeftArrowScript.Evaluable parseParamDecl(BuildingScript script) { String var = assertIdentifier(tpp()); LASValueDescriptor valueDescriptor = new LASValueDescriptor(); if (is(":")) { var type = parseColonType(); valueDescriptor = LASValueDescriptor.nonExactCanBeNull(type); } knownVars.put(var, valueDescriptor); script.script.params = putOrCreateLinkedHashMap(script.script.params, var, valueDescriptor); return null; } public GazelleV_LeftArrowScript.Evaluable parseInstruction(BuildingScript script) { if (consumeOpt("param")) return parseParamDecl(script); if (is("throw")) { consume(); return new GazelleV_LeftArrowScript.Throw(parseExpr()); } if (isOneOf("return", "ret")) { consume(); GazelleV_LeftArrowScript.Evaluable expr; if (atCmdEnd()) expr = _const(null); else expr = parseAssignmentOrExpr(); return new GazelleV_LeftArrowScript.ReturnFromScript(currentReturnableScript.script, expr); } if (consumeOpt("continue")) { assertCmdEnd(); if (currentLoop == null) throw fail("continue outside of loop"); return new GazelleV_LeftArrowScript.Continue(currentLoop.script); } if (is("temp")) { consume(); GazelleV_LeftArrowScript.Evaluable tempExpr = parseAssignmentOrExpr(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("tempExpr", tempExpr); GazelleV_LeftArrowScript.Evaluable body = parseScript(new BuildingScript()); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("body", body); return new GazelleV_LeftArrowScript.TempBlock(tempExpr, body); } if (is("will") && is(1, "return")) { consume(2); GazelleV_LeftArrowScript.Evaluable exp = parseAssignmentOrExpr(); GazelleV_LeftArrowScript.Evaluable body = parseScript(new BuildingScript()); return new GazelleV_LeftArrowScript.WillReturn(exp, body); } if (is("var") && isIdentifier(token(1))) { consume(); String varName = consume(); var type = parseColonTypeOpt(); if (consumeLeftArrowOpt()) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Found assignment"); GazelleV_LeftArrowScript.Evaluable rhs = parseExpr(); assertNotNull("Expression expected", rhs); knownVars.put(varName, type == null ? or(rhs.returnType(), new LASValueDescriptor()) : LASValueDescriptor.nonExactCanBeNull(type)); return new GazelleV_LeftArrowScript.VarDeclaration(varName, typeToClass(type), rhs); } } return parseAssignmentOrExpr(); } public GazelleV_LeftArrowScript.Evaluable parseAssignmentOrExpr() { { var __2 = parseAssignmentOpt(); if (__2 != null) return __2; } return parseExpr(); } public GazelleV_LeftArrowScript.Evaluable parseAssignmentOpt() { String t = token(); if (isIdentifier(t)) { Type type = null; var ptr = ptr(); if (is(1, ":")) { next(); type = parseColonType(); unconsume(); } if (is(1, "<") && is(2, "-")) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Found assignment"); next(3); GazelleV_LeftArrowScript.Evaluable rhs = parseExpr(); assertNotNull("Expression expected", rhs); boolean newVar = !knownVars.containsKey(t); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("newVar", newVar, "t", t, "knownVars", knownVars); if (newVar && scope != null) { var __3 = scope.completeAssignmentOpt(t, rhs); if (__3 != null) return __3; } knownVars.put(t, type == null ? or(rhs.returnType(), new LASValueDescriptor()) : LASValueDescriptor.nonExactCanBeNull(type)); return newVar ? new GazelleV_LeftArrowScript.VarDeclaration(t, null, rhs) : new GazelleV_LeftArrowScript.Assignment(t, rhs); } ptr(ptr); } return null; } public GazelleV_LeftArrowScript.Evaluable parseOptionalInnerExpression() { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("parseOptionalInnerExpression", "token", token()); if (atCmdEnd() || isOneOf("{", ",", "then")) return null; return parseInnerExpr(); } public GazelleV_LeftArrowScript.Evaluable _const(Object o) { return new GazelleV_LeftArrowScript.Const(o); } public GazelleV_LeftArrowScript.Evaluable parseInnerExpr() { return parseExpr(true); } public GazelleV_LeftArrowScript.Evaluable parseExpr() { if (metaGet("scaffolding") != null) scaffoldCalled(this, "parseExpr"); return parseExpr(false); } public GazelleV_LeftArrowScript.Evaluable parseExpr(boolean inner) { GazelleV_LeftArrowScript.Evaluable e = linkToSrc(() -> inner ? parseExpr_impl(true) : parseFullExpr()); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("parseExpr done:\n" + GazelleV_LeftArrowScript.indentedScriptStruct(e)); return e; } public GazelleV_LeftArrowScript.Evaluable parseFullExpr() { return linkToSrc(() -> parseExprPlusOptionalComma()); } public GazelleV_LeftArrowScript.CallOnTarget parseThenCall(GazelleV_LeftArrowScript.CallOnTarget expr) { consume("then"); GazelleV_LeftArrowScript.CallOnTarget secondCall = (GazelleV_LeftArrowScript.CallOnTarget) (parseCall(null)); return new GazelleV_LeftArrowScript.Then(expr, secondCall); } public GazelleV_LeftArrowScript.Evaluable parseExprPlusOptionalComma() { GazelleV_LeftArrowScript.Evaluable expr = parseExpr_impl(false); while (consumeOpt(",")) { expr = parseCall_noCmdEndCheck(expr); } return expr; } public GazelleV_LeftArrowScript.Evaluable parseExpr_impl(boolean inner) { if (atEnd()) return null; String t = token(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("parseExpr", "token", t); if (is(";")) return null; if (consumeOpt("try")) { GazelleV_LeftArrowScript.Evaluable body = parseCurlyBlock(); while (consumeOpt("catch")) { String var = consumeIdentifierOpt(); AutoCloseable __11 = tempAddKnownVars(var); try { GazelleV_LeftArrowScript.Evaluable catchBlock = parseCurlyBlock(); body = new GazelleV_LeftArrowScript.TryCatch(body, var, catchBlock); } finally { _close(__11); } } if (consumeOpt("finally")) { GazelleV_LeftArrowScript.Evaluable finallyBlock = parseCurlyBlock(); return new GazelleV_LeftArrowScript.TryFinally(body, finallyBlock); } return body; } if (is("def")) { var fd = parseFunctionDefinition(currentReturnableScript.functionDefs); return _const(fd); } if (is("{")) return parseCurlyBlock(); if (is("-") && empty(nextSpace()) && startsWithDigit(token(1)) || startsWithDigit(t)) { var e = parseNumberLiteral(); return parseCall(inner, e); } if (isQuoted(t)) { var e = parseStringLiteral(); return parseCall(inner, e); } if (startsWith(t, '\'')) { consume(); var e = _const(first(unquote(t))); return parseCall(inner, e); } if (isIdentifier(t)) { if (consumeOpt("synchronized")) { var target = parseExpr(); var body = parseCurlyBlock(); return new GazelleV_LeftArrowScript.Synchronized(target, body); } if (is("while")) return parseWhileLoop(); if (is("for")) return parseForEach(); if (is("if")) return parseIfStatement(); if (is("repeat")) return parseRepeatStatement(); if (is("outer")) { consume(); var a = parseAssignmentOpt(); if (!(a instanceof GazelleV_LeftArrowScript.Assignment)) throw fail("Assignment expected"); return new GazelleV_LeftArrowScript.AssignmentToOuterVar(((GazelleV_LeftArrowScript.Assignment) a).var, ((GazelleV_LeftArrowScript.Assignment) a).expression); } consume(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Consumed identifier " + t + ", next token: " + token() + ", inner: " + inner); var e = parseExprStartingWithIdentifier(t, inner); return inner ? parseCall(inner, e) : e; } if (eq(t, "(")) { consume(); GazelleV_LeftArrowScript.Evaluable e = parseExpr_inParens(); consume(")"); return parseCall(inner, e); } if (isOneOf("&", "|") && empty(nextSpace()) && is(1, token())) { return parseBinaryOperator(); } throw fail("Identifier, literal, operator or opening parentheses expected (got: " + quote(t)); } public GazelleV_LeftArrowScript.Evaluable parseExpr_inParens() { boolean inParensOld = inParens; inParens = true; try { return parseExpr(); } finally { inParens = inParensOld; } } public GazelleV_LeftArrowScript.Evaluable parseNumberLiteral() { String t = consumeMultiTokenLiteral(); if (swic(t, "0x")) return _const(parseHexInt(dropFirst(t, 2))); if (swic(t, "0b")) return _const(intFromBinary(dropFirst(t, 2))); if (isInteger(t)) return _const(parseIntOrLong(t)); if (ewic(t, "f")) return _const(parseFloat(t)); if (endsWith(t, "L")) return _const(parseLong(t)); return _const(parseDouble(t)); } public GazelleV_LeftArrowScript.Evaluable parseBinaryOperator() { boolean and = is("&"); next(2); GazelleV_LeftArrowScript.Evaluable a = parseInnerExpr(); GazelleV_LeftArrowScript.Evaluable b = parseInnerExpr(); return and ? new GazelleV_LeftArrowScript.BoolAnd(a, b) : new GazelleV_LeftArrowScript.BoolOr(a, b); } public boolean qualifiedNameContinues() { return empty(prevSpace()) && eq(token(), ".") && empty(nextSpace()) && isIdentifier(token(1)); } public GazelleV_LeftArrowScript.Evaluable parseNewExpr() { String className = assertIdentifier(tpp()); parseTypeArguments(null); LASClassDef cd = classDefs.get(className); if (cd != null) return new GazelleV_LeftArrowScript.NewObject_LASClass(cd.resolvable(lasClassLoader)); var type = knownVars.get(className); if (type != null) return new GazelleV_LeftArrowScript.NewObject_UnknownClass(new GazelleV_LeftArrowScript.GetVar(className), parseArguments()); Object o = findExternalObject(className); if (o instanceof Class) { Class c = (Class) o; if (c == List.class) c = ArrayList.class; else if (c == Map.class) c = HashMap.class; else if (c == Set.class) c = HashSet.class; return new GazelleV_LeftArrowScript.NewObject(c, parseArguments()); } throw new ClassNotFound(className); } public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithIdentifier(String t, boolean inner) { if (eq(t, "true")) return _const(true); if (eq(t, "false")) return _const(false); if (eq(t, "null")) return _const(null); if (eq(t, "new")) return parseNewExpr(); if (eq(t, "class")) { unconsume(); return new GazelleV_LeftArrowScript.ClassDef(parseClassDef().resolvable(lasClassLoader)); } if (eq(t, "list") && is("{")) { GazelleV_LeftArrowScript.Script block = parseReturnableCurlyBlock(); GazelleV_LeftArrowScript.Evaluable e = new GazelleV_LeftArrowScript.ListFromScript(block); return parseCall(inner, e); } var type = knownVars.get(t); if (type != null) { var e = new GazelleV_LeftArrowScript.GetVar(t).returnType(type); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Found var acccess: " + e + ", " + (!inner ? "Checking for call" : "Returning expression")); return parseCall(inner, e); } if (scope != null) { { var __4 = scope.parseExprStartingWithIdentifierOpt(t, inner); if (__4 != null) return __4; } } LASClassDef cd = classDefs.get(t); if (cd != null) return new GazelleV_LeftArrowScript.ClassDef(cd.resolvable(lasClassLoader)); if (!inner) { var fdef = lookupFunction(t); if (fdef != null) { if (is("~")) return parseTildeCall(new GazelleV_LeftArrowScript.CallFunction(fdef, new GazelleV_LeftArrowScript.Evaluable[0])); return new GazelleV_LeftArrowScript.CallFunction(fdef, parseArguments()); } } if (eq(t, "_context")) return new GazelleV_LeftArrowScript.GetVarContext(); Object o = findExternalObject(t); var start = ptr().minus(2); if (o == null) { throw new UnknownObject(t); } else if (o instanceof EvaluableWrapper) { return parseCall(inner, ((EvaluableWrapper) o).expr); } else if (inner) return linkToSrc(start, _const(o)); else if (o instanceof Class) { return parseExprStartingWithClass(start, ((Class) o)); } else if (o instanceof MethodOnObject) { if (inner) throw fail("Can't call methods in arguments"); return new GazelleV_LeftArrowScript.CallMethod(_const(((MethodOnObject) o).object), ((MethodOnObject) o).method, parseArguments()); } else return parseCall(_const(o)); } public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithClass(ListAndIndex start, Class c) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("parseExprStartingWithClass", "c", c); if (atCmdEnd()) return linkToSrc(start, _const(c)); if (is("(")) return new GazelleV_LeftArrowScript.NewObject(c, parseArguments()); { var __5 = parseLambdaOpt(c); if (__5 != null) return __5; } if (isIdentifier()) { String name = tpp(); if (hasStaticMethodNamed(c, name)) return new GazelleV_LeftArrowScript.CallMethod(_const(c), name, parseArguments()); if (isInterface(c)) return parseLambdaMethodRef(c, name); var field = getField(c, name); if (field == null) field = findFieldInInterfaces(c, name); if (field != null) { if (!isStaticField(field)) throw fail(field + " is not a static field"); if (consumeLeftArrowOpt()) { GazelleV_LeftArrowScript.Evaluable rhs = parseExpr(); return new GazelleV_LeftArrowScript.SetStaticField(field, rhs); } assertCmdEnd(); return new GazelleV_LeftArrowScript.GetStaticField(field); } throw fail(name + " not found in " + c + " (looked for method or field)"); } else throw fail("Method name expected: " + token()); } public GazelleV_LeftArrowScript.Evaluable parseLambdaOpt(Class c) { if (!isInterface(c)) return null; var ptr = ptr(); var parameterized = parseTypeArgumentsOpt(c); if (is("{")) return finishLambdaDef(c, null); if (consumeOpt("_")) { String methodName = consumeIdentifier(); return new GazelleV_LeftArrowScript.LambdaMethodOnArgument(c, methodName, parseArguments()); } LinkedHashMap args = new LinkedHashMap(); while (isIdentifier()) { String name = consume(); args.put(name, typeToValueDescriptor(parseColonTypeOpt())); } if (!(is("-") && is(1, ">"))) { ptr(ptr); return null; } skip(2); return finishLambdaDef(c, args); } public GazelleV_LeftArrowScript.Evaluable finishLambdaDef(Class c, LinkedHashMap args) { AutoCloseable __12 = tempAddKnownVars(args); try { knownVarsSnapshot(knownVars); GazelleV_LeftArrowScript.Evaluable body; if (is("{")) body = parseReturnableCurlyBlock(); else body = parseExpr(); var lambda = new GazelleV_LeftArrowScript.LambdaDef(c, toStringArray(keys(args)), body); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("finishLambdaDef done:\n" + GazelleV_LeftArrowScript.indentedScriptStruct(lambda)); return lambda; } finally { _close(__12); } } public GazelleV_LeftArrowScript.Evaluable parseLambdaMethodRef(Class c, String name) { var fdef = lookupFunction(name); if (fdef != null) { GazelleV_LeftArrowScript.Evaluable[] curriedArguments = parseArguments(); return new GazelleV_LeftArrowScript.CurriedScriptFunctionLambda(c, fdef, curriedArguments); } Object function = findExternalObject(name); if (function == null) throw new UnknownObject(name); if (function instanceof MethodOnObject) { Object target = ((MethodOnObject) function).object; String targetMethod = ((MethodOnObject) function).method; GazelleV_LeftArrowScript.Evaluable[] curriedArguments = parseArguments(); return new GazelleV_LeftArrowScript.CurriedMethodLambda(c, target, targetMethod, curriedArguments); } else if (function instanceof Class) { Class c2 = (Class) function; assertCmdEnd(); var ctors = constructorsWithNumberOfArguments(c2, 1); if (empty(ctors)) throw fail("No single argument constructor found in " + c2); return new GazelleV_LeftArrowScript.CurriedConstructorLambda(c, toArray(Constructor.class, ctors), null); } else throw fail(function + " is not an instantiable class or callable method"); } public GazelleV_LeftArrowScript.FunctionDef lookupFunction(String name) { var script = currentReturnableScript; while (script != null) { var f = script.functionDefs.get(name); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("lookupFunction", "script", script, "name", name, "f", f); if (f != null) return f; script = script.returnableParent; } return functionDefs.get(name); } public GazelleV_LeftArrowScript.Evaluable[] parseArguments() { List l = new ArrayList(); try { while (true) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("parseArgumentsAsList: token is " + quote(t())); if (is("+") && empty(nextSpace()) && isIdentifier(token(1))) { consume(); l.add(_const(token())); continue; } if (consumeOpt("<")) { GazelleV_LeftArrowScript.Evaluable a = parseFullExpr(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("parseArgumentsAsList: token after expr is " + quote(t())); if (a == null) throw fail("expression expected"); l.add(a); break; } GazelleV_LeftArrowScript.Evaluable a = parseOptionalInnerExpression(); if (a == null) break; l.add(a); } return toArrayOrNull(GazelleV_LeftArrowScript.Evaluable.class, l); } catch (Throwable _e) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Arguments parsed so far: " + l); throw rethrow(_e); } } public String consumeMultiTokenLiteral() { return consumeUntilSpaceOr(() -> atCmdEnd() || is(",")); } public boolean atCmdEnd() { return !inParens && atEndOrLineBreak() || closerTokens.contains(token()); } public void assertCmdEnd() { if (!atCmdEnd()) throw fail("Expected end of command, token is: " + quote(token())); } public GazelleV_LeftArrowScript.Evaluable parseCall(GazelleV_LeftArrowScript.Evaluable target) { return parseCall(false, target); } public GazelleV_LeftArrowScript.Evaluable parseCall(boolean inner, GazelleV_LeftArrowScript.Evaluable target) { returnTypeHook(target); if (atCmdEnd()) return target; if (inner) { { var __6 = parseTildeCall(target); if (__6 != null) return __6; } return target; } return parseCall_noCmdEndCheck(target); } public void returnTypeHook(GazelleV_LeftArrowScript.Evaluable e) { if (e != null && e.returnType() != null) typeHook(e.returnType()); } public GazelleV_LeftArrowScript.Evaluable parseCall_noCmdEndCheck(GazelleV_LeftArrowScript.Evaluable target) { var start = ptr(); returnTypeHook(target); if (isIdentifier()) { String name = tpp(); if (consumeLeftArrowOpt()) { GazelleV_LeftArrowScript.Evaluable rhs = parseExpr(); return new GazelleV_LeftArrowScript.SetField(target, name, rhs); } boolean allowNullReference = consumeOpt("?"); var args = parseArguments(); var call = finalizeCall(start, target, name, args); set(call, "allowNullReference", allowNullReference); return call; } { var __7 = parseTildeCall(target); if (__7 != null) return __7; } if (is("!") && is(1, "_getField_")) { next(2); String field = consumeIdentifier(); return new GazelleV_LeftArrowScript.GetField(target, field); } return target; } public boolean consumeLeftArrowOpt() { if (is("<") && eq(token(1), "-")) { next(2); return true; } return false; } public GazelleV_LeftArrowScript.Evaluable parseTildeCall(GazelleV_LeftArrowScript.Evaluable target) { var start = ptr(); if (consumeOpt("~")) { if (isIdentifier()) { String key = consumeIdentifier(); return parseCall(finalizeCall(start, target, "getOpt", _const(key))); } else { int idx = consumeInteger(); return parseCall(finalizeCall(start, target, "listGet", _const(idx))); } } return null; } public GazelleV_LeftArrowScript.Evaluable finalizeCall(ListAndIndex start, GazelleV_LeftArrowScript.Evaluable target, String name, GazelleV_LeftArrowScript.Evaluable... args) { return finalizeCall2(finalizeCall1(start, target, name, args)); } public GazelleV_LeftArrowScript.Evaluable finalizeCall2(GazelleV_LeftArrowScript.CallOnTarget call) { while (is("then")) call = parseThenCall(call); return call; } public GazelleV_LeftArrowScript.CallOnTarget finalizeCall1(ListAndIndex start, GazelleV_LeftArrowScript.Evaluable target, String name, GazelleV_LeftArrowScript.Evaluable... args) { if (magicSwitch) { Object ext = findExternalObject(name); if (ext instanceof MethodOnObject) { if (nempty(args)) return new GazelleV_LeftArrowScript.CallMethodOrGlobalFunction(target, name, ((MethodOnObject) ext), args); else return new GazelleV_LeftArrowScript.CallMethodOrGetFieldOrGlobalFunction(target, name, ((MethodOnObject) ext)); } } if (nempty(args)) return new GazelleV_LeftArrowScript.CallMethod(target, name, args); else return linkToSrc(start, new GazelleV_LeftArrowScript.CallMethodOrGetField(target, name)); } public A linkToSrc(ListAndIndex start, A a) { if (a instanceof IHasTokenRangeWithSrc) if (((IHasTokenRangeWithSrc) a).tokenRangeWithSrc() == null) ((IHasTokenRangeWithSrc) a).setTokenRangeWithSrc(new TokenRangeWithSrc(start, ptr().plus(-1)).sourceInfo(sourceInfo())); return a; } public A linkToSrc(IF0 a) { var start = ptr(); return linkToSrc(start, a.get()); } transient public IF1 findExternalObject; public Object findExternalObject(String name) { return findExternalObject != null ? findExternalObject.get(name) : findExternalObject_base(name); } final public Object findExternalObject_fallback(IF1 _f, String name) { return _f != null ? _f.get(name) : findExternalObject_base(name); } public Object findExternalObject_base(String name) { if (eq(name, "void")) return void.class; { var __8 = parsePrimitiveType(name); if (__8 != null) return __8; } if (qualifiedNameContinues()) { int idx = idx() - 2; do next(2); while (qualifiedNameContinues()); String fqn = joinSubList(tok, idx, idx() - 1); return classForName(fqn); } return findExternalObject2(name); } transient public IF1 findExternalObject2; public Object findExternalObject2(String name) { return findExternalObject2 != null ? findExternalObject2.get(name) : findExternalObject2_base(name); } final public Object findExternalObject2_fallback(IF1 _f, String name) { return _f != null ? _f.get(name) : findExternalObject2_base(name); } public Object findExternalObject2_base(String name) { String fullName = globalClassNames().get(name); if (fullName != null) return classForName(fullName); { var __9 = classForNameOpt_noCache(name); if (__9 != null) return __9; } for (var container : unnullForIteration(functionContainers)) { if (hasMethodNamed(container, name) && !isBlockedFunctionContainerMethod(container, name)) { var moo = new MethodOnObject(container, name); return moo; } var field = getField(container, name); if (field != null && isStaticField(field)) return new EvaluableWrapper(new GazelleV_LeftArrowScript.GetStaticField(field)); } return null; } transient public IF2 isBlockedFunctionContainerMethod; public boolean isBlockedFunctionContainerMethod(Object container, String name) { return isBlockedFunctionContainerMethod != null ? isBlockedFunctionContainerMethod.get(container, name) : isBlockedFunctionContainerMethod_base(container, name); } final public boolean isBlockedFunctionContainerMethod_fallback(IF2 _f, Object container, String name) { return _f != null ? _f.get(container, name) : isBlockedFunctionContainerMethod_base(container, name); } public boolean isBlockedFunctionContainerMethod_base(Object container, String name) { return false; } public GazelleV_LeftArrowScriptParser allowTheWorld() { return allowTheWorld(mc()); } public GazelleV_LeftArrowScriptParser allowTheWorld(Object... functionContainers) { for (Object o : unnullForIteration(reversed(functionContainers))) if (!contains(this.functionContainers, o)) { this.functionContainers.add(0, o); globalClassNames_cache = null; } return this; } public void printFunctionDefs(GazelleV_LeftArrowScript.Script script) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print(values(script.functionDefs)); } public AutoCloseable tempAddKnownVars(String... vars) { return tempAddKnownVars(nonNulls(vars)); } public AutoCloseable tempAddKnownTypedVars(Iterable vars) { return tempAddKnownVars(mapToMap(vars, v -> pair(v.name, v.type))); } public AutoCloseable tempAddKnownVars(Iterable vars) { var newVars = mapWithSingleValue(vars, new LASValueDescriptor()); return tempAddKnownVars(newVars); } public AutoCloseable tempAddKnownVar(String var, LASValueDescriptor type) { return tempAddKnownVars(litmap(var, type)); } public AutoCloseable tempAddKnownVars(Map newVars) { return tempMapPutAll(knownVars, newVars); } public String parseFunctionDefArg(Map argsOut) { if (consumeOpt("(")) { String result = parseFunctionDefArg(argsOut); consume(")"); return result; } if (isIdentifier()) { String arg = tpp(); var type = typeToValueDescriptor(parseColonTypeOpt()); argsOut.put(arg, type); return arg; } return null; } public GazelleV_LeftArrowScript.FunctionDef parseFunctionDefinition(Map functionDefsToAddTo) { var start = ptr(); consume("def"); boolean synthetic = consumeOpt("!"); if (synthetic) consume("synthetic"); String functionName = assertIdentifier(tpp()); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("parseFunctionDefinition " + functionName); return parseFunctionDefinition_step2(functionDefsToAddTo, start, functionName).synthetic(synthetic); } public GazelleV_LeftArrowScript.FunctionDef parseFunctionDefinition_step2(Map functionDefsToAddTo, ListAndIndex start, String functionName) { LinkedHashMap args = new LinkedHashMap(); while (parseFunctionDefArg(args) != null) { } var returnType = parseColonTypeOpt(); var fd = new GazelleV_LeftArrowScript.FunctionDef(functionName, keysList(args), null); fd.argTypes(valuesArray(LASValueDescriptor.class, args)); { if (functionDefsToAddTo != null) functionDefsToAddTo.put(functionName, fd); } AutoCloseable __13 = tempAddKnownVars(args); try { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Parsing function body"); fd.body = parseReturnableCurlyBlock(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Defined function " + functionName + ", added to " + functionDefsToAddTo); if (returnType != null) fd.returnType(returnType); return linkToSrc(start, fd); } finally { _close(__13); } } public Scope currentScope() { return scope; } public AutoCloseable tempScope(Scope scope) { var oldScope = currentScope(); this.scope = scope; return () -> { this.scope = oldScope; }; } public GazelleV_LeftArrowScript.Script parseReturnableCurlyBlock() { return (GazelleV_LeftArrowScript.Script) parseCurlyBlock(new BuildingScript().returnable(true)); } public GazelleV_LeftArrowScript.Evaluable parseCurlyBlock() { return parseCurlyBlock(new BuildingScript()); } public GazelleV_LeftArrowScript.Evaluable parseCurlyBlock(BuildingScript script) { consume("{"); boolean inParensOld = inParens; inParens = false; var body = parseScript(script); consume("}"); inParens = inParensOld; return body; } public GazelleV_LeftArrowScript.Evaluable parseWhileLoop() { consume("while"); var condition = parseExpr(); var body = parseCurlyBlock(new BuildingScript().isLoopBody(true)); return new GazelleV_LeftArrowScript.While(condition, body); } public GazelleV_LeftArrowScript.Evaluable parseForEach() { return new ParseForEach().get(); } public class ParseForEach { public GazelleV_LeftArrowScript.Evaluable collection, body; public IF0 finish; public List vars = new ArrayList(); public TypedVar addVar(TypedVar var) { return addAndReturn(vars, var); } public TypedVar consumeVar() { String name = consumeIdentifier(); var type = parseColonTypeOpt(); return addVar(new TypedVar(name, typeToValueDescriptor(type))); } public void parseBody() { AutoCloseable __14 = tempAddKnownTypedVars(vars); try { body = parseCurlyBlock(new BuildingScript().isLoopBody(true)); } finally { _close(__14); } } public GazelleV_LeftArrowScript.Evaluable get() { consume("for"); if (is(1, "to")) { TypedVar var = consumeVar(); consume("to"); GazelleV_LeftArrowScript.Evaluable endValue = parseExpr(); parseBody(); return new GazelleV_LeftArrowScript.ForIntTo(endValue, var.name, body); } int iIn = relativeIndexOf("in"); if (iIn < 0) throw fail("for without in"); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("iIn", iIn); if (iIn == 1 || is(1, ":")) { TypedVar var = consumeVar(); finish = () -> new GazelleV_LeftArrowScript.ForEach(collection, var.name, body).varType(var.type); } else if (iIn == 2) { if (consumeOpt("iterator")) { TypedVar var = consumeVar(); finish = () -> new GazelleV_LeftArrowScript.ForIterator(collection, var.name, body); } else if (consumeOpt("nested")) { TypedVar var = consumeVar(); finish = () -> new GazelleV_LeftArrowScript.ForNested(collection, var.name, body); } else throw fail("Unknown pattern for 'for' loop"); } else if (iIn == 3) { if (isOneOf("pair", "Pair")) { consume(); TypedVar varA = consumeVar(); TypedVar varB = consumeVar(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("varA", varA, "varB", varB); finish = () -> new GazelleV_LeftArrowScript.ForPairs(collection, body, varA.name, varB.name); } else { TypedVar varA = consumeVar(); consume(","); TypedVar varB = consumeVar(); finish = () -> new GazelleV_LeftArrowScript.ForKeyValue(collection, body, varA.name, varB.name); } } else if (iIn == 4) { consume("index"); String varIndex = consumeVar().name; consume(","); String varElement = consumeVar().name; finish = () -> new GazelleV_LeftArrowScript.ForIndex(collection, body, varIndex, varElement); } else throw fail("Unknown pattern for 'for' loop"); consume("in"); collection = parseExpr_inParens(); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("collection", collection); parseBody(); return finish.get(); } } public GazelleV_LeftArrowScript.Evaluable parseIfStatement() { consume("if"); GazelleV_LeftArrowScript.Evaluable condition, body, elseBranch = null; { AutoCloseable __15 = tempAdd(closerTokens, "then"); try { condition = parseExpr(); } finally { _close(__15); } } if (consumeOpt("then")) { AutoCloseable __16 = tempAdd(closerTokens, "else"); try { body = parseExpr(); if (consumeOpt("else")) elseBranch = parseExpr(); } finally { _close(__16); } } else { body = parseCurlyBlock(); if (consumeOpt("else")) { if (is("if")) elseBranch = parseIfStatement(); else elseBranch = parseCurlyBlock(); } } return new GazelleV_LeftArrowScript.IfThen(condition, body, elseBranch); } public GazelleV_LeftArrowScript.Evaluable parseRepeatStatement() { consume("repeat"); var n = parseExpr(); var body = parseCurlyBlock(); return new GazelleV_LeftArrowScript.RepeatN(n, body); } public void addVar(String var) { addVar(var, new LASValueDescriptor()); } public void addVar(String var, LASValueDescriptor type) { knownVars.put(var, type); } public void addVar(String var, Class type, boolean canBeNull) { addVar(var, typeToValueDescriptor(type, canBeNull)); } public LASValueDescriptor typeToValueDescriptor(Type type) { return typeToValueDescriptor(type, true); } public LASValueDescriptor typeToValueDescriptor(Type type, boolean canBeNull) { return type == null ? new LASValueDescriptor() : new LASValueDescriptor.NonExact(typeToClass(type), canBeNull); } public Map globalClassNames_cache; public Map globalClassNames() { if (globalClassNames_cache == null) globalClassNames_cache = globalClassNames_load(); return globalClassNames_cache; } public Map globalClassNames_load() { var packages = mapToTreeSet(importedPackages(), pkg -> pkg + "."); Map out = new HashMap(); for (var name : unnullForIteration(importedClasses())) out.put(shortenClassName(name), name); for (var fc : functionContainers) if (fc instanceof Class) { if (isAnonymousClass((Class) fc)) continue; out.put(shortClassName((Class) fc), className((Class) fc)); } var classContainers = classContainerPrefixes(); TreeSet classContainerSet = asTreeSet(classContainers); for (var className : classNameResolver().allFullyQualifiedClassNames()) { if (isAnonymousClassName(className)) continue; if (!contains(className, '$')) { String pkg = longestPrefixInTreeSet(className, packages); if (pkg != null) { String shortName = dropPrefix(pkg, className); if (!shortName.contains(".") && !out.containsKey(shortName)) out.put(shortName, className); } } String container = longestPrefixInTreeSet(className, classContainerSet); if (container != null) { String shortName = dropPrefix(container, className); String existing = out.get(shortName); if (existing != null) { int priority = indexOf(classContainers, container); String oldContainer = longestPrefixInTreeSet(existing, classContainerSet); int oldPriority = smartIndexOf(classContainers, oldContainer); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("className", className, "shortName", shortName, "container", container, "priority", priority, "existing", existing, "oldPriority", oldPriority); if (priority > oldPriority) continue; } out.put(shortName, className); } } for (var __23 : _entrySet(unnullForIteration(classShortcuts()))) { var key = __23.getKey(); var val = __23.getValue(); String fullName = out.get(val); if (fullName != null) out.put(key, fullName); } return out; } transient public IF0> classShortcuts; public Map classShortcuts() { return classShortcuts != null ? classShortcuts.get() : classShortcuts_base(); } final public Map classShortcuts_fallback(IF0> _f) { return _f != null ? _f.get() : classShortcuts_base(); } public Map classShortcuts_base() { return javaxClassShortcuts(); } transient public IF0> importedPackages; public Collection importedPackages() { return importedPackages != null ? importedPackages.get() : importedPackages_base(); } final public Collection importedPackages_fallback(IF0> _f) { return _f != null ? _f.get() : importedPackages_base(); } public Collection importedPackages_base() { return itemPlus("java.lang", standardImports_fullyImportedPackages()); } transient public IF0> importedClasses; public Collection importedClasses() { return importedClasses != null ? importedClasses.get() : importedClasses_base(); } final public Collection importedClasses_fallback(IF0> _f) { return _f != null ? _f.get() : importedClasses_base(); } public Collection importedClasses_base() { return standardImports_singleClasses(); } public void addClassAlias(String alias, String longName) { String fullName = globalClassNames().get(longName); if (fullName != null) globalClassNames().put(alias, fullName); } public List classContainerPrefixes() { return map(functionContainers, fc -> className(fc) + "$"); } static public class UnknownObject extends RuntimeException implements IFieldsToList { public String name; public UnknownObject() { } public UnknownObject(String name) { this.name = name; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + name + ")"; } public Object[] _fieldsToList() { return new Object[] { name }; } public String getMessage() { return "Unknown object: " + name; } } static public class ClassNotFound extends UnknownObject { public ClassNotFound(String className) { super(className); } public String getMessage() { return "Class not found: " + name; } } abstract static public class Scope { public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithIdentifierOpt(String t, boolean inner) { return null; } public GazelleV_LeftArrowScript.Evaluable completeAssignmentOpt(String lhs, GazelleV_LeftArrowScript.Evaluable rhs) { return null; } } public class ClassDefScope extends Scope implements IFieldsToList { public LASClassDef classDef; public ClassDefScope() { } public ClassDefScope(LASClassDef classDef) { this.classDef = classDef; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + classDef + ")"; } public boolean equals(Object o) { if (!(o instanceof ClassDefScope)) return false; ClassDefScope __0 = (ClassDefScope) o; return eq(classDef, __0.classDef); } public int hashCode() { int h = -1760310585; h = boostHashCombine(h, _hashCode(classDef)); return h; } public Object[] _fieldsToList() { return new Object[] { classDef }; } public GazelleV_LeftArrowScript.Evaluable getThis() { return new GazelleV_LeftArrowScript.GetVar("this"); } public GazelleV_LeftArrowScript.Evaluable parseExprStartingWithIdentifierOpt(String t, boolean inner) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("ClassDefScope.parseExprStartingWithIdentifierOpt", "t", t); return linkToSrc(() -> { var field = classDef.fieldsByName.get(t); if (field != null) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Found field " + field); var e = inner ? new GazelleV_LeftArrowScript.GetField(getThis(), field.name) : new GazelleV_LeftArrowScript.CallMethodOrGetField(getThis(), field.name); return parseCall(inner, e); } Class superClass = typeToClass(classDef.superClass); var field2 = findFieldOfClass(superClass, t); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("field2", field2, "superClass", superClass, "t", t); if (field2 != null) { if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) print("Found field " + field2); var e = inner ? new GazelleV_LeftArrowScript.GetField(getThis(), field2.getName()) : new GazelleV_LeftArrowScript.CallMethodOrGetField(getThis(), field2.getName()); return parseCall(inner, e); } if (!inner && (classDef.methodsByName.containsKey(t) || classHasMethodNamed(typeToClass(classDef.superClass), t))) { return new GazelleV_LeftArrowScript.CallMethod(getThis(), t, parseArguments()); } return null; }); } public GazelleV_LeftArrowScript.Evaluable completeAssignmentOpt(String lhs, GazelleV_LeftArrowScript.Evaluable rhs) { var field = classDef.fieldsByName.get(lhs); if (field != null) return new GazelleV_LeftArrowScript.SetField(getThis(), lhs, rhs); Class superClass = typeToClass(classDef.superClass); var field2 = findFieldOfClass(superClass, lhs); if (field2 != null) return new GazelleV_LeftArrowScript.SetField(getThis(), lhs, rhs); return null; } } public LASClassDef parseClassDef() { return linkToSrc(() -> { consume("class"); LASClassDef classDef = new LASClassDef(); classDef.verbose(scaffoldingEnabled()); if (nempty(classDefPrefix)) classDef.classDefPrefix(classDefPrefix); String name = consumeIdentifier(); classDef.userGivenName(name); classDefs.put(name, classDef); AutoCloseable __17 = tempMapPut(classDefs, "selfType", classDef); try { if (consumeOpt("extends")) { classDef.superClass(parseType()); } if (consumeOpt("is")) classDef.interfaces.add(parseType()); consume("{"); AutoCloseable __18 = tempAddKnownVar("this", new LASValueDescriptor.NonExactType(classDef.resolvable(lasClassLoader), false)); try { AutoCloseable __19 = !objectScopesEnabled ? null : tempScope(new ClassDefScope(classDef)); try { while (!is("}")) { if (is(";")) { next(); continue; } if (is("def")) { GazelleV_LeftArrowScript.FunctionDef fd = parseFunctionDefinition(null); if (GazelleV_LeftArrowScriptParser.this.scaffoldingEnabled()) printVars("knownVarsAfterFunctionDef", knownVars); classDef.addMethod(fd); continue; } var start = ptr(); if (consumeOpt("ctor")) { var fd = parseFunctionDefinition_step2(null, start, ""); fd.returnType(void.class); classDef.addMethod(fd); continue; } if (consumeOpt("initializer")) { classDef.initializers.add(parseCurlyBlock()); continue; } LASClassDef.FieldDef fd = new LASClassDef.FieldDef(); while (isOneOf("transient", "static")) { fd.addModifier(tpp()); } fd.name(consumeIdentifier()); var type = parseColonType(); fd.type(type); if (consumeLeftArrowOpt()) fd.initializer(parseExpr()); classDef.addField(fd); } consume("}"); return classDef; } finally { _close(__19); } } finally { _close(__18); } } finally { _close(__17); } }); } public Type parseColonTypeOpt() { if (is(":")) return parseColonType(); return null; } public Type parseColonType() { consume(":"); return parseType(); } public Type findType(String typeName) { LASClassDef cd = classDefs.get(typeName); if (cd != null) return cd.resolvable(lasClassLoader); Object o = findExternalObject(typeName); if (o instanceof Class) return ((Class) o); throw new ClassNotFound(typeName); } public Type parseType() { String typeName = consumeIdentifier(); Type type = findType(typeName); return parseArrayType(parseTypeArguments(type)); } public Type parseArrayType(Type type) { while (is("[") && is(1, "]")) { consume(2); type = new GenericArrayTypeImpl(type); } return type; } final public Type parseTypeArgumentsOpt(Type type) { return parseTypeArguments(type); } public Type parseTypeArguments(Type type) { if (is("<") && empty(nextSpace()) && isIdentifier(token(1))) { next(); List args = new ArrayList(); while (true) { args.add(parseType()); if (is(">")) break; consume(","); } consume(">"); if (type != null) type = new ParameterizedTypeImpl(null, type, toTypedArray(Type.class, args)); } return type; } transient public IF1 classForName; public Class classForName(String name) { return classForName != null ? classForName.get(name) : classForName_base(name); } final public Class classForName_fallback(IF1 _f, String name) { return _f != null ? _f.get(name) : classForName_base(name); } public Class classForName_base(String name) { try { return Class.forName(name); } catch (Exception __e) { throw rethrow(__e); } } public void copyFunctionContainersFrom(GazelleV_LeftArrowScriptParser parser) { functionContainers = cloneList(parser.functionContainers); globalClassNames_cache = parser.globalClassNames(); isBlockedFunctionContainerMethod = parser.isBlockedFunctionContainerMethod; } public ClassNameResolver classNameResolver() { if (classNameResolver == null) classNameResolver = new ClassNameResolver().byteCodePath(assertNotNull(getBytecodePathForClass(this))).init(); return classNameResolver; } public GazelleV_LeftArrowScriptParser classNameResolver(ClassNameResolver classNameResolver) { this.classNameResolver = classNameResolver; return this; } public GazelleV_LeftArrowScript.Evaluable parseStringLiteral() { return _const(unquote_relaxedMLS(consume())); } public void addFunctionDefs(Map map) { putAll(functionDefs, map); } public GazelleV_LeftArrowScriptParser setFlag(String flag) { flags.add(flag); return this; } public boolean getFlag(String flag) { return flags.contains(flag); } public void noImports() { importedPackages = () -> null; importedClasses = () -> null; classShortcuts = () -> null; } static public class TypedVar implements IFieldsToList { public String name; public LASValueDescriptor type; public TypedVar() { } public TypedVar(String name, LASValueDescriptor type) { this.type = type; this.name = name; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + name + ", " + type + ")"; } public boolean equals(Object o) { if (!(o instanceof TypedVar)) return false; TypedVar __22 = (TypedVar) o; return eq(name, __22.name) && eq(type, __22.type); } public int hashCode() { int h = -611218819; h = boostHashCombine(h, _hashCode(name)); h = boostHashCombine(h, _hashCode(type)); return h; } public Object[] _fieldsToList() { return new Object[] { name, type }; } } } static public class G22LeftArrowScript extends G22Text { static final public String _fieldOrder = "clearedForAutoRun runOnProjectOpen runOrder runCount lastResultByMode supercededBy metaCode compileResultForAutoRun compileResultForSaved compileResultForEditing"; public transient FieldVar> varClearedForAutoRun_cache; public FieldVar> varClearedForAutoRun() { if (varClearedForAutoRun_cache == null) varClearedForAutoRun_cache = varClearedForAutoRun_load(); return varClearedForAutoRun_cache; } public FieldVar> varClearedForAutoRun_load() { return new FieldVar>(this, "clearedForAutoRun", () -> clearedForAutoRun(), clearedForAutoRun -> clearedForAutoRun(clearedForAutoRun)); } final public G22LeftArrowScript setClearedForAutoRun(ClearForAutoRun clearedForAutoRun) { return clearedForAutoRun(clearedForAutoRun); } public G22LeftArrowScript clearedForAutoRun(ClearForAutoRun clearedForAutoRun) { if (!eq(this.clearedForAutoRun, clearedForAutoRun)) { this.clearedForAutoRun = clearedForAutoRun; change(); } return this; } final public ClearForAutoRun getClearedForAutoRun() { return clearedForAutoRun(); } public ClearForAutoRun clearedForAutoRun() { return clearedForAutoRun; } public ClearForAutoRun clearedForAutoRun; public transient FieldVar varRunOnProjectOpen_cache; public FieldVar varRunOnProjectOpen() { if (varRunOnProjectOpen_cache == null) varRunOnProjectOpen_cache = varRunOnProjectOpen_load(); return varRunOnProjectOpen_cache; } public FieldVar varRunOnProjectOpen_load() { return new FieldVar(this, "runOnProjectOpen", () -> runOnProjectOpen(), runOnProjectOpen -> runOnProjectOpen(runOnProjectOpen)); } final public G22LeftArrowScript setRunOnProjectOpen(boolean runOnProjectOpen) { return runOnProjectOpen(runOnProjectOpen); } public G22LeftArrowScript runOnProjectOpen(boolean runOnProjectOpen) { if (!eq(this.runOnProjectOpen, runOnProjectOpen)) { this.runOnProjectOpen = runOnProjectOpen; change(); } return this; } final public boolean getRunOnProjectOpen() { return runOnProjectOpen(); } public boolean runOnProjectOpen() { return runOnProjectOpen; } public boolean runOnProjectOpen = false; public transient FieldVar varRunOrder_cache; public FieldVar varRunOrder() { if (varRunOrder_cache == null) varRunOrder_cache = varRunOrder_load(); return varRunOrder_cache; } public FieldVar varRunOrder_load() { return new FieldVar(this, "runOrder", () -> runOrder(), runOrder -> runOrder(runOrder)); } final public G22LeftArrowScript setRunOrder(String runOrder) { return runOrder(runOrder); } public G22LeftArrowScript runOrder(String runOrder) { if (!eq(this.runOrder, runOrder)) { this.runOrder = runOrder; change(); } return this; } final public String getRunOrder() { return runOrder(); } public String runOrder() { return runOrder; } public String runOrder; public long runCount; public Map>> lastResultByMode; public Ref supercededBy = new Ref(); public transient FieldVar varMetaCode_cache; public FieldVar varMetaCode() { if (varMetaCode_cache == null) varMetaCode_cache = varMetaCode_load(); return varMetaCode_cache; } public FieldVar varMetaCode_load() { return new FieldVar(this, "metaCode", () -> metaCode(), metaCode -> metaCode(metaCode)); } final public G22LeftArrowScript setMetaCode(String metaCode) { return metaCode(metaCode); } public G22LeftArrowScript metaCode(String metaCode) { if (!eq(this.metaCode, metaCode)) { this.metaCode = metaCode; change(); } return this; } final public String getMetaCode() { return metaCode(); } public String metaCode() { return metaCode; } public String metaCode; public void _doneLoading2() { super._doneLoading2(); cMigrateField(this, "code", "text"); } public String toString() { if (empty(description)) return myType() + " " + id; else return "Script " + id + ": " + description; } public boolean isSavedDistinctFromAutoRunVersion() { return isSaved() && !eq(text, codeForAutoRun()); } public boolean isClearForAutoRun() { return clearedForAutoRun != null; } public String codeForAutoRun() { return getVar(clearedForAutoRun()); } public String safestCode() { return or(codeForAutoRun(), stableText()); } public void clearForAutoRun() { if (!isSaved()) return; String text = text(); saveFieldToHistory("Auto-runnable code", text); clearedForAutoRun(new ClearForAutoRun(text)); } public void forgetAutoRunCode() { if (!isClearForAutoRun()) return; saveFieldToHistory("Auto-runnable code", null); clearedForAutoRun(null); compileResultForAutoRun = null; } public void forgetCompileResults() { compileResultForAutoRun = compileResultForSaved = null; } public GazelleV_LeftArrowScriptParser makeParser() { return g22utils().leftArrowParser().sourceInfo(this); } public LASCompileResult newCompileResult() { return new LASCompileResult(); } public LASCompileResult returnOrCompile(LASCompileResult lastCompileResult, String code) { if (g22utils().compileResultValid(lastCompileResult, code)) return lastCompileResult; var cr = newCompileResult(); cr.script(code); var parser = makeParser(); cr.parser(parser); cr.compile(); return cr; } transient public LASCompileResult compileResultForAutoRun; public LASCompileResult compileForAutoRun() { String code = codeForAutoRun(); if (code == null) return null; var cr = returnOrCompile(compileResultForAutoRun, code); return compileResultForAutoRun = cr; } transient public LASCompileResult compileResultForSaved; public LASCompileResult compileSaved() { String code = stableText(); if (code == null) return null; var cr = returnOrCompile(compileResultForSaved, code); return compileResultForSaved = cr; } transient public LASCompileResult compileResultForEditing; public LASCompileResult compileEditing() { String code = editingText(); if (code == null) return null; var cr = returnOrCompile(compileResultForEditing, code); return compileResultForEditing = cr; } public LASCompileResult safestCompileResult() { { var __1 = compileForAutoRun(); if (__1 != null) return __1; } return compileSaved(); } public LASCompileResult latestCompileResult() { { var __2 = compileEditing(); if (__2 != null) return __2; } { var __3 = compileSaved(); if (__3 != null) return __3; } return compileForAutoRun(); } public LASCompileResult latestRunnableCompileResult() { var cr = compileEditing(); if (cr != null && cr.runnable()) return cr; cr = compileSaved(); if (cr != null && cr.runnable()) return cr; cr = compileForAutoRun(); if (cr != null && cr.runnable()) return cr; return null; } public Object evaluateWithoutTimeout() { var cr = safestCompileResult(); if (cr == null) throw fail("Not saved: " + this); AutoCloseable __4 = g22utils().enter(); try { return cr.parsedScriptMandatory().get(); } finally { _close(__4); } } public Object evaluateAutoRunWithoutTimeout() { var cr = compileForAutoRun(); if (cr == null) throw fail("Not cleared for auto-run: " + this); AutoCloseable __5 = g22utils().enter(); try { return cr.parsedScriptMandatory().get(); } finally { _close(__5); } } public String renderRunOnProjectOpenStatus() { return runOnProjectOpen ? "Yes" + appendBracketed(appendPrefixIfNempty("prio ", runOrder)) : null; } public Set allTexts() { return addAndReturnCollection(super.allTexts(), codeForAutoRun()); } } static public class G22RegionThinner_v2 implements Steppable, IFieldsToList { public IImageRegion originalRegion; public G22RegionThinner_v2() { } public G22RegionThinner_v2(IImageRegion originalRegion) { this.originalRegion = originalRegion; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + originalRegion + ")"; } public Object[] _fieldsToList() { return new Object[] { originalRegion }; } public Rect bounds; public IImageRegion region; public boolean phase1done = false; final public G22RegionThinner_v2 setDebug(boolean debug) { return debug(debug); } public G22RegionThinner_v2 debug(boolean debug) { this.debug = debug; return this; } final public boolean getDebug() { return debug(); } public boolean debug() { return debug; } public boolean debug = false; final public G22RegionThinner_v2 setDoFinalStep(boolean doFinalStep) { return doFinalStep(doFinalStep); } public G22RegionThinner_v2 doFinalStep(boolean doFinalStep) { this.doFinalStep = doFinalStep; return this; } final public boolean getDoFinalStep() { return doFinalStep(); } public boolean doFinalStep() { return doFinalStep; } public boolean doFinalStep = true; final public G22RegionThinner_v2 setLastPhaseThreshold1(int lastPhaseThreshold1) { return lastPhaseThreshold1(lastPhaseThreshold1); } public G22RegionThinner_v2 lastPhaseThreshold1(int lastPhaseThreshold1) { this.lastPhaseThreshold1 = lastPhaseThreshold1; return this; } final public int getLastPhaseThreshold1() { return lastPhaseThreshold1(); } public int lastPhaseThreshold1() { return lastPhaseThreshold1; } public int lastPhaseThreshold1 = 2; final public G22RegionThinner_v2 setLastPhaseThreshold(int lastPhaseThreshold) { return lastPhaseThreshold(lastPhaseThreshold); } public G22RegionThinner_v2 lastPhaseThreshold(int lastPhaseThreshold) { this.lastPhaseThreshold = lastPhaseThreshold; return this; } final public int getLastPhaseThreshold() { return lastPhaseThreshold(); } public int lastPhaseThreshold() { return lastPhaseThreshold; } public int lastPhaseThreshold = 5; final public G22RegionThinner_v2 setLookupTable(byte[] lookupTable) { return lookupTable(lookupTable); } public G22RegionThinner_v2 lookupTable(byte[] lookupTable) { this.lookupTable = lookupTable; return this; } final public byte[] getLookupTable() { return lookupTable(); } public byte[] lookupTable() { return lookupTable; } public byte[] lookupTable; public byte[] pixels; public int idx(int x, int y) { return (y - bounds.y) * bounds.w + x - bounds.x; } public int idx(Pt p) { return idx(p.x, p.y); } public Pt idxToPt(int idx) { return pt(bounds.x + (idx % bounds.w), bounds.y + idx / bounds.w); } public byte getPixel(long p) { return getPixel(firstIntFromLong(p), secondIntFromLong(p)); } public byte getPixel(Pt p) { return !containsPt(bounds, p) ? 0 : pixels[idx(p)]; } public byte getPixel(int x, int y) { return !containsPt(bounds, x, y) ? 0 : pixels[idx(x, y)]; } public boolean contains(int x, int y) { return getPixel(x, y) != 0; } public boolean clearPixel(int x, int y) { if (!region.contains(x, y)) return false; pixels[idx(x, y)] = 0; return true; } public void init() { if (bounds != null) return; bounds = originalRegion.bounds(); pixels = new byte[area(bounds)]; for (Pt p : originalRegion.pixelIterator()) pixels[idx(p.x, p.y)] = 1; region = new ThinnedRegion(); } public class ThinnedRegion implements IImageRegion { public Img image() { return originalRegion.image(); } public Rect bounds() { return bounds; } public boolean contains(int x, int y) { return containsPt(bounds, x, y) && pixels[idx(x, y)] > 0; } public IterableIterator pixelIterator() { return iff_null(new IF0() { public int idx = 0; public Pt get() { for (; idx < pixels.length; idx++) if (pixels[idx] > 0) return idxToPt(idx++); return null; } }); } } public boolean step() { init(); if (phase1done) return finalStep(); List traces = g22_allBorderTraces_withDiagonals(region); for (var points : traces) for (var p : points) pixels[idx(p)] = 2; PtBuffer toDelete = new PtBuffer(); for (var points : traces) { int nPoints = l(points); BitSet deletable = emptyBitSet(nPoints); for (int i = 0; i < nPoints; i++) { boolean del = deletableBorderPoint(points, i); if (del) deletable.set(i); } for (int i = 0; i < nPoints; i++) if (cyclicGet(deletable, nPoints, i - 1) && !deletable.get(i) && cyclicGet(deletable, nPoints, i + 1)) { Pt p = points.get(i); Pt prev = ptMinus(cyclicGet(points, i - 1), p); Pt next = ptMinus(cyclicGet(points, i + 1), p); int dir1 = onePathLookupDirection(prev); int dir2 = onePathLookupDirection(next); int diff = mod(dir2 - dir1, 8); if (debug) printVars("special case", "p", p, "prev", prev, "next", next, "dir1", dir1, "dir2", dir2, "diff", diff); if (diff == 1 || diff == 7) deletable.set(i); } for (int i = 0; i < nPoints; i++) if (deletable.get(i)) toDelete.add(points.get(i)); } for (var p : toDelete) pixels[idx(p)] = 0; if (empty(toDelete)) phase1done = true; return true; } public boolean deletableBorderPoint(PtBuffer points, int i) { LongBuffer pointsBuf = points.buf; long p_long = pointsBuf.get(i); if (p_long == cyclicGet(pointsBuf, i - 2) || p_long == cyclicGet(pointsBuf, i + 2)) { return false; } int surroundingInnerPixels = 0; int foreignBorderPixels = 0; for (int dir = 1; dir <= 8; dir++) { long p2_long = onePathDirection_long(p_long, dir); byte value = getPixel(p2_long); if (value == 2 && !rangeContains(pointsBuf, i, p2_long)) { boolean fix = dir == 5 || dir == 7; if (!fix) return false; } else if (value == 1) { surroundingInnerPixels++; } } boolean deletable = surroundingInnerPixels > 0; int imgPattern = neighborhoodPattern(firstIntFromLong(p_long), secondIntFromLong(p_long)); if (imgPattern == 0b10011100 || imgPattern == 0b01000111 || imgPattern == 0b00111001 || imgPattern == 0b00111111 || imgPattern == 0b10111101) deletable = false; else if (imgPattern == 0b11010110) deletable = true; return deletable; } public boolean rangeContains(LongBuffer pointsBuf, int i, long p2_long) { for (int j = i - 3; j <= i + 3; j++) if (cyclicGet(pointsBuf, j) == p2_long) return true; return false; } public boolean deletableBorderPoint_old(PtBuffer points, int i) { List range = cyclicSubList_incl(points, i - 3, i + 3); Pt p = points.get(i); if (eq(range.get(1), p) || eq(range.get(5), p)) return false; int surroundingBorderPixels = 0, surroundingInnerPixels = 0; for (int dir = 1; dir <= 8; dir++) { Pt p2 = ptPlus(p, onePathDirection(dir)); byte value = getPixel(p2); if (value == 2 && !range.contains(p2)) surroundingBorderPixels++; else if (value == 1) surroundingInnerPixels++; } boolean deletable = surroundingInnerPixels > 0 && surroundingBorderPixels == 0; return deletable; } final public IImageRegion get() { return region(); } public IImageRegion region() { return or(region, originalRegion); } public boolean finalStep() { if (!doFinalStep) return false; if (lookupTable == null) lookupTable = new G22RegionThinner_LookupTable().lastPhaseThreshold(lastPhaseThreshold).lastPhaseThreshold1(lastPhaseThreshold1).get(); boolean change = false; int x1 = bounds.x, x2 = bounds.x2(); int y1 = bounds.y, y2 = bounds.y2(); var pingSource = pingSource(); for (int y = y1; y < y2; y++) { ping(pingSource); for (int x = x1; x < x2; x++) { if (!contains(x, y)) continue; int imgPattern = neighborhoodPattern(x, y); boolean delete = getBit(lookupTable, imgPattern); if (delete) change |= clearPixel(x, y); } } return change; } public int neighborhoodPattern(int x, int y) { return ubyteFromBits(contains(x - 1, y - 1), contains(x, y - 1), contains(x + 1, y - 1), contains(x - 1, y), contains(x + 1, y), contains(x - 1, y + 1), contains(x, y + 1), contains(x + 1, y + 1)); } } static public class DoubleMinMax { public double min = Double.NaN, max = Double.NaN; public boolean isEmpty() { return isNaN(min); } public void add(double d) { if (isNaN(min) || d < min) min = d; if (isNaN(max) || d > max) max = d; } public double rangeLength() { return max - min; } public String toString() { return renderVars("min", min, "max", max); } public DoubleRange range() { return isEmpty() ? null : doubleRange(min, max); } } static public class PStack implements Steppable { public PStack() { } final public PStack setScheduler(ProbabilisticScheduler scheduler) { return scheduler(scheduler); } public PStack scheduler(ProbabilisticScheduler scheduler) { this.scheduler = scheduler; return this; } final public ProbabilisticScheduler getScheduler() { return scheduler(); } public ProbabilisticScheduler scheduler() { return scheduler; } public ProbabilisticScheduler scheduler = new ProbabilisticScheduler(); final public PStack setVerbose(boolean verbose) { return verbose(verbose); } public PStack verbose(boolean verbose) { this.verbose = verbose; return this; } final public boolean getVerbose() { return verbose(); } public boolean verbose() { return verbose; } public boolean verbose = false; static public class NoOptionsException extends RuntimeException { } public PStack(VStack.Computable computable) { add(computable); } static public class ExecuteOption implements VStack.Computable, IFieldsToList { public IVF1 option; public ExecuteOption() { } public ExecuteOption(IVF1 option) { this.option = option; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + option + ")"; } public Object[] _fieldsToList() { return new Object[] { option }; } public void step(VStack stack, Object subComputationResult) { Object target = stack.caller(); stack._return(); option.get(target); } } public class SingleStack extends VStack implements IPStack, Runnable { public double probability = 1.0; public SingleStack() { } public SingleStack(VStack.Computable computable) { super(computable); } public void run() { try { if (verbose) print("Stepping " + last(stack)); if (step() && !isEmpty()) { if (verbose) print("Re-scheduling at " + probability + ": " + last(stack)); scheduler.add(probability, this); } } catch (Exception __e) { throw rethrow(__e); } } public void options(B function, Iterable> options) { List> optionsList = nonNulls(options); if (empty(optionsList)) throw new NoOptionsException(); probability = probability / l(optionsList); int n = l(optionsList) - 1; for (int i = 0; i < n; i++) { SingleStack s = new SingleStack(); s.stack = shallowCloneElements(stack); s.push(new ExecuteOption(optionsList.get(i))); s.probability = probability; scheduler.at(probability, s); } push(new ExecuteOption(last(optionsList))); } public void probabilisticOptions(B currentFrame, Iterable>> options) { List>> optionsList = nonNulls(options); if (empty(optionsList)) throw new NoOptionsException(); int n = l(optionsList) - 1; for (int i = 0; i < n; i++) { SingleStack s = new SingleStack(); s.stack = shallowCloneElements(stack); var option = optionsList.get(i); s.push(new ExecuteOption(option.get())); s.probability = probability * option.probability(); scheduler.at(s.probability, s); } var option = last(optionsList); probability *= option.probability(); push(new ExecuteOption(option.get())); } } static public class FollowUp extends PStackComputableWithStep implements IFieldsToList { public VStack.Computable computable; public IVF1 onCompletion; public FollowUp() { } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + computable + ", " + onCompletion + ")"; } public Object[] _fieldsToList() { return new Object[] { computable, onCompletion }; } public FollowUp(VStack.Computable computable, IVF1 onCompletion) { this.onCompletion = onCompletion; this.computable = computable; probability = getProbability(computable); } public void step(IPStack stack) { if (step == 0) { stack.push(computable); ++step; } else { onCompletion.get((A) stack.subResult()); stack._return(); } } } public void add(VStack.Computable computable) { scheduler.at(getProbability(computable), new SingleStack(computable)); } public void add(VStack.Computable computable, IVF1 onCompletion) { if (onCompletion != null) add(new FollowUp<>(computable, onCompletion)); else add(computable); } public boolean step() { return scheduler.step(); } public void run() { scheduler.run(); } public void run(VStack.Computable computable) { add(computable); run(); } public void runWithStats() { scheduler.runWithStats(); } public void runWithStats(VStack.Computable computable) { add(computable); runWithStats(); } static public double getProbability(VStack.Computable computable) { return computable instanceof PStackComputable ? ((PStackComputable) computable).probability : 1.0; } } static public class Chaser extends G22TradingStrategy { static final public String _fieldOrder = "maxPositionHours maxLoss pullback relativePullback minPullback maxPullback opener lastDirection rlc openSignal"; final public Chaser setMaxPositionHours(double maxPositionHours) { return maxPositionHours(maxPositionHours); } public Chaser maxPositionHours(double maxPositionHours) { this.maxPositionHours = maxPositionHours; return this; } final public double getMaxPositionHours() { return maxPositionHours(); } public double maxPositionHours() { return maxPositionHours; } public double maxPositionHours = 4; final public Chaser setMaxLoss(double maxLoss) { return maxLoss(maxLoss); } public Chaser maxLoss(double maxLoss) { this.maxLoss = maxLoss; return this; } final public double getMaxLoss() { return maxLoss(); } public double maxLoss() { return maxLoss; } public double maxLoss = 0.6; final public Chaser setPullback(double pullback) { return pullback(pullback); } public Chaser pullback(double pullback) { this.pullback = pullback; return this; } final public double getPullback() { return pullback(); } public double pullback() { return pullback; } public double pullback = 0.4; final public Chaser setRelativePullback(double relativePullback) { return relativePullback(relativePullback); } public Chaser relativePullback(double relativePullback) { this.relativePullback = relativePullback; return this; } final public double getRelativePullback() { return relativePullback(); } public double relativePullback() { return relativePullback; } public double relativePullback; final public Chaser setMinPullback(double minPullback) { return minPullback(minPullback); } public Chaser minPullback(double minPullback) { this.minPullback = minPullback; return this; } final public double getMinPullback() { return minPullback(); } public double minPullback() { return minPullback; } public double minPullback; final public Chaser setMaxPullback(double maxPullback) { return maxPullback(maxPullback); } public Chaser maxPullback(double maxPullback) { this.maxPullback = maxPullback; return this; } final public double getMaxPullback() { return maxPullback(); } public double maxPullback() { return maxPullback; } public double maxPullback; final public Chaser setOpener(Opener opener) { return opener(opener); } public Chaser opener(Opener opener) { this.opener = opener; return this; } final public Opener getOpener() { return opener(); } public Opener opener() { return opener; } public Opener opener; public transient FieldVar varLastDirection_cache; public FieldVar varLastDirection() { if (varLastDirection_cache == null) varLastDirection_cache = varLastDirection_load(); return varLastDirection_cache; } public FieldVar varLastDirection_load() { return new FieldVar(this, "lastDirection", () -> lastDirection(), lastDirection -> lastDirection(lastDirection)); } final public Chaser setLastDirection(int lastDirection) { return lastDirection(lastDirection); } public Chaser lastDirection(int lastDirection) { if (!eq(this.lastDirection, lastDirection)) { this.lastDirection = lastDirection; change(); } return this; } final public int getLastDirection() { return lastDirection(); } public int lastDirection() { return lastDirection; } public int lastDirection; public RunLengthCounter rlc = new RunLengthCounter(); public OpenSignal openSignal; public class CloseSignal implements IFieldsToList { public String reason; public double trigger; public CloseSignal() { } public CloseSignal(String reason, double trigger) { this.trigger = trigger; this.reason = reason; } public Object[] _fieldsToList() { return new Object[] { reason, trigger }; } public double trigger() { return trigger; } public String toString() { return "Close signal " + reason + " (" + iround(trigger * 100) + "%)"; } } public class OpenSignal implements IFieldsToList { public String reason; public double trigger; public int direction; public OpenSignal() { } public OpenSignal(String reason, double trigger, int direction) { this.direction = direction; this.trigger = trigger; this.reason = reason; } public Object[] _fieldsToList() { return new Object[] { reason, trigger, direction }; } public double trigger() { return trigger; } public String toString() { return "Open signal " + reason + " (" + iround(trigger * 100) + "%)"; } } public class BaseJuicer { public BaseJuicer() { } final public BaseJuicer setMaxLoss(double maxLoss) { return maxLoss(maxLoss); } public BaseJuicer maxLoss(double maxLoss) { this.maxLoss = maxLoss; return this; } final public double getMaxLoss() { return maxLoss(); } public double maxLoss() { return maxLoss; } public double maxLoss; public List closeSignals(Position p) { List signals = new ArrayList(); double profit = p.profitBeforeLeverage(); if (p.maxClosingTime() < infinity()) signals.add(new CloseSignal("Age", transformToZeroToOne(currentTime(), p.openingTime(), p.maxClosingTime()))); if (profit < 0) signals.add(new CloseSignal("Loss", doubleRatio(-profit, maxLoss))); return signals; } } public class Juicer extends BaseJuicer { public Juicer() { } final public Juicer setPullback(double pullback) { return pullback(pullback); } public Juicer pullback(double pullback) { this.pullback = pullback; return this; } final public double getPullback() { return pullback(); } public double pullback() { return pullback; } public double pullback; public Juicer(double maxLoss, double pullback) { this.pullback = pullback; this.maxLoss = maxLoss; } public String toString() { return renderRecord("Juicer", "maxLoss", maxLoss, "pullback", pullback); } public List closeSignals(Position p) { List signals = super.closeSignals(p); double profit = p.profitBeforeLeverage(); if (profit >= 0) signals.add(new CloseSignal("Profit", transformToZeroToOne(profit, p.crest, p.crest - pullback))); return signals; } } public class RelativePullbackJuicer extends BaseJuicer { public RelativePullbackJuicer() { } final public RelativePullbackJuicer setRelativePullback(double relativePullback) { return relativePullback(relativePullback); } public RelativePullbackJuicer relativePullback(double relativePullback) { this.relativePullback = relativePullback; return this; } final public double getRelativePullback() { return relativePullback(); } public double relativePullback() { return relativePullback; } public double relativePullback; final public RelativePullbackJuicer setMinPullback(double minPullback) { return minPullback(minPullback); } public RelativePullbackJuicer minPullback(double minPullback) { this.minPullback = minPullback; return this; } final public double getMinPullback() { return minPullback(); } public double minPullback() { return minPullback; } public double minPullback; final public RelativePullbackJuicer setMaxPullback(double maxPullback) { return maxPullback(maxPullback); } public RelativePullbackJuicer maxPullback(double maxPullback) { this.maxPullback = maxPullback; return this; } final public double getMaxPullback() { return maxPullback(); } public double maxPullback() { return maxPullback; } public double maxPullback; public String toString() { return renderRecord("RelativePullbackJuicer", "maxLoss", maxLoss, "relativePullback", relativePullback, "minPullback", minPullback, "maxPullback", maxPullback); } public List closeSignals(Position p) { List signals = super.closeSignals(p); double profit = p.profitBeforeLeverage(); if (profit >= 0) signals.add(new CloseSignal("Profit", transformToZeroToOne(profit, p.crest, p.crest - calculatePullback(p.crest)))); return signals; } public double calculatePullback(double crest) { return clamp(relativePullback / 100 * crest, minPullback, maxPullback); } } abstract static public class Opener { abstract public OpenSignal openSignal(); abstract public Opener cloneInto(Chaser strat); } public class PreRunOpener extends Opener implements IFieldsToList { public int minRunUp; public int minRunDown; public PreRunOpener() { } public PreRunOpener(int minRunUp, int minRunDown) { this.minRunDown = minRunDown; this.minRunUp = minRunUp; } public boolean equals(Object o) { if (!(o instanceof PreRunOpener)) return false; PreRunOpener __0 = (PreRunOpener) o; return minRunUp == __0.minRunUp && minRunDown == __0.minRunDown; } public int hashCode() { int h = 1447043999; h = boostHashCombine(h, _hashCode(minRunUp)); h = boostHashCombine(h, _hashCode(minRunDown)); return h; } public Object[] _fieldsToList() { return new Object[] { minRunUp, minRunDown }; } public Opener cloneInto(Chaser strat) { return strat.new PreRunOpener(minRunUp, minRunDown); } public OpenSignal openSignal() { int direction = Chaser.this.direction; if (direction == 0) return null; int preRun = direction > 1 ? minRunUp : minRunDown; int runLength = toInt(rlc.runLength()); return new OpenSignal("RunLength " + runLength, doubleRatio(runLength, preRun), direction); } public String toString() { return "PreRunOpener up " + minRunUp + ", down " + minRunDown; } } public class Position extends G22TradingStrategy.Position { public Position() { } final public Position setOpenSignal(OpenSignal openSignal) { return openSignal(openSignal); } public Position openSignal(OpenSignal openSignal) { this.openSignal = openSignal; return this; } final public OpenSignal getOpenSignal() { return openSignal(); } public OpenSignal openSignal() { return openSignal; } public OpenSignal openSignal; final public Position setJuicer(BaseJuicer juicer) { return juicer(juicer); } public Position juicer(BaseJuicer juicer) { this.juicer = juicer; return this; } final public BaseJuicer getJuicer() { return juicer(); } public BaseJuicer juicer() { return juicer; } public BaseJuicer juicer; public double crest = -infinity(); public double maxClosingTime() { return usingLiveData ? infinity() : openingTime() + hoursToMS(maxPositionHours); } public List closeSignals() { return juicer == null ? null : juicer.closeSignals(this); } public double closeSignal() { CloseSignal strongestSignal = closeSignalWithDescription(); return strongestSignal == null ? 0 : strongestSignal.trigger; } public CloseSignal closeSignalWithDescription() { return highestBy(closeSignals(), signal -> signal.trigger); } public void update() { crest = max(crest, profitBeforeLeverage()); } public String toString() { var closeSignal = closed() ? null : closeSignalWithDescription(); return commaCombine(super.toString(), closeSignal); } } public List status() { return listCombine(commaCombine("Max loss: " + formatDouble3(maxLoss) + "%", relativePullback == 0 ? "pullback: " + formatDouble3(pullback) + "%" : commaCombine("relative pullback: " + formatDouble3(relativePullback) + "%", "min pullback: " + formatDouble3(minPullback) + "%", "max pullback: " + formatDouble3(maxPullback) + "%")), "Opener: " + opener, "Run length: " + signToUpDown(unnull(rlc.value())) + " " + rlc.runLength(), openSignal, super.status()); } public Position openPosition(OpenSignal openSignal) { int direction = openSignal.direction; if (l(positionsInDirection(direction)) > 0) { return null; } nextStep(); Position p = new Position(); p.openSignal(openSignal); p.juicer(makeJuicer()); return openPosition(p, direction); } public BaseJuicer makeJuicer() { if (relativePullback != 0) return new RelativePullbackJuicer().relativePullback(relativePullback).minPullback(minPullback).maxPullback(maxPullback).maxLoss(maxLoss); else return new Juicer(maxLoss, pullback); } public void start() { if (started()) throw fail("Already started"); if (currentPrice() == 0) { primed(true); return; } startingPrice = currentPrice(); var priceCells = makePriceCells(startingPrice); digitizer = new PriceDigitizer2(priceCells); digitizer.verbose(verbose); log("Starting CHASER at " + startingPrice + " +/- " + cellSize); } public void price(double price) { if (currentPrice == price) return; currentPrice = price; if (!started()) { if (primed) { primed(false); start(); nextStep(); beforeStep(); afterStep(); } return; } digitizer.digitize(price); direction = sign(digitizedPrice() - lastDigitizedPrice()); if (direction != 0) lastDirection = direction; if (started()) step(); } transient public Runnable step; public void step() { if (step != null) step.run(); else step_base(); } final public void step_fallback(Runnable _f) { if (_f != null) _f.run(); else step_base(); } public void step_base() { for (var p : openPositions()) { ((Position) p).update(); } List toClose = new ArrayList(); for (var p : openPositions()) { CloseSignal signal = ((Position) p).closeSignalWithDescription(); if (signal != null && signal.trigger() >= 1) { ((Position) p).closeReason(signal); log("Closing position because " + signal + ": " + ((Position) p)); toClose.add((Position) p); } } if (nempty(toClose)) { nextStep(); closePositions(toClose); afterStep(); } beforeStep(); double p1 = lastDigitizedPrice(); double p2 = digitizedPrice(); direction = sign(p2 - p1); if (direction != 0) rlc.add(direction); if (haveBackData()) { openSignal = makeOpenSignal(); if (openSignal != null && openSignal.trigger >= 1) openPosition(openSignal); afterStep(); } } transient public IF0 makeOpenSignal; public OpenSignal makeOpenSignal() { return makeOpenSignal != null ? makeOpenSignal.get() : makeOpenSignal_base(); } final public OpenSignal makeOpenSignal_fallback(IF0 _f) { return _f != null ? _f.get() : makeOpenSignal_base(); } public OpenSignal makeOpenSignal_base() { return opener == null ? null : opener.openSignal(); } transient public Runnable beforeStep; public void beforeStep() { if (beforeStep != null) beforeStep.run(); else beforeStep_base(); } final public void beforeStep_fallback(Runnable _f) { if (_f != null) _f.run(); else beforeStep_base(); } public void beforeStep_base() { } public String baseToString() { return colonCombine(_conceptID() == 0 ? "" : "Strategy " + _conceptID(), "Chaser profit " + formatMarginProfit(coinProfit())); } public String fieldsToReset() { return lines(ll(super.fieldsToReset(), "lastDirection rlc openSignal")); } public Chaser emptyClone() { Chaser strat = (Chaser) (super.emptyClone()); return strat.opener(opener == null ? null : opener.cloneInto(strat)); } public String toString() { return baseToString(); } public Chaser preRunOpener(int minRunUp, int minRunDown) { return opener(new PreRunOpener(minRunUp, minRunDown)); } } static public class G22ScreenPartsPanel extends G22CRUDAndDetailPanel { public G22ScreenPartsPanel() { } public SimpleCRUD_v2 makeCRUD() { var crud = new SimpleCRUD_v2<>(g22utils.concepts(), G22ScreenPart.class); crud.entityName = () -> "Screen part"; crud.addButton("Add all screens", runnableThread(new Runnable() { public void run() { try { addAllScreens(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "addAllScreens();"; } })); return crud; } public void addAllScreens() { uniq(g22utils.concepts(), G22ScreenPart.class, "name", "All screens", "bounds", combinedScreenBounds()); } public JComponent makeDetailView(G22ScreenPart screenPart) { var maxSize = 100; var full = combinedScreenRect(); var rect = screenPart.bounds; var scale = min(doubleRatio(maxSize, full.w()), doubleRatio(maxSize, full.h())); var image = whiteImage(iround(scale * full.w()), iround(scale * full.h())); if (rect != null) { var scaled = scaleRect(rect, scale); fillRect(image, scaled, java.awt.Color.gray); } image = addBorderToImage(image, java.awt.Color.black, 1); return g22utils.stdImageSurface(image); } public G22ScreenPartsPanel g22utils(G22Utils g22utils) { super.g22utils(g22utils); return this; } } static public class TradingCandleMaker { public TradingCandleMaker() { } final public TradingCandleMaker setCandleLength(double candleLength) { return candleLength(candleLength); } public TradingCandleMaker candleLength(double candleLength) { this.candleLength = candleLength; return this; } final public double getCandleLength() { return candleLength(); } public double candleLength() { return candleLength; } public double candleLength = 1; final public TradingCandleMaker setMaxCandles(int maxCandles) { return maxCandles(maxCandles); } public TradingCandleMaker maxCandles(int maxCandles) { this.maxCandles = maxCandles; return this; } final public int getMaxCandles() { return maxCandles(); } public int maxCandles() { return maxCandles; } public int maxCandles = Integer.MAX_VALUE; final public TradingCandleMaker setAlignment(double alignment) { return alignment(alignment); } public TradingCandleMaker alignment(double alignment) { this.alignment = alignment; return this; } final public double getAlignment() { return alignment(); } public double alignment() { return alignment; } public double alignment; public TradingCandleMaker(double candleLength) { this.candleLength = candleLength; } public List candles = syncL(); public TradingCandle currentCandle() { return last(candles); } public TradingCandle completedCandle() { return nextToLast(candles); } public boolean isEmpty() { return loadableUtils.utils.isEmpty(candles); } public Timestamp endTime() { var candle = last(candles); return candle == null ? null : candle.endTime(); } public double lastPrice() { return currentCandle().end(); } public void add(double price, long timestamp) { var ts = new Timestamp(timestamp); int safety = 0; while (currentCandle() != null) { if (safety++ >= 1000) { warn("TradingCandleMaker safety warning"); break; } Timestamp maxEnd = maxEndOfCurrentCandle(); if (!greaterOrEq(ts, maxEnd)) break; currentCandle().endTime(maxEnd); double lastPrice = lastPrice(); newCandle(); var cc = currentCandle(); cc.addValue(lastPrice, maxEnd); if (cc.projectedEndTime() == 0) cc.projectedEndTime(maxEndOfCurrentCandle().unixDate()); } if (empty(candles)) newCandle(); currentCandle().addValue(price, ts); } public void newCandle() { var c = currentCandle(); { if (c != null) c.ongoing(false).projectedEndTime(0); } candles.add(new TradingCandle().ongoing(true)); dropOldCandles(); } final public int add(TickerSequence ts) { return addTickerSequence(ts); } final public int feed(TickerSequence ts) { return addTickerSequence(ts); } public int addTickerSequence(TickerSequence ts) { int entriesProcessed = 0; Timestamp endTime = endTime(); if (endTime != null) ts = ts.subSequenceFromTimestamp(endTime().unixDate() + 1); int n = l(ts); for (int i = 0; i < n; i++) { add(ts.prices.get(i), ts.timestamps.get(i)); ++entriesProcessed; } if (!isEmpty() && ts.lastTickerEvent > currentCandle().endTime().toLong()) { add(ts.lastPrice(), ts.lastTickerEvent); ++entriesProcessed; } return entriesProcessed; } public Timestamp maxEndOfCurrentCandle() { long time = currentCandle().startTime.toLong(); long align = secondsToMS(alignment); time = roundUpTo(secondsToMS(candleLength * 60), time + align + 1) - align; return new Timestamp(time); } public void dropOldCandles() { if (l(candles) > maxCandles) removeSubList(candles, 0, l(candles) - maxCandles); } final public List get() { return candles(); } public List candles() { return cloneList(candles); } public List liveCandles() { return candles; } public List completeCandles() { synchronized (mutex()) { int startIdx = isComplete(first(candles)) ? 0 : 1; return cloneSubList(candles, startIdx, l(candles) - 1); } } public Object mutex() { return candles; } public boolean isComplete(TradingCandle candle) { return candle != null && candle.durationInSeconds() == candleLength * 60; } public String toString() { return "Candle maker " + formatDouble(candleLength) + "m, " + nCandles(candles); } public List get(TickerSequence ticker) { feed(ticker); return candles(); } public TradingCandleMaker granularity(double minutes) { return candleLength(minutes); } } static public class DynamicVStack extends DynamicStack { transient public IF0 _componentConstraints; public GridBagConstraints _componentConstraints() { return _componentConstraints != null ? _componentConstraints.get() : _componentConstraints_base(); } final public GridBagConstraints _componentConstraints_fallback(IF0 _f) { return _f != null ? _f.get() : _componentConstraints_base(); } public GridBagConstraints _componentConstraints_base() { return gridBagConstraints_vstack_1(spacing); } public GridBagConstraints _fillerConstraints() { return gridBagConstraints_vstack_rest(); } } static public class G22PointOfInterest extends ConceptWithChangeListeners { static final public String _fieldOrder = "imageMD5 pt bnpSettings source labelsText"; public String imageMD5; public Pt pt; public BlurAndPosterizeSettings bnpSettings; public String source; public String labelsText; public String toString() { return commaCombine("Point of interest " + id, labelsText); } public G22Utils g22utils() { return main.g22utils(this); } public BufferedImage image() { var img = galleryImage(); return img == null ? null : img.image(); } public G22GalleryImage galleryImage() { return g22utils().galleryImageForMD5(imageMD5); } public boolean sameImage(G22PointOfInterest otherPOI) { return otherPOI != null && eq(imageMD5, otherPOI.imageMD5); } public G22DataWrangler wrangler() { return wranglerStealingFrom(null, null); } public G22DataWrangler wranglerStealingFrom(G22PointOfInterest otherPOI, G22DataWrangler otherWrangler) { if (otherWrangler != null && !sameImage(otherPOI)) otherWrangler = null; G22DataWrangler wrangler = new G22DataWrangler(); wrangler.inputImage(otherWrangler != null ? otherWrangler.inputImage : image()); wrangler.stealingFrom(otherWrangler); wrangler.timings(g22utils().functionTimings()); wrangler.importSettings(bnpSettings); return wrangler; } public IImageRegion regionAroundPoint() { return regionAroundPoint(wrangler()); } public IImageRegion regionAroundPoint(G22DataWrangler wrangler) { var rm = wrangler.regionMaker(); return rm.getRegion(rm.regionAt(pt)); } } static public class G22MeshScrambler implements IFieldsToList { public G22Mesh mesh; public G22MeshScrambler() { } public G22MeshScrambler(G22Mesh mesh) { this.mesh = mesh; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + mesh + ")"; } public Object[] _fieldsToList() { return new Object[] { mesh }; } public G22Mesh scrambledMesh; public Map anchorMap = new HashMap(); public G22Mesh get() { scrambledMesh = new G22Mesh(); for (var a1 : shuffled(mesh.anchors())) { var a2 = scrambledMesh.newAnchor(a1.pt); anchorMap.put(a1, a2); } for (var c1 : shuffled(mesh.curves())) { boolean flip = flipCoin(); var path = flip ? c1.path.reversed() : c1.path; scrambledMesh.addCurve(new G22Mesh.Curve(anchorMap.get(c1.anchor(flip)), anchorMap.get(c1.anchor(!flip)), path)); } return scrambledMesh; } } static public class G22SelfTests implements IFieldsToList { public G22Utils g22utils; public G22SelfTests() { } public G22SelfTests(G22Utils g22utils) { this.g22utils = g22utils; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + g22utils + ")"; } public Object[] _fieldsToList() { return new Object[] { g22utils }; } volatile public boolean started = false; volatile public OKOrError result; public void run() { try { started = true; result = okOrError(() -> runImpl()); String msg = "Self Tests " + status(); if (result.isOK()) print(msg); else infoBox(msg); } catch (Exception __e) { throw rethrow(__e); } } public void runImpl() { G22LAScriptIDE.selfTest(g22utils); } public String status() { return !started ? "Not started" : result == null ? "Running" : result.isOK() ? "OK" : "Failed"; } } static public class G22Analyzer extends G22LeftArrowScript { public Ref exampleImage = new Ref(); @Override public GazelleV_LeftArrowScriptParser makeParser() { var parser = super.makeParser(); parser.addVar("image", BufferedImage.class, false); parser.addVar("imageStream", SourceTriggeredStream.class, false); parser.addVar("context", G22AnalysisContext.class, false); return parser; } public class CompiledAnalyzer extends LASCompileResult { final public CompiledAnalyzer setTimeout(double timeout) { return timeout(timeout); } public CompiledAnalyzer timeout(double timeout) { this.timeout = timeout; return this; } final public double getTimeout() { return timeout(); } public double timeout() { return timeout; } public double timeout = 10; public G22AnalysisContext createAnalysisContext(BufferedImage image) { return new G22AnalysisContext(g22utils(), image); } public Object get_impl(G22AnalysisContext context) { FlexibleVarContext ctx = new FlexibleVarContext(); ctx.set("image", context.image); ctx.set("imageStream", context.imageStream); ctx.set("context", context); return parsedScript.get(ctx); } public Object get_impl(BufferedImage image) { return get_impl(createAnalysisContext(image)); } public Object get(BufferedImage image) { return get(createAnalysisContext(image)); } public Object get(G22AnalysisContext context) { if (context.analyzerResults.containsKey(analyzer())) { Object value = context.analyzerResults.get(analyzer()); if (value == G22AnalysisContext.calculating) throw fail("Recursive call to analyzer " + this); return ((OKOrError) value).getMandatory(); } context.analyzerResults.put(analyzer(), G22AnalysisContext.calculating); var result = okOrError(() -> { if (parsedScript == null) rethrow(compileError); if (context.image == null && context.imageStream == null) throw fail("Need image or imageStream"); return g22utils().evalRegisteredCode(timeout, str(G22Analyzer.this), () -> get_impl(context)); }); context.analyzerResults.put(analyzer(), result); return result.getMandatory(); } } public G22Analyzer analyzer() { return this; } public LASCompileResult newCompileResult() { return new CompiledAnalyzer(); } public CompiledAnalyzer compileForAutoRun() { return (CompiledAnalyzer) super.compileForAutoRun(); } } static public class FastDownscale4x4 { static final public int scaleX = 4, scaleY = scaleX; public int w, h, w2, h2; public int[] finalPixels; public void scaleDown(BufferedImage img) { scaleDown(loadableUtils.utils.grabbableIntPixels_fastOrSlow(img)); } public void scaleDown(GrabbableIntPixels gp) { w = gp.w; int h = this.h = gp.h; int w2 = this.w2 = w / scaleX, h2 = this.h2 = h / scaleY; int stride = gp.scanlineStride; int scaleArea = scaleX * scaleY; int[] newPixels = finalPixels = new int[w2 * h2]; int iRow = gp.offset, iOut = 0; int[] pixels = gp.data; for (int y = 0; y < h2; y++) { int iIn = iRow; for (int x = 0; x < w2; x++) { int r = 0, g = 0, b = 0; int iSub = iIn; for (int subY = 0; subY < scaleY; subY++) { for (int subX = 0; subX < scaleX; subX++) { int rgb = pixels[iSub + subX]; r += (rgb >> 16) & 0xFF; g += (rgb >> 8) & 0xFF; b += rgb & 0xFF; } iSub += stride; } iIn += scaleX; newPixels[iOut++] = rgbIntFullAlpha(r / scaleArea, g / scaleArea, b / scaleArea); } iRow += stride * scaleY; } } public BufferedImage get(BufferedImage img) { scaleDown(img); return get(); } public BufferedImage get() { return bufferedImage(w2, h2, finalPixels); } public GrabbableIntPixels grabbableIntPixels() { return new GrabbableIntPixels(finalPixels, w2, h2, 0, w2); } } static public class SetWithChangeListeners extends NotifyingSet implements IHasChangeListeners { transient public Set onChange; public SetWithChangeListeners onChange(Runnable r) { onChange = createOrAddToSyncLinkedHashSet(onChange, r); return this; } public SetWithChangeListeners removeChangeListener(Runnable r) { loadableUtils.utils.remove(onChange, r); return this; } public void fireChange() { if (onChange != null) for (var listener : onChange) pcallF_typed(listener); } public void change() { fireChange(); } public SetWithChangeListeners() { super(new HashSet()); } public SetWithChangeListeners(Set set) { super(set); } } static public class G22DataWrangler extends Stages2 implements IHasChangeListeners { transient public Set onChange; public G22DataWrangler onChange(Runnable r) { onChange = createOrAddToSyncLinkedHashSet(onChange, r); return this; } public G22DataWrangler removeChangeListener(Runnable r) { loadableUtils.utils.remove(onChange, r); return this; } public void change() { if (onChange != null) for (var listener : onChange) pcallF_typed(listener); } final public G22DataWrangler setInputImage(BufferedImage inputImage) { return inputImage(inputImage); } public G22DataWrangler inputImage(BufferedImage inputImage) { this.inputImage = inputImage; return this; } final public BufferedImage getInputImage() { return inputImage(); } public BufferedImage inputImage() { return inputImage; } public BufferedImage inputImage; final public G22DataWrangler setStealingFrom(G22DataWrangler stealingFrom) { return stealingFrom(stealingFrom); } public G22DataWrangler stealingFrom(G22DataWrangler stealingFrom) { this.stealingFrom = stealingFrom; return this; } final public G22DataWrangler getStealingFrom() { return stealingFrom(); } public G22DataWrangler stealingFrom() { return stealingFrom; } public G22DataWrangler stealingFrom; final public G22DataWrangler setWithDiagonals(boolean withDiagonals) { return withDiagonals(withDiagonals); } public G22DataWrangler withDiagonals(boolean withDiagonals) { this.withDiagonals = withDiagonals; return this; } final public boolean getWithDiagonals() { return withDiagonals(); } public boolean withDiagonals() { return withDiagonals; } public boolean withDiagonals = true; public transient FieldVar varBlur_cache; public FieldVar varBlur() { if (varBlur_cache == null) varBlur_cache = varBlur_load(); return varBlur_cache; } public FieldVar varBlur_load() { return new FieldVar(this, "blur", () -> blur(), blur -> blur(blur)); } final public G22DataWrangler setBlur(int blur) { return blur(blur); } public G22DataWrangler blur(int blur) { if (!eq(this.blur, blur)) { this.blur = blur; change(); } return this; } final public int getBlur() { return blur(); } public int blur() { return blur; } public int blur = 0; public transient FieldVar varColorsPerChannel_cache; public FieldVar varColorsPerChannel() { if (varColorsPerChannel_cache == null) varColorsPerChannel_cache = varColorsPerChannel_load(); return varColorsPerChannel_cache; } public FieldVar varColorsPerChannel_load() { return new FieldVar(this, "colorsPerChannel", () -> colorsPerChannel(), colorsPerChannel -> colorsPerChannel(colorsPerChannel)); } final public G22DataWrangler setColorsPerChannel(int colorsPerChannel) { return colorsPerChannel(colorsPerChannel); } public G22DataWrangler colorsPerChannel(int colorsPerChannel) { if (!eq(this.colorsPerChannel, colorsPerChannel)) { this.colorsPerChannel = colorsPerChannel; change(); } return this; } final public int getColorsPerChannel() { return colorsPerChannel(); } public int colorsPerChannel() { return colorsPerChannel; } public int colorsPerChannel = 2; public transient FieldVar varDrift_cache; public FieldVar varDrift() { if (varDrift_cache == null) varDrift_cache = varDrift_load(); return varDrift_cache; } public FieldVar varDrift_load() { return new FieldVar(this, "drift", () -> drift(), drift -> drift(drift)); } final public G22DataWrangler setDrift(float drift) { return drift(drift); } public G22DataWrangler drift(float drift) { if (!eq(this.drift, drift)) { this.drift = drift; change(); } return this; } final public float getDrift() { return drift(); } public float drift() { return drift; } public float drift; public transient FieldVar varAntiDrift_cache; public FieldVar varAntiDrift() { if (varAntiDrift_cache == null) varAntiDrift_cache = varAntiDrift_load(); return varAntiDrift_cache; } public FieldVar varAntiDrift_load() { return new FieldVar(this, "antiDrift", () -> antiDrift(), antiDrift -> antiDrift(antiDrift)); } final public G22DataWrangler setAntiDrift(float antiDrift) { return antiDrift(antiDrift); } public G22DataWrangler antiDrift(float antiDrift) { if (!eq(this.antiDrift, antiDrift)) { this.antiDrift = antiDrift; change(); } return this; } final public float getAntiDrift() { return antiDrift(); } public float antiDrift() { return antiDrift; } public float antiDrift; final public G22DataWrangler setKilobytes(TargetAndActual kilobytes) { return kilobytes(kilobytes); } public G22DataWrangler kilobytes(TargetAndActual kilobytes) { this.kilobytes = kilobytes; return this; } final public TargetAndActual getKilobytes() { return kilobytes(); } public TargetAndActual kilobytes() { return kilobytes; } public TargetAndActual kilobytes = new TargetAndActual<>(250.0); final public G22DataWrangler setCoveredPixelsPercentage(TargetAndActual coveredPixelsPercentage) { return coveredPixelsPercentage(coveredPixelsPercentage); } public G22DataWrangler coveredPixelsPercentage(TargetAndActual coveredPixelsPercentage) { this.coveredPixelsPercentage = coveredPixelsPercentage; return this; } final public TargetAndActual getCoveredPixelsPercentage() { return coveredPixelsPercentage(); } public TargetAndActual coveredPixelsPercentage() { return coveredPixelsPercentage; } public TargetAndActual coveredPixelsPercentage = new TargetAndActual(); final public G22DataWrangler setDetailLevel(TargetAndActual detailLevel) { return detailLevel(detailLevel); } public G22DataWrangler detailLevel(TargetAndActual detailLevel) { this.detailLevel = detailLevel; return this; } final public TargetAndActual getDetailLevel() { return detailLevel(); } public TargetAndActual detailLevel() { return detailLevel; } public TargetAndActual detailLevel = new TargetAndActual(); final public G22DataWrangler setVectorize(boolean vectorize) { return vectorize(vectorize); } public G22DataWrangler vectorize(boolean vectorize) { this.vectorize = vectorize; return this; } final public boolean getVectorize() { return vectorize(); } public boolean vectorize() { return vectorize; } public boolean vectorize = true; final public G22DataWrangler setAllowPartialSSIs(boolean allowPartialSSIs) { return allowPartialSSIs(allowPartialSSIs); } public G22DataWrangler allowPartialSSIs(boolean allowPartialSSIs) { this.allowPartialSSIs = allowPartialSSIs; return this; } final public boolean getAllowPartialSSIs() { return allowPartialSSIs(); } public boolean allowPartialSSIs() { return allowPartialSSIs; } public boolean allowPartialSSIs = true; final public boolean getBlackAndWhiteMode() { return blackAndWhiteMode(); } public boolean blackAndWhiteMode() { return blackAndWhiteMode; } public boolean blackAndWhiteMode = false; final public G22DataWrangler setSortMode(SortMode sortMode) { return sortMode(sortMode); } public G22DataWrangler sortMode(SortMode sortMode) { this.sortMode = sortMode; return this; } final public SortMode getSortMode() { return sortMode(); } public SortMode sortMode() { return sortMode; } public SortMode sortMode = SortMode.compressibility; public enum SortMode { compressibility, pixels } public BufferedImage blurredImage; public int maxLines, maxInts; public List currentSSIs; public List initialSSIs; public AbstractSSIList sortedSSIs, cutSSIs, vectorizedSSIs, cutVectorizedSSIs; public CutListToBudget cutter; public Hi15Image posterizedImage; public FastRegions_Hi15Image regionMaker; public List> regions, regionsBySize; public G22DataWrangler() { } public G22DataWrangler(BufferedImage inputImage) { this.inputImage = inputImage; } public G22DataWrangler(MakesBufferedImage inputImage) { this.inputImage = inputImage.getBufferedImage(); } public SinglePixelPosterizer posterizer() { return new SinglePixelPosterizer(colorsPerChannel()).drift(drift).antiDrift(antiDrift); } public G22DataWrangler kb(TargetAndActual kb) { return kilobytes(kb); } public TargetAndActual kb() { return kilobytes; } public WidthAndHeight resolution() { return imageSize(inputImage); } public double detailDivisor() { return areaRoot(inputImage); } public int colors() { return blackAndWhiteMode ? 2 : cubed(colorsPerChannel()); } transient public FieldVar varColors_cache; public FieldVar varColors() { if (varColors_cache == null) varColors_cache = varColors_load(); return varColors_cache; } public FieldVar varColors_load() { return new FieldVar(this, "colors", () -> colors(), __1 -> colors(__1)); } public G22DataWrangler colors(int colors) { int perChannel = iceil(cbrt(colors)); blackAndWhiteMode = colors == 2; return colorsPerChannel(perChannel); } { stage("Steal", new Runnable() { public void run() { try { if (stealingFrom != null) { if (stealingFrom.inputImage != inputImage) { stealingFrom = null; return; } stealingFrom.stealingFrom = null; } } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (stealingFrom != null) {\r\n if (stealingFrom.inputImage != inputImage)..."; } }); } { stage("Blur", new Runnable() { public void run() { try { if (stealingFrom != null) if (stealingFrom.blur == blur) { blurredImage = stealingFrom.blurredImage; return; } else stealingFrom = null; blurredImage = blurBufferedImage(blur, inputImage); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (stealingFrom != null)\r\n if (stealingFrom.blur == blur)\r\n { bl..."; } }); } public Stage posterizeStage = stage("Posterize", new Runnable() { public void run() { try { if (stealingFrom != null) if (eq(stealingFrom.posterizer(), posterizer())) { posterizedImage = stealingFrom.posterizedImage; return; } else stealingFrom = null; var image = blurredImage; if (blackAndWhiteMode) image = new BWImage(image).getBufferedImage(); posterizedImage = posterizeBufferedImageToHi15(image, posterizer()); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (stealingFrom != null)\r\n if (eq(stealingFrom.posterizer(), posterizer..."; } }); public Stage prepareRegionsStage = stage("Prepare regions", new Runnable() { public void run() { try { if (stealingFrom != null) if (stealingFrom.withDiagonals == withDiagonals) { regionMaker = stealingFrom.regionMaker; regions = stealingFrom.regions; return; } else stealingFrom = null; regionMaker = new FastRegions_Hi15Image(posterizedImage); regionMaker.withDiagonals(withDiagonals); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (stealingFrom != null)\r\n if (stealingFrom.withDiagonals == withDiagon..."; } }); public Stage regionsStage = stage("Regions", new Runnable() { public void run() { try { regions = regionMaker.get(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "regions = regionMaker.get();"; } }); public Stage biggestRegionsStage = stage("Sort regions", new Runnable() { public void run() { try { regions = regionsBySize = biggestRegionsFirst(regions); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "regions = regionsBySize = biggestRegionsFirst(regions);"; } }); { stage("SSIs", new Runnable() { public void run() { try { initialSSIs = new ArrayList(); for (var region : regions) initialSSIs.addAll(new G22_RegionToSSIs_v2(region).withDiagonals(withDiagonals).get()); currentSSIs = initialSSIs; } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "initialSSIs = new ArrayList();\r\n for (var region : regions)\r\n initial..."; } }); } public int initialSSILines() { return totalSSILines(initialSSIs); } { stage("Vector-Optimize", new Runnable() { public void run() { try { currentSSIs = vectorizedSSIs = vectorize ? new VectorOptimizedSSIList(currentSSIs) : new GeneralSSIList(currentSSIs); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "currentSSIs = vectorizedSSIs = vectorize\r\n ? new VectorOptimizedSSIList(..."; } }); } { stage("Sort SSIs", new Runnable() { public void run() { try { if (sortMode == SortMode.compressibility) sortedSSIs = new GeneralSSIList(sortedDesc(currentSSIs, (a, b) -> { int x = cmp(a.compressibility(), b.compressibility()); if (x != 0) return x; return cmp(a.numberOfPixels(), b.numberOfPixels()); })); else if (sortMode == SortMode.pixels) sortedSSIs = new GeneralSSIList(biggestSSIsFirst(currentSSIs)); else throw fail("Unknown sort mode"); currentSSIs = sortedSSIs; } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "if (sortMode == SortMode.compressibility)\r\n sortedSSIs = new GeneralSSIL..."; } }); } { stage("Cut SSI List by detail level", new Runnable() { public void run() { try { maxLines = !detailLevel.hasTarget() ? Integer.MAX_VALUE : iround(detailDivisor() * detailLevel.target()); currentSSIs = cutSSIs = new GeneralSSIList(takeFirstNSSILines(maxLines, currentSSIs)); detailLevel.set(l(cutSSIs) / detailDivisor()); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "maxLines = !detailLevel.hasTarget() ? Integer.MAX_VALUE\r\n : iround(detai..."; } }); } { stage("Cut Vector-Optimized SSIs by file size", new Runnable() { public void run() { try { maxInts = !kilobytes.hasTarget() ? Integer.MAX_VALUE : iround(kilobytes.target() * 512); cutter = new CutListToBudget(ssi -> (double) ssi.sizeInInts(), maxInts, (List) currentSSIs); if (allowPartialSSIs) cutter.allowPartial((ssi, budget) -> ssi.reduceToInts(iround(budget))); currentSSIs = cutVectorizedSSIs = new GeneralSSIList(cutter.get()); kilobytes.set(totalSizeInInts(cutVectorizedSSIs) / 512.0); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "maxInts = !kilobytes.hasTarget() ? Integer.MAX_VALUE\r\n : iround(kilobyte..."; } }); } public List> regions() { stepUntilStage(regionsStage); return regions; } public List> regionsBySize() { stepUntilStage(biggestRegionsStage); return regions; } public List regionsAsIBinaryImages() { return map(__84 -> regionToIBinaryImage(__84), regions()); } public BlurAndPosterizeSettings bnpSettings() { return new BlurAndPosterizeSettings().blur(blur).colors(colors()).colorDrift(new RGB(drift())).antiDrift(new RGB(antiDrift)); } public void importSettings(BlurAndPosterizeSettings bnp) { blur(bnp.blur); colors(bnp.colors); drift(bnp.colorDrift.brightness()); antiDrift(bnp.antiDrift.brightness()); } public FastRegions_Hi15Image preparedRegionMaker() { stepUntilStage(prepareRegionsStage); return regionMaker; } public FastRegions_Hi15Image regionMaker() { stepUntilStage(regionsStage); return regionMaker; } public String toString() { return commaCombine(shortClassName(this), imageSize(inputImage), "completed stages: " + or2(joinWithComma(completedStages()), "-")); } public Hi15Image posterizedImage() { stepUntilStage(posterizeStage); return posterizedImage; } } static public class RunLengthCounter { final public A getValue() { return value(); } public A value() { return value; } public A value; final public long getRunLength() { return runLength(); } public long runLength() { return runLength; } public long runLength; public long add(A value) { if (eq(this.value, value)) ++runLength; else runLength = 1; this.value = value; return runLength; } } static public class VScrollingWrapLayout extends AbstractLayoutManager { final public VScrollingWrapLayout setCenteredHorizontally(boolean centeredHorizontally) { return centeredHorizontally(centeredHorizontally); } public VScrollingWrapLayout centeredHorizontally(boolean centeredHorizontally) { this.centeredHorizontally = centeredHorizontally; return this; } final public boolean getCenteredHorizontally() { return centeredHorizontally(); } public boolean centeredHorizontally() { return centeredHorizontally; } public boolean centeredHorizontally = false; public void layoutContainer(Container parent) { List components = getComponents(parent); class X { public int maxWidth = parent.getWidth(); public int x, y; public int lineHeight; public int componentsInLine, i; public void finishLine() { if (centeredHorizontally) { int x1 = (maxWidth - x) / 2; for (int j = i - componentsInLine; j < i; j++) { var c = components.get(j); Rectangle r = c.getBounds(); c.setBounds(r.x + x1, r.y, r.width, r.height); } } } public void run() { for (i = 0; i < l(components); i++) { var c = components.get(i); Dimension size = c.getPreferredSize(); boolean needNewLine = componentsInLine != 0 && x + size.width > maxWidth; if (needNewLine) { finishLine(); y += lineHeight; x = componentsInLine = lineHeight = 0; } c.setBounds(x, y, size.width, size.height); x += size.width; lineHeight = max(size.height, lineHeight); ++componentsInLine; } finishLine(); preferredSize(maxWidth, y + lineHeight); } } new X().run(); } } static public class MockJuiceable implements Juiceable { final public MockJuiceable setJuiceValue(double juiceValue) { return juiceValue(juiceValue); } public MockJuiceable juiceValue(double juiceValue) { this.juiceValue = juiceValue; return this; } final public double getJuiceValue() { return juiceValue(); } public double juiceValue() { return juiceValue; } public double juiceValue; } static public class G22MeshMapper_v2 implements IFieldsToList { public G22Mesh mesh1; public G22Mesh mesh2; public G22MeshMapper_v2() { } public G22MeshMapper_v2(G22Mesh mesh1, G22Mesh mesh2) { this.mesh2 = mesh2; this.mesh1 = mesh1; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + mesh1 + ", " + mesh2 + ")"; } public Object[] _fieldsToList() { return new Object[] { mesh1, mesh2 }; } final public G22MeshMapper_v2 setChooseAnchor1AtRandom(boolean chooseAnchor1AtRandom) { return chooseAnchor1AtRandom(chooseAnchor1AtRandom); } public G22MeshMapper_v2 chooseAnchor1AtRandom(boolean chooseAnchor1AtRandom) { this.chooseAnchor1AtRandom = chooseAnchor1AtRandom; return this; } final public boolean getChooseAnchor1AtRandom() { return chooseAnchor1AtRandom(); } public boolean chooseAnchor1AtRandom() { return chooseAnchor1AtRandom; } public boolean chooseAnchor1AtRandom = false; public G22MeshMapping mm; final public G22MeshMapper_v2 setDebugOutput(List debugOutput) { return debugOutput(debugOutput); } public G22MeshMapper_v2 debugOutput(List debugOutput) { this.debugOutput = debugOutput; return this; } final public List getDebugOutput() { return debugOutput(); } public List debugOutput() { return debugOutput; } public List debugOutput; final public G22MeshMapper_v2 setContrast(float contrast) { return contrast(contrast); } public G22MeshMapper_v2 contrast(float contrast) { this.contrast = contrast; return this; } final public float getContrast() { return contrast(); } public float contrast() { return contrast; } public float contrast = 0.25f; final public G22MeshMapper_v2 setBrightness(int brightness) { return brightness(brightness); } public G22MeshMapper_v2 brightness(int brightness) { this.brightness = brightness; return this; } final public int getBrightness() { return brightness(); } public int brightness() { return brightness; } public int brightness = 128; public MultiMap anchorsByArity2; final public G22MeshMapper_v2 setRejectedBecause(Object rejectedBecause) { return rejectedBecause(rejectedBecause); } public G22MeshMapper_v2 rejectedBecause(Object rejectedBecause) { this.rejectedBecause = rejectedBecause; return this; } final public Object getRejectedBecause() { return rejectedBecause(); } public Object rejectedBecause() { return rejectedBecause; } public Object rejectedBecause; public boolean rejected() { return rejectedBecause != null; } public boolean prechecksDone = false; public String sig1, sig2; public G22Mesh.Anchor anchor1; public G22MeshMapping get() { return mm; } public Search newSearch() { return new Search(); } public class Search extends VStackComputableWithStep implements IMakeEmptyClone { public G22Mesh.Anchor anchor2; public Search makeEmptyClone() { return new Search(); } public void step(VStack stack) { if (step == 0) { prechecks(); if (rejected()) ((BStack) stack)._return(); step = 1; } else if (step == 1) { mm = new G22MeshMapping(mesh1, mesh2); anchorsByArity2 = multiMapIndex(mesh2.anchors(), a -> a.arity()); anchor1 = chooseAnchor1AtRandom ? random(mesh1.anchors()) : first(mesh1.anchors()); List anchor2options = anchorsByArity2.get(anchor1.arity()); step = 2; ((BStack) stack).options(this, map(anchor2options, anchor2 -> instance -> instance.anchor2 = anchor2)); } else if (step == 2) { print("G22MeshMapper_v2 step1: Connecting " + anchor1 + " to " + anchor2); add(debugOutput, "Mapping anchor"); ((BStack) stack).temp(mm.tempMapAnchor(anchor1, anchor2)); ((BStack) stack).temp(() -> add(debugOutput, print("Unmapping anchor"))); addMappingToDebugOutput(); step = 3; } else if (step == 3) { ((BStack) stack).call(new Step2()); step = 4; } else { if (isTrue(((BStack) stack).subResult())) step = 3; else ((BStack) stack)._return(); } } } public class Step2 extends VStackComputableWithStep implements IMakeEmptyClone { public boolean change = false; public Iterator curve1iterator; public G22Mesh.Curve curve1; public G22MeshMapping.MappedCurve c2; public G22Mesh.Anchor a2; public Step2 makeEmptyClone() { return new Step2(); } public void step(VStack stack) { if (step == 0) { print(n2(mesh1.curves(), "curve") + " in mesh1, mapped: " + l(mm.curveMap)); print("mesh1.curves: " + map(__85 -> identityHashCode(__85), mesh1.curves())); print("mapped: " + map(__86 -> identityHashCode(__86), keys(mm.curveMap))); print("mapped (backward map): " + map(__87 -> identityHashCode(__87), keys(mm.curveBackwardMap))); curve1iterator = iterator(mesh1.curves()); step++; } else if (step == 1) { if (!curve1iterator.hasNext()) { ((BStack) stack)._return(change); return; } curve1 = curve1iterator.next(); print("Looking to match " + curve1); G22MeshMapping.MappedCurve curve1mapping = mm.get(curve1); if (curve1mapping != null) { print("Curve is mapped: " + curve1); assertTrue("mesh2 contains curve1mapping", mesh2.containsCurve(curve1mapping.get())); return; } G22Mesh.Anchor start2 = mm.get(curve1.start); G22Mesh.Anchor end2 = mm.get(curve1.end); if (start2 == null && end2 == null) { return; } List possibleCurves = new ArrayList(); if (start2 != null && end2 != null) { for (var curve2 : start2.curves()) if (curve2.connectedTo(end2)) { boolean flipped = curve2.end == start2; possibleCurves.add(new G22MeshMapping.MappedCurve(curve2, flipped)); } } else { boolean startAtEnd = end2 != null; G22Mesh.Anchor a1 = curve1.anchor(startAtEnd); G22Mesh.Anchor a1other = curve1.anchor(!startAtEnd); a2 = mm.get(curve1.anchor(startAtEnd)); print("a1", a1); print("a2", a2); print("a1other", a1other); for (var c2 : a2.curves()) { if (mm.isMapped(c2)) { continue; } G22Mesh.Anchor a3 = c2.anchorOpposite(a2); print("a3", a3); int arity1 = a3.arity(), arity2 = a1other.arity(); if (arity1 != arity2) { print("Arity mismatch (" + arity1 + "/" + arity2 + ") for curve " + c2); continue; } boolean flipped = c2.start() != a2; possibleCurves.add(new G22MeshMapping.MappedCurve(c2, flipped)); print("Possible curve!"); } } addPossibleCurvesToDebugOutput(curve1, possibleCurves); print(l(possibleCurves) + " possible curve(s) to map " + curve1 + " to: "); pnl(possibleCurves); if (empty(possibleCurves)) { ((BStack) stack).temp(tempRejectedBecause("Could not map curve " + curve1)); { ((BStack) stack)._return(false); return; } } step = 2; ((BStack) stack).options(this, map(possibleCurves, c2 -> instance -> instance.c2 = c2)); return; } else { print("Mapping curve " + curve1 + " to " + c2); add(debugOutput, print("Mapping curve")); ((BStack) stack).temp(mm.tempMapCurve(curve1, c2.get(), c2.flipped)); ((BStack) stack).temp(() -> add(debugOutput, "Unmapping curve")); addMappingToDebugOutput(); change = true; step = 1; } } } public void prechecks() { prechecksDone = true; sig1 = mesh1.signature(); sig2 = mesh1.signature(); if (!eq(sig1, sig2)) { rejectedBecause(new G22SignatureMismatch(mesh1, mesh2)); return; } } public AutoCloseable tempRejectedBecause(Object reason) { rejectedBecause(reason); return () -> rejectedBecause(null); } public void addMappingToDebugOutput() { if (debugOutput == null) return; Object error = mm.validityError(); addIfNotNull(debugOutput, error); var img1 = mesh1.getBufferedImage(); var img2 = mesh2.getBufferedImage(); for (var img : ll(img1, img2)) bufferedImageContrastAndBrightness(img, contrast, brightness); mm.drawMappedPartOfMesh1(createGraphics(img1)); mm.drawMappedPartOfMesh2(createGraphics(img2)); addPair(debugOutput, img1, img2); } public void addPossibleCurvesToDebugOutput(G22Mesh.Curve c1, Collection possibleCurves) { if (debugOutput == null) return; var img1 = mesh1.getBufferedImage(); var img2 = mesh2.getBufferedImage(); for (var img : ll(img1, img2)) bufferedImageContrastAndBrightness(img, contrast, brightness); new G22VisualizeMeshes().drawCurve(createGraphics(img1), c1); for (var curve : possibleCurves) { G22VisualizeMeshes vm = new G22VisualizeMeshes(); if (curve.flipped) vm.curveColor(Color.green); vm.drawCurve(createGraphics(img2), curve.get()); } add(debugOutput, n2(possibleCurves, "possible curve")); addPair(debugOutput, img1, img2); } } static public class G22JavaObjectVisualizer implements Swingable, IFieldsToList { public G22Utils g22utils; public G22JavaObjectVisualizer() { } public G22JavaObjectVisualizer(G22Utils g22utils) { this.g22utils = g22utils; } public Object[] _fieldsToList() { return new Object[] { g22utils }; } final public G22JavaObjectVisualizer setWithTypeAndTime(boolean withTypeAndTime) { return withTypeAndTime(withTypeAndTime); } public G22JavaObjectVisualizer withTypeAndTime(boolean withTypeAndTime) { this.withTypeAndTime = withTypeAndTime; return this; } final public boolean getWithTypeAndTime() { return withTypeAndTime(); } public boolean withTypeAndTime() { return withTypeAndTime; } public boolean withTypeAndTime = true; final public G22JavaObjectVisualizer setSingleLineLayout(boolean singleLineLayout) { return singleLineLayout(singleLineLayout); } public G22JavaObjectVisualizer singleLineLayout(boolean singleLineLayout) { this.singleLineLayout = singleLineLayout; return this; } final public boolean getSingleLineLayout() { return singleLineLayout(); } public boolean singleLineLayout() { return singleLineLayout; } public boolean singleLineLayout = false; final public G22JavaObjectVisualizer setMaxElements(int maxElements) { return maxElements(maxElements); } public G22JavaObjectVisualizer maxElements(int maxElements) { this.maxElements = maxElements; return this; } final public int getMaxElements() { return maxElements(); } public int maxElements() { return maxElements; } public int maxElements = 1000; final public G22JavaObjectVisualizer setHorizontal(boolean horizontal) { return horizontal(horizontal); } public G22JavaObjectVisualizer horizontal(boolean horizontal) { this.horizontal = horizontal; return this; } final public boolean getHorizontal() { return horizontal(); } public boolean horizontal() { return horizontal; } public boolean horizontal = false; final public G22JavaObjectVisualizer setFloatingPointDigits(int floatingPointDigits) { return floatingPointDigits(floatingPointDigits); } public G22JavaObjectVisualizer floatingPointDigits(int floatingPointDigits) { this.floatingPointDigits = floatingPointDigits; return this; } final public int getFloatingPointDigits() { return floatingPointDigits(); } public int floatingPointDigits() { return floatingPointDigits; } public int floatingPointDigits = 4; final public G22JavaObjectVisualizer setAllowDescendingIntoListElements(boolean allowDescendingIntoListElements) { return allowDescendingIntoListElements(allowDescendingIntoListElements); } public G22JavaObjectVisualizer allowDescendingIntoListElements(boolean allowDescendingIntoListElements) { this.allowDescendingIntoListElements = allowDescendingIntoListElements; return this; } final public boolean getAllowDescendingIntoListElements() { return allowDescendingIntoListElements(); } public boolean allowDescendingIntoListElements() { return allowDescendingIntoListElements; } public boolean allowDescendingIntoListElements = false; final public G22JavaObjectVisualizer setScriptTimeout(double scriptTimeout) { return scriptTimeout(scriptTimeout); } public G22JavaObjectVisualizer scriptTimeout(double scriptTimeout) { this.scriptTimeout = scriptTimeout; return this; } final public double getScriptTimeout() { return scriptTimeout(); } public double scriptTimeout() { return scriptTimeout; } public double scriptTimeout = 10.0; final public G22JavaObjectVisualizer setStringDisplayLength(int stringDisplayLength) { return stringDisplayLength(stringDisplayLength); } public G22JavaObjectVisualizer stringDisplayLength(int stringDisplayLength) { this.stringDisplayLength = stringDisplayLength; return this; } final public int getStringDisplayLength() { return stringDisplayLength(); } public int stringDisplayLength() { return stringDisplayLength; } public int stringDisplayLength = 80; public Set seen = identityHashSet(); final public G22JavaObjectVisualizer setObject(Object object) { return object(object); } public G22JavaObjectVisualizer object(Object object) { this.object = object; return this; } final public Object getObject() { return object(); } public Object object() { return object; } transient public Object object; final public G22JavaObjectVisualizer setNanos(long nanos) { return nanos(nanos); } public G22JavaObjectVisualizer nanos(long nanos) { this.nanos = nanos; return this; } final public long getNanos() { return nanos(); } public long nanos() { return nanos; } transient public long nanos = -1; transient public SingleComponentPanel scp = scp(); public G22JavaObjectVisualizer(G22Utils g22utils, Object object) { this.object = object; this.g22utils = g22utils; } public String objectInfos() { return objectInfos(this.object); } public String objectInfos(Object object) { List infos = new ArrayList(); infos.add(str(shortClassName2(object))); for (var __0 : _entrySet(mainVisualizer().properties)) { var key = __0.getKey(); var val = __0.getValue(); String s = n2OrStrOrNull(val); if (nempty(s)) infos.add(key + " " + s); } if (nanos >= 0) { String timeDesc = nanos < 0 ? "" : formatElapsedTimeWithAppropriateUnit(nanosToSeconds(nanos)); infos.add(timeDesc); } return joinNemptiesWithComma(infos); } public transient JComponent visualize_cache; public JComponent visualize() { if (visualize_cache == null) visualize_cache = visualize_load(); return visualize_cache; } public JComponent visualize_load() { return markVisualizer(this, visualize_impl()); } public JComponent visualize_impl() { scp.set(visualizeObjectWithExtras(object)); return scp; } public JComponent visualizeObject(Object object) { return mainVisualizer().visualize(object); } public JComponent visualizeObjectWithExtras(Object object) { return visualizeObjectWithExtras(object, null); } public JComponent visualizeObjectWithExtras(Object object, Component back) { JComponent c = visualizeObject(object); JButton btnBack = back == null ? null : jimageButtonScaledToWidth(16, "#1103102", () -> scp.set(back)); JComponent lblType = null; if (withTypeAndTime) { String type = objectInfos(object); lblType = withLabel("Type:", jlabel(type)); } if (btnBack != null || lblType != null) { JComponent top = or(lblType, jpanel()); if (btnBack != null) top = westAndCenterWithMargin(btnBack, top); return northAndCenterWithMargins(top, c); } return c; } public ObjectVisualizer mainVisualizer_cache; public ObjectVisualizer mainVisualizer() { if (mainVisualizer_cache == null) mainVisualizer_cache = mainVisualizer_load(); return mainVisualizer_cache; } public ObjectVisualizer mainVisualizer_load() { return new ObjectVisualizer().recurse(true).bigFont(true).horizontal(horizontal); } public class ObjectVisualizer { final public ObjectVisualizer setRecurse(boolean recurse) { return recurse(recurse); } public ObjectVisualizer recurse(boolean recurse) { this.recurse = recurse; return this; } final public boolean getRecurse() { return recurse(); } public boolean recurse() { return recurse; } public boolean recurse = false; final public ObjectVisualizer setBigFont(boolean bigFont) { return bigFont(bigFont); } public ObjectVisualizer bigFont(boolean bigFont) { this.bigFont = bigFont; return this; } final public boolean getBigFont() { return bigFont(); } public boolean bigFont() { return bigFont; } public boolean bigFont = false; final public ObjectVisualizer setHorizontal(boolean horizontal) { return horizontal(horizontal); } public ObjectVisualizer horizontal(boolean horizontal) { this.horizontal = horizontal; return this; } final public boolean getHorizontal() { return horizontal(); } public boolean horizontal() { return horizontal; } public boolean horizontal = false; final public ObjectVisualizer setScrollable(boolean scrollable) { return scrollable(scrollable); } public ObjectVisualizer scrollable(boolean scrollable) { this.scrollable = scrollable; return this; } final public boolean getScrollable() { return scrollable(); } public boolean scrollable() { return scrollable; } public boolean scrollable = true; public LinkedHashMap properties = new LinkedHashMap(); public ObjectVisualizer subVisualizer() { return new ObjectVisualizer().horizontal(!horizontal); } public ObjectVisualizer subVisualizerOnSameLevel() { return new ObjectVisualizer().horizontal(horizontal).recurse(recurse).bigFont(bigFont).scrollable(false); } public JComponent makeBig(JComponent c) { if (bigFont) return fontSizePlus(10, c); return c; } public JComponent subVisualizeOnSameLevel(Object o) { return subVisualizerOnSameLevel().visualize(o); } public JComponent visualize(Object object) { try { return visualize2(object); } catch (Throwable e) { return g22utils.jErrorView(new RuntimeException("Visualization error", e)); } } public JComponent visualize2(Object object) { if (object instanceof Throwable) return g22utils.jErrorView((Throwable) object); if (object == null || eq(object, "")) return jpanel(); object = arrayToList(object); if (object instanceof Swingable) object = ((Swingable) object).visualize(); if (object instanceof JComponent && getParent((JComponent) object) == null) return ((JComponent) object); if (object instanceof Integer) object = toLong((Integer) object); if (object instanceof Long) return bigText(n2((Long) object)); if (object instanceof Double) return toolTip(str((Double) object), bigText(formatDouble(((Double) object), floatingPointDigits))); if (object instanceof Number) return bigText((Number) object); if (object instanceof Pair) return visualizeTuple(pairToList((Pair) object)); if (object instanceof T3) return visualizeTuple(tripleToList((T3) object)); if (object instanceof MakesBufferedImage) object = toBufferedImage((MakesBufferedImage) object); if (object instanceof BufferedImage) { var is = g22utils.stdImageSurface((BufferedImage) object); if (!recurse) is.setAutoZoomToDisplay(false); return jscroll_centered_borderless(is); } if (object instanceof GazelleV_LeftArrowScript.FunctionDef) { var f = (GazelleV_LeftArrowScript.FunctionDef) object; if (empty(f.args)) return centerAndEastWithMargin(visualizeAsText(f), jverticalCenter(jThreadedButton("Call", () -> inspectElement(callFunctionDef(f))))); } if (recurse) { if (object instanceof MultiMap) { propertyLength(l((MultiMap) object)); propertyKeyCount(((MultiMap) object).keyCount()); object = multiMapToMapPairs((MultiMap) object); } if (object instanceof MultiSetMap) { propertyLength(l((MultiSetMap) object)); propertyKeyCount(((MultiSetMap) object).keyCount()); object = multiSetMapToMapPairs((MultiSetMap) object); } if (object instanceof Map) { propertyLength(l((Map) object)); object = mapToPairs((Map) object); } if (object instanceof Collection) { propertyLength(l((Collection) object)); var sub = subVisualizer(); var elements = map(cloneTakeFirst(maxElements, ((Collection) object)), element -> { var elementVis = sub.visualize(element); if (allowDescendingIntoListElements) elementVis = centerAndEastWithMargin(elementVis, new JPopDownButton().content("Inspect element", runnableThread(new Runnable() { public void run() { try { inspectElement(element); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "inspectElement(element)"; } }))); return elementVis; }); return stackElements(elements); } } return visualizeAsText(object); } public JComponent visualizeTuple(List tuple) { if (horizontal) return jcenteredline(listCombine(jlabel("<"), intersperseF(() -> jlabel(","), map(__88 -> visualize(__88), tuple)), jlabel(">"))); else return stackElements(listCombine(map(__89 -> subVisualizeOnSameLevel(__89), tuple))); } public JComponent visualizeAsText(Object object) { if (object instanceof String) { propertyLength(l((String) object)); } String string = str(object); if (containsNewLine(string)) return jscroll_borderless(wordWrapTypeWriterTextArea(string)); if (recurse && l(string) > stringDisplayLength) return jText(string); var lbl = jcenterNarrowLabel(shorten(string)); if (l(string) <= 10) return makeBig(lbl); return lbl; } public void propertyLength(int l) { properties.put("size", l); } public void propertyKeyCount(int l) { properties.put("keys", l); } public JComponent bigText(Object o) { return makeBig(jcenteredLabel(str(o))); } public Object arrayToList(Object object) { if (isArray(object)) object = wrapArrayAsImmutableList(object); return object; } public JComponent stackElements(List elements) { var c = horizontal ? hstackWithSpacing(elements) : vstackWithSpacing(elements); return scrollable ? jscroll_centered_borderless(c) : c; } } public G22JavaObjectVisualizer withType(boolean b) { return withTypeAndTime(b); } public void inspectElement(Object element) { var back = scp.getComponent(); scp.set(visualizeObjectWithExtras(element, back)); } public Object callFunctionDef(GazelleV_LeftArrowScript.FunctionDef f) { return evalWithTimeoutOrFail(scriptTimeout, () -> f.call(new FlexibleVarContext())); } } static public class JGazelleVScriptRunner implements IFieldsToList { public SimpleLiveValue lvScript; public JGazelleVScriptRunner() { } public JGazelleVScriptRunner(SimpleLiveValue lvScript) { this.lvScript = lvScript; } public Object[] _fieldsToList() { return new Object[] { lvScript }; } public GazelleVScript parsedScript; public GazelleVScript.Run run; public Object result; public SingleComponentPanel scpScriptResult = singleComponentPanel(); public WeakVar isScriptResult = new WeakVar(); public WeakVar taResult = new WeakVar(); public JLabel lblScore = jlabel(); public JComponent scriptAndResultPanel() { return northAndCenter(scriptInputField(), scpScriptResult = singleComponentPanel()); } public JComponent scriptInputField() { return withMargin(centerAndEastWithMargin(withLabel("Gazelle \"Linear\" Script:", jLiveTextField(lvScript)), jPopDownButton_noText("Show Scripting Help", runnableThread(new Runnable() { public void run() { try { showText("Gazelle 'Linear Script' Help", GazelleVScript.helpText); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "showText(\"Gazelle 'Linear Script' Help\", GazelleVScript.helpText)"; } })))); } public void showScriptOutput() { if (result instanceof BWImage) { showImageResult((BWImage) result); } else if (result instanceof BufferedImage) { showImageResult((BufferedImage) result); } else if (result instanceof Animation) { showImageResult(((Animation) result).toImage()); } else { showTextResult(str(result)); } } public void showTextResult(String text) { text = shorten(1000, text); if (isShowing(taResult.get())) { setTextKeepCaret(taResult.get(), text); } else { var ta = jTextArea_noUndo(text); scpScriptResult.set(jscroll(ta)); taResult.set(ta); } } public void showImageResult(MakesBufferedImage img) { showImageResult(toBufferedImage(img)); } public void showImageResult(BufferedImage img) { if (img == null) return; if (isShowing(isScriptResult.get())) { isScriptResult.get().setImage(img); } else { var is = stdImageSurface(); is.setImage(img); scpScriptResult.set(jscroll_centered(is)); isScriptResult.set(is); } if (isShowing(lblScore)) { String score = ""; if (sameSize(run.inputImage, img)) { double distance = bwDistance(toBWImage(run.inputImage), toBWImage(img)); score = "Score: " + formatDoubleX(100 * (1 - distance), 1); } setText(lblScore, score); } } public ImageSurface stdImageSurface() { return pixelatedImageSurface().setAutoZoomToDisplay(true).repaintInThread(false); } public void parse() { parsedScript = new GazelleVScript(lvScript.get()); } public void runOn(IBWIntegralImage ii) { run = parsedScript.new Run(); run.setInputImage(ii); run.setIntegralImage(ii); run.run(); result = run.result(); } public void parseAndRunOn(IBWIntegralImage ii) { try { parse(); runOn(ii); } catch (Throwable e) { result = exceptionToStringShort(e); printStackTrace(e); } showScriptOutput(); } } static public class PicturesByMD5 implements IFieldsToList { public File dir; public PicturesByMD5() { } public PicturesByMD5(File dir) { this.dir = dir; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + dir + ")"; } public Object[] _fieldsToList() { return new Object[] { dir }; } final public PicturesByMD5 setExtension(String extension) { return extension(extension); } public PicturesByMD5 extension(String extension) { this.extension = extension; return this; } final public String getExtension() { return extension(); } public String extension() { return extension; } public String extension = ".jpeg"; transient public Lock lock = lock(); transient public VarWithNotify imageCount = new VarWithNotify(); public File imageFile(String md5) { return newFile(dir, assertMD5(md5) + extension); } public boolean has(String md5) { return isFile(imageFile(md5)); } public BufferedImage get(String md5) { return decodeImage(imageFile(md5)); } transient public IF1 decodeImage; public BufferedImage decodeImage(File f) { return decodeImage != null ? decodeImage.get(f) : decodeImage_base(f); } final public BufferedImage decodeImage_fallback(IF1 _f, File f) { return _f != null ? _f.get(f) : decodeImage_base(f); } public BufferedImage decodeImage_base(File f) { return loadImage2(f); } public boolean put(String md5, byte[] imageData) { if (has(md5)) return false; Lock __0 = lock; lock(__0); try { if (has(md5)) return false; saveBinaryFile(imageFile(md5), imageData); if (imageCount.has()) imageCount.set(imageCount() + 1); return true; } finally { unlock(__0); } } public int freshImageCount() { Lock __1 = lock; lock(__1); try { return setAndReturn(imageCount, l(freshImageFiles())); } finally { unlock(__1); } } public List freshImageFiles() { return listFilesWithExtension(dir, extension); } public int imageCount() { Lock __2 = lock; lock(__2); try { if (!imageCount.has()) freshImageCount(); return imageCount.get(); } finally { unlock(__2); } } public IVarWithNotify varImageCount() { return imageCount; } } static public class BitGetCredentials { final public BitGetCredentials setName(String name) { return name(name); } public BitGetCredentials name(String name) { this.name = name; return this; } final public String getName() { return name(); } public String name() { return name; } public String name; final public BitGetCredentials setApiKey(String apiKey) { return apiKey(apiKey); } public BitGetCredentials apiKey(String apiKey) { this.apiKey = apiKey; return this; } final public String getApiKey() { return apiKey(); } public String apiKey() { return apiKey; } public String apiKey; final public BitGetCredentials setPassphrase(String passphrase) { return passphrase(passphrase); } public BitGetCredentials passphrase(String passphrase) { this.passphrase = passphrase; return this; } final public String getPassphrase() { return passphrase(); } public String passphrase() { return passphrase; } public String passphrase; final public BitGetCredentials setSecretKey(String secretKey) { return secretKey(secretKey); } public BitGetCredentials secretKey(String secretKey) { this.secretKey = secretKey; return this; } final public String getSecretKey() { return secretKey(); } public String secretKey() { return secretKey; } public String secretKey; public String toString() { return joinNempties(" with ", spaceCombine(shortClassName(this), quoteOrEmpty(name)), commaCombine(nempty(apiKey) ? "apiKey " + roundBracket(nCharacters(apiKey)) : null, nempty(passphrase) ? "passphrase " + roundBracket(nCharacters(passphrase)) : null, nempty(secretKey) ? "secretKey " + roundBracket(nCharacters(secretKey)) : null)); } static public BitGetCredentials fromFile(File f) { var credMap = parseColonPropertyCIMap(loadTextFile(f)); return new BitGetCredentials().apiKey(credMap.get("API-Key")).passphrase(credMap.get("Passphrase")).secretKey(credMap.get("SecretKey")).name(credMap.get("Name")); } public void save(File f) { saveTextFile(f, formatColonProperties(litorderedmap("API-Key", apiKey, "Passphrase", passphrase, "SecretKey", secretKey, "Name", name))); } } static public class JButtonWithInset extends JButton { public JButtonWithInset() { } public JButtonWithInset(String text) { super(text); } public JButtonWithInset(Action action) { super(action); } public int inset = 10; public Dimension getMinimumSize() { Dimension d = super.getMinimumSize(); return new Dimension(d.width + inset, d.height + inset); } public Dimension getPreferredSize() { Dimension d = super.getPreferredSize(); return new Dimension(d.width + inset, d.height + inset); } } static public class G22Label extends ConceptWithGlobalID { public String name; public String toString() { return name; } final public boolean textIs(String text) { return nameIs(text); } public boolean nameIs(String text) { return eqic(name, text); } } static public class G22Tiler_Hi15Image extends G22AbstractTiler { public int getColor(int pos) { return image.getHi15Pixel_noRangeCheck(pos); } public G22Tiler_Hi15Image(Hi15Image img) { super(img); } public G22Tiler_Hi15Image(BufferedImage img) { this(new Hi15Image(img)); } } static public class DifferentialRegionsMaker_RGBImage extends DifferentialRegionsMaker { public int getRGB(int pos) { return image.getIntPixel_noRangeCheck(pos); } public DifferentialRegionsMaker_RGBImage(BufferedImage img) { super(new RGBImage(img)); } public DifferentialRegionsMaker_RGBImage(RGBImage img) { super(img); } } static public class G22ScriptsPanel extends G22CRUDAndDetailPanel { final public G22ScriptsPanel setScriptIDE(G22LAScriptIDE scriptIDE) { return scriptIDE(scriptIDE); } public G22ScriptsPanel scriptIDE(G22LAScriptIDE scriptIDE) { this.scriptIDE = scriptIDE; return this; } final public G22LAScriptIDE getScriptIDE() { return scriptIDE(); } public G22LAScriptIDE scriptIDE() { return scriptIDE; } transient volatile public G22LAScriptIDE scriptIDE; public SimpleCRUD_v2 makeCRUD() { var crud = new SimpleCRUD_v2<>(g22utils.concepts(), G22LeftArrowScript.class); crud.noSubclasses(true); crud.entityName = () -> "Script"; g22utils.setupScriptCRUD(crud, true); var ts = crud.tableSearcher(); var basicRowTester = ts.rowTester; ts.rowTester = if2ToF2((pat, map) -> { if (basicRowTester.get(pat, map)) return true; long id = toLong(map.get(crud.hID)); G22LeftArrowScript script = g22utils.getScript(id); if (anyContainsIgnoreCase(script.allTexts(), pat)) return true; return false; }); crud.addButton(new JPopDownButton().content("Show all scripts as one long text", runnableThread(new Runnable() { public void run() { try { showHugeText(); } catch (Exception __e) { throw rethrow(__e); } } public String toString() { return "showHugeText();"; } }))); return crud; } public JComponent makeDetailView(G22LeftArrowScript script) { scriptIDE(new G22LAScriptIDE(g22utils)); scriptIDE.setScript(script); return scriptIDE.visualize(); } public SimpleCRUD_v2 scriptCRUD() { return crud(); } public G22ScriptsPanel g22utils(G22Utils g22utils) { super.g22utils(g22utils); return this; } public void showHugeText() { String text = new G22ScriptUtil(g22utils).makeHugeText(g22utils.list(G22LeftArrowScript.class)); showFrame("Scripts in project", g22utils.newSyntaxTextArea(text)); } public void edit(G22LeftArrowScript script, LineAndColumn lineAndCol) { edit(script); print("scriptIDE", scriptIDE); print("Waiting for script IDE to appear for " + script); var ide = pollWaitUntilNotNull(100, 5.0, () -> { if (scriptIDE == null) return null; if (scriptIDE.script() != script) return null; return scriptIDE; }); print("Going to position " + lineAndCol + " in " + ide); { if (ide != null) ide.goToPositionInAllModes(lineAndCol); } } } static public class G22_RegionToSSIs implements IFieldsToList { public IImageRegion region; public G22_RegionToSSIs() { } public G22_RegionToSSIs(IImageRegion region) { this.region = region; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + region + ")"; } public Object[] _fieldsToList() { return new Object[] { region }; } public Color color; public List ssis; public List growingSSIs = new ArrayList(); public class GrowingSSI { final public GrowingSSI setY1(int y1) { return y1(y1); } public GrowingSSI y1(int y1) { this.y1 = y1; return this; } final public int getY1() { return y1(); } public int y1() { return y1; } public int y1; public ShortBuffer data = new ShortBuffer(); public int y2() { return y1 + l(data) / 2; } public SSI finish() { return new SSI(y1, y2()).data(data.toArray()).color(color); } } public List get() { if (region == null) return null; color = region.color(); ssis = new ArrayList(); Rect r = region.bounds(); int x1 = r.x1(), y1 = r.y1(), y2 = r.y2(), h = y2 - y1, w = r.w; for (int y = y1; y < y2; y++) { var _y_2 = y; List streaks = genericStreaks(w, x -> region.contains(x1 + x, _y_2)); while (longerThan(growingSSIs, streaks)) ssis.add(popLast(growingSSIs).finish()); for (int i = l(growingSSIs); i < l(streaks); i++) growingSSIs.add(new GrowingSSI().y1(_y_2)); for (var __0 : zipTwoLists(growingSSIs, streaks)) { var ssi = pairA(__0); var range = pairB(__0); ssi.data.add(toShort_enforce(x1 + range.start)); ssi.data.add(toShort_enforce(x1 + range.end)); } } for (var ssi : cloneAndClear(growingSSIs)) ssis.add(ssi.finish()); return ssis; } } static public class G22RegionThinner implements Steppable, IFieldsToList { public IImageRegion originalRegion; public G22RegionThinner() { } public G22RegionThinner(IImageRegion originalRegion) { this.originalRegion = originalRegion; } public String toString() { return shortClassName_dropNumberPrefix(this) + "(" + originalRegion + ")"; } public Object[] _fieldsToList() { return new Object[] { originalRegion }; } public Rect bounds; public boolean[] pixels; final public IImageRegion getRegion() { return region(); } public IImageRegion region() { return region; } public IImageRegion region = new IImageRegion() { public Rect bounds() { return bounds; } public boolean contains(int x, int y) { return containsPt(bounds, x, y) && pixels[idx(x, y)]; } public IterableIterator pixelIterator() { return iff_null(new IF0() { public int idx = 0; public Pt get() { for (; idx < pixels.length; idx++) if (pixels[idx]) return idxToPt(idx++); return null; } }); } }; public int idx(int x, int y) { return (y - bounds.y) * bounds.w + x - bounds.x; } public Pt idxToPt(int idx) { return pt(bounds.x + (idx % bounds.w), bounds.y + idx / bounds.w); } public void init() { if (bounds != null) return; bounds = originalRegion.bounds(); pixels = new boolean[area(bounds)]; for (Pt p : originalRegion.pixelIterator()) pixels[idx(p.x, p.y)] = true; } public boolean change = false; public boolean step() { init(); change = false; List traces = g22_allBorderTraces_withDiagonals(region); for (var points : traces) { if (eq(first(points), last(points))) removeLast(points); for (int i = 0; i < l(points); i++) { ping(); if (deletableBorderPoint(points, i)) { Pt p = points.get(i); pixels[idx(p.x, p.y)] = false; change = true; } } points.clear(); } return change; } public boolean deletableBorderPoint(PtBuffer points, int i) { List range = cyclicSubList(points, i - 1, i + 2); Pt lastPoint = cyclicGet(points, i - 1); Pt p = points.get(i); Pt diff = ptDiff(p, lastPoint); Pt l = ptPlus(p, rotatePtLeft(diff)); Pt r = ptPlus(p, rotatePtRight(diff)); boolean deletable = !range.contains(l) && region.contains(l) || !range.contains(r) && region.contains(r); return deletable; } public boolean deletableBorderPoint_v1(PtBuffer points, int i) { List range = cyclicSubList(points, i - 1, i + 2); Pt p = points.get(i); for (int dir = 1; dir <= 8; dir++) { Pt p2 = ptPlus(p, onePathDirection(dir)); if (region.contains(p2.x, p2.y) && !range.contains(p2)) { return true; } } return false; } public IImageRegion get() { return region; } } static public class BestWorstAndAverage { public IBest best = new Best(); public IBest worst = new Lowest(); public Average average = new Average(); public BestWorstAndAverage lowerIsBetter() { best = new Lowest(); worst = new Best(); return this; } public boolean put(A a, double score) { average.add(score); return best.put(a, score) | worst.put(a, score); } public String toString() { return renderVars("avg", average, "best", best, "worst", worst); } } static public class TickerSequence implements ByteIO, IntSize, IntegrityCheckable { public TickerSequence() { } final public TickerSequence setMarket(String market) { return market(market); } public TickerSequence market(String market) { this.market = market; return this; } final public String getMarket() { return market(); } public String market() { return market; } public String market; final public TickerSequence setPriceCells(PriceCells priceCells) { return priceCells(priceCells); } public TickerSequence priceCells(PriceCells priceCells) { this.priceCells = priceCells; return this; } final public PriceCells getPriceCells() { return priceCells(); } public PriceCells priceCells() { return priceCells; } public PriceCells priceCells; final public TickerSequence setLive(boolean live) { return live(live); } public TickerSequence live(boolean live) { this.live = live; return this; } final public boolean getLive() { return live(); } public boolean live() { return live; } public boolean live = false; final public TickerSequence setLoading(boolean loading) { return loading(loading); } public TickerSequence loading(boolean loading) { this.loading = loading; return this; } final public boolean getLoading() { return loading(); } public boolean loading() { return loading; } public boolean loading = false; public ILongBuffer timestamps = new SynchronizedLongBuffer(); public IDoubleBuffer prices = new SynchronizedFloatBufferPresentingAsDoubles(); final public TickerSequence setLastTickerEvent(long lastTickerEvent) { return lastTickerEvent(lastTickerEvent); } public TickerSequence lastTickerEvent(long lastTickerEvent) { this.lastTickerEvent = lastTickerEvent; return this; } final public long getLastTickerEvent() { return lastTickerEvent(); } public long lastTickerEvent() { return lastTickerEvent; } public long lastTickerEvent; final public TickerSequence setEpsilon(double epsilon) { return epsilon(epsilon); } public TickerSequence epsilon(double epsilon) { this.epsilon = epsilon; return this; } final public double getEpsilon() { return epsilon(); } public double epsilon() { return epsilon; } public double epsilon = 1e-6; transient public Set> onPricePointAdded; public TickerSequence onPricePointAdded(IVF1 f) { onPricePointAdded = createOrAddToSyncLinkedHashSet(onPricePointAdded, f); return this; } public TickerSequence removePricePointAddedListener(IVF1 f) { loadableUtils.utils.remove(onPricePointAdded, f); return this; } public void pricePointAdded(long timestamp) { if (onPricePointAdded != null) for (var listener : onPricePointAdded) pcallF_typed(listener, timestamp); } transient public Set onNewTickerEvent; public TickerSequence onNewTickerEvent(Runnable r) { onNewTickerEvent = createOrAddToSyncLinkedHashSet(onNewTickerEvent, r); return this; } public TickerSequence removeNewTickerEventListener(Runnable r) { loadableUtils.utils.remove(onNewTickerEvent, r); return this; } public void newTickerEvent() { if (onNewTickerEvent != null) for (var listener : onNewTickerEvent) pcallF_typed(listener); } public TickerSequence(String market) { this.market = market; } public void addIfPriceChanged(double price, Timestamp timestamp) { addIfPriceChanged(price, toLong(timestamp)); } synchronized public void addIfPriceChanged(double price, long timestamp) { if (isEmpty() || differentByEpsilonRatio(prices.last(), price, epsilon)) add(price, timestamp); updateTickerEvent(timestamp); } public void updateTickerEvent(long timestamp) { if (timestamp > lastTickerEvent) { lastTickerEvent(timestamp); newTickerEvent(); } } final public void addPrice(double price, long timestamp) { add(price, timestamp); } synchronized public void add(double price, long timestamp) { timestamps.add(timestamp); prices.add(price); pricePointAdded(timestamp); updateTickerEvent(timestamp); } synchronized public void add(double[] prices, long[] timestamps) { assertEquals(l(prices), l(timestamps)); if (empty(prices)) return; this.prices.addAll(asList(prices)); this.timestamps.addAll(asList(timestamps)); lastTickerEvent = max(lastTickerEvent, endTime()); } synchronized public void add(TickerSequence ticker) { add(ticker.prices.toArray(), ticker.timestamps.toArray()); } synchronized public String toString() { return commaCombine(spaceCombine("Ticker", market, priceCells == null ? null : roundBracket(priceCells)), formatDays(duration()), n2(l(prices), "price point"), timeRange()); } public synchronized TickerSequence clone() { return subSequence(0, size()); } public TickerSequence emptyClone() { return new TickerSequence().market(market); } synchronized public TickerSequence subSequence(int start) { return subSequence(start, size()); } synchronized public TickerSequence subSequence(int start, int end) { var s = emptyClone(); s.add(cloneSubDoubleArray(prices.toArray(), start, end), cloneSubLongArray(timestamps.toArray(), start, end)); return s; } synchronized public TickerSequence cutOffAfterSeconds(double seconds) { int idx = indexOfTimestamp(startTime() + secondsToMS(seconds)); return subSequence(0, idx); } public TickerSequence dropFirstDays(double days) { return subSequenceFromTimestamp(startTime() + daysToMS(days)); } public TickerSequence takeFirstDays(double days) { return cutOffAfterSeconds(daysToSeconds(days)); } public TickerSequence takeFirstHours(double days) { return cutOffAfterSeconds(hoursToSeconds(days)); } public TickerSequence takeLastDays(double days) { return subSequenceFromTimestamp(endTime() - daysToMS(days)); } public TickerSequence takeLastHours(double hours) { return takeLastDays(hoursToDays(hours)); } public TickerSequence takeLastMinutes(double minutes) { return takeLastDays(minutesToDays(minutes)); } synchronized public TickerSequence subSequenceByTimestamps(long from, long to) { int idx1 = indexOfTimestamp(from); int idx2 = indexOfTimestamp(to); return subSequence(idx1, idx2); } synchronized public TickerSequence subSequenceFromTimestamp(long from) { return subSequence(indexOfTimestamp(from)); } synchronized public TickerSequence subSequenceToTimestamp(long to) { return subSequence(0, indexOfTimestamp(to)); } synchronized public int indexOfTimestamp(double ts) { return binarySearch_insertionPoint(timestamps.asVirtualList(), lround(ts)); } synchronized public int indexOfTimestampAtOrBefore(double ts) { return binarySearch_tipToTheLeft(timestamps.asVirtualList(), lround(ts)); } synchronized public long nextTimestamp(double ts) { return getTimestamp(indexOfTimestamp(ts) + 1); } synchronized public double priceAtTimestamp(double ts) { return getPrice(indexOfTimestampAtOrBefore(ts)); } public int size() { return l(prices); } public boolean isEmpty() { return size() == 0; } synchronized public TimestampRange timeRange() { return isEmpty() ? null : new TimestampRange(startTime(), endTime()); } public Duration duration() { return main.duration(timeRange()); } synchronized public long startTime() { return empty(timestamps) ? 0 : first(timestamps); } synchronized public long endTime() { return max(lastTickerEvent, empty(timestamps) ? 0 : last(timestamps)); } synchronized public double getPrice(int i) { return isEmpty() ? Double.NaN : prices.get(clampToLength(size(), i)); } synchronized public long getTimestamp(int i) { return isEmpty() ? 0 : timestamps.get(clampToLength(size(), i)); } synchronized public TickerSequence removePlateaus() { var seq = emptyClone(); int n = size(); for (int i = 0; i < n; i++) { var value = getPrice(i); seq.prices.add(value); seq.timestamps.add(getTimestamp(i)); while (i + 1 < n && getPrice(i + 1) == value) ++i; } return seq.trimToSize(); } synchronized public TickerSequence removeZeros() { if (!prices.contains(0)) return this; var seq = emptyClone(); int n = size(); for (int i = 0; i < n; i++) { var value = getPrice(i); if (value != 0) { seq.prices.add(value); seq.timestamps.add(getTimestamp(i)); } } return seq.trimToSize(); } synchronized public TickerSequence alignTimestamps(int interval) { var seq = emptyClone(); int n = size(); for (int i = 0; i < n; i++) { var value = getPrice(i); long time = roundDownTo(interval, getTimestamp(i)); if (time != seq.endTime()) seq.addIfPriceChanged(value, time); } return seq.trimToSize(); } public TickerSequence trimToSize() { prices.trimToSize(); timestamps.trimToSize(); return this; } public double minPrice() { return doubleMin(prices.toArray()); } public double maxPrice() { return doubleMax(prices.toArray()); } public DoubleRange priceRange() { return doubleRange(minPrice(), maxPrice()); } synchronized public double firstPrice() { return empty(prices) ? Double.NaN : prices.first(); } synchronized public double lastPrice() { return empty(prices) ? Double.NaN : prices.last(); } synchronized public TickerPoint lastPoint() { return new TickerPoint(this, endTime()); } static public Pattern reBestAsk = regexp("\"bestAsk\":([0-9\\.]+)"); static public Pattern reSystemTime = regexp("\"systemTime\":(\\d+)"); synchronized public void addJSONLine_fast(String line) { long time = toLong(regexpFirstGroup(reSystemTime, line)); if (time > lastTickerEvent) { double price = toDouble(regexpFirstGroup(reBestAsk, line)); if (price != 0) addIfPriceChanged(price, time); } } transient public IVF1 addJSONLine; public void addJSONLine(String line) { if (addJSONLine != null) addJSONLine.get(line); else addJSONLine_base(line); } final public void addJSONLine_fallback(IVF1 _f, String line) { if (_f != null) _f.get(line); else addJSONLine_base(line); } public void addJSONLine_base(String line) { addJSONLine_fast(line); } synchronized public void addJSONLine_slow(String line) { Map data = parseJSONMap(line); double price = toDouble(data.get("bestAsk")); long time = toLong(data.get("systemTime")); if (time > lastTickerEvent) addIfPriceChanged(price, time); } final public UpDownSequence upDownSequence() { return toUpDownSequence(); } public UpDownSequence toUpDownSequence() { return toUpDownSequence(priceCells); } final public UpDownSequence upDownSequence(PriceCells cells) { return toUpDownSequence(cells); } public UpDownSequence toUpDownSequence(PriceCells cells) { if (cells == null) return null; var dig = digitize(new PriceDigitizer2(cells)); List cellNumbers = dig.roundedCellNumbers(); return UpDownSequence.fromInts(cellNumbers); } public TickerSequence digitizeToPercent(double cellSizeInPercent) { return digitizeToPercent(firstPrice(), cellSizeInPercent); } public TickerSequence digitizeToPercent(double basePrice, double cellSizeInPercent) { if (isEmpty()) return this; return digitize(geometricPriceDigitizer(basePrice, cellSizeInPercent)); } public TickerSequence digitize(PriceDigitizer2 digitizer) { var seq = emptyClone(); seq.priceCells(digitizer.priceCells()); int n = size(); for (int i = 0; i < n; i++) { seq.addIfPriceChanged(digitizer.digitize(getPrice(i)), getTimestamp(i)); } return seq.trimToSize(); } public List pricePoints() { return listFromFunction(__90 -> getPricePoint(__90), size()); } synchronized public PricePoint getPricePoint(int idx) { return idx >= 0 && idx < size() ? new PricePoint(timestamps.get(idx), prices.get(idx)) : null; } public PricePoint firstPricePoint() { return getPricePoint(0); } synchronized public PricePoint lastPricePoint() { return getPricePoint(size() - 1); } public List roundedCellNumbers() { return map(__91 -> iround(__91), cellNumbers()); } public List cellNumbers() { if (priceCells == null) return null; int n = size(); DoubleBuffer buf = new DoubleBuffer(n); for (int i = 0; i < n; i++) buf.add(priceCells.toCellNumber(getPrice(i))); return buf.asVirtualList(); } public TickerSequence toCellNumbers() { if (priceCells == null) return null; TickerSequence seq = new TickerSequence(); seq.market(market + " cell numbers " + roundBracket(priceCells)); int n = size(); for (int i = 0; i < n; i++) seq.add(priceCells.toCellNumber(getPrice(i)), getTimestamp(i)); return seq.trimToSize(); } public void dropLastPricePoint() { if (isEmpty()) return; prices.popLast(); timestamps.popLast(); lastTickerEvent = endTime(); newTickerEvent(); } public TickerSequence marketIfEmpty(String market) { if (empty(this.market)) market(market); return this; } public TickerSequence legacyCompact() { if (!(prices instanceof SynchronizedFloatBufferPresentingAsDoubles)) prices = new SynchronizedFloatBufferPresentingAsDoubles(prices.toArray()); return this; } public boolean compactTimestamps() { return compactTimestamps(20); } public boolean compactTimestamps(long msUnit) { if (!(timestamps instanceof SynchronizedLongBufferStoredAsLinearInts)) { timestamps = new SynchronizedLongBufferStoredAsLinearInts(roundDownTo(msUnit, startTime()), msUnit, timestamps); return true; } return false; } public double averageTimeStep() { return doubleRatio(endTime() - startTime(), size() - 1); } public void write(ByteHead head) { head.writeString(market); SynchronizedLongBufferStoredAsLinearInts timestamps = (SynchronizedLongBufferStoredAsLinearInts) (this.timestamps); head.writeLong(timestamps.base); head.writeLong(timestamps.factor); int n = size(); head.writeInt(n); for (int i = 0; i < n; i++) { head.writeInt(timestamps.getRaw(i)); head.writeFloat((float) prices.get(i)); } } public void readWrite(ByteHead head) { if (head.readMode()) readImpl(head); if (head.writeMode()) write(head); } static public TickerSequence read(ByteHead head) { TickerSequence t = new TickerSequence(); if (!t.readImpl(head)) return null; return t; } public boolean readImpl(ByteHead head) { market = head.readString(); if (head.eof()) return false; long base = head.readLong(); long factor = head.readLong(); var timestamps = new SynchronizedLongBufferStoredAsLinearInts(base, factor); this.timestamps = timestamps; int n = head.readInt(); for (int i = 0; i < n; i++) { int time = head.readInt(); if (head.eof()) break; timestamps.addRaw(time); prices.add(head.readFloat()); } trimToSize(); return true; } public TickerSequence loadJSONFile(File f) { var it = linesFromFile(f); try { for (var line : it) { try { addJSONLine(line); } catch (Throwable __e) { pcallFail(__e); } } return trimToSize(); } finally { _close(it); } } synchronized public void insertAt(int idx, TickerSequence ticker) { prices.insertAt(idx, ticker.prices.toArray()); timestamps.insertAt(idx, ticker.timestamps.toArray()); } public void integrityCheck() { timestamps.integrityCheck(); prices.integrityCheck(); assertEquals(l(timestamps), l(prices)); } } static public class RecursiveObjectSize { public long size; public SimpleStack stack = new SimpleStack(); public Set seen = new CompactIdentityHashSet(); public Set fieldsToIgnore; public Set realmsToIgnore; final public RecursiveObjectSize setDummySizeForUnknownObject(int dummySizeForUnknownObject) { return dummySizeForUnknownObject(dummySizeForUnknownObject); } public RecursiveObjectSize dummySizeForUnknownObject(int dummySizeForUnknownObject) { this.dummySizeForUnknownObject = dummySizeForUnknownObject; return this; } final public int getDummySizeForUnknownObject() { return dummySizeForUnknownObject(); } public int dummySizeForUnknownObject() { return dummySizeForUnknownObject; } public int dummySizeForUnknownObject = 24; final public RecursiveObjectSize setSkipTransientFields(boolean skipTransientFields) { return skipTransientFields(skipTransientFields); } public RecursiveObjectSize skipTransientFields(boolean skipTransientFields) { this.skipTransientFields = skipTransientFields; return this; } final public boolean getSkipTransientFields() { return skipTransientFields(); } public boolean skipTransientFields() { return skipTransientFields; } public boolean skipTransientFields = false; transient public IVF1