Examples with Object_ suite.util.Object_ used on opensource projects

Example 1 with Object_

use of suite.util.Object_ in project suite by stupidsing.

the class Scheduler method run.

public void run() {
    while (!schedules.isEmpty()) {
        List<Schedule> schedules1 = new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime nextWakeUpDateTime = // 
        Read.from(// 
        schedules).map(// 
        schedule -> schedule.nextRunDateTime).min(Object_::compare);
        Thread_.sleepQuietly(Duration.between(now, nextWakeUpDateTime).toMillis());
        for (Schedule schedule : schedules) if (now.isBefore(schedule.nextRunDateTime))
            schedules1.add(schedule);
        else
            try {
                schedules1.addAll(schedule.run.source());
            } catch (Exception ex) {
                LogUtil.error(ex);
            }
        schedules = schedules1;
    }
}

Example 2 with Object_

use of suite.util.Object_ in project suite by stupidsing.

the class BackTestMain method run.

@Override
protected boolean run(String[] args) {
    // BEGIN
    // END
    String arg0 = 0 < args.length ? args[0] : "";
    String arg1 = 1 < args.length ? args[1] : "";
    String arg2 = 2 < args.length ? args[2] : "";
    Streamlet<String> strategyMatches = !arg0.isEmpty() ? Read.from(arg0.split(",")) : null;
    Streamlet<Integer> years = !arg1.isEmpty() ? // 
    Read.from(// 
    arg1.split(",")).concatMap(s -> {
        Pair<String, String> pair = ParseUtil.search(s, "-", Assoc.RIGHT);
        return // 
        pair != null ? // 
        Ints_.range(Integer.valueOf(pair.t0), Integer.valueOf(pair.t1)).map(i -> i) : Read.each(Integer.valueOf(s));
    }) : // 
    Ints_.range(2007, Trade_.thisYear).map(i -> i);
    Fun<Time, Streamlet<Asset>> fun = // 
    !arg2.isEmpty() ? // 
    time -> Read.from(arg2.split(",")).map(cfg::queryCompany).collect(As::streamlet) : cfg::queryCompaniesByMarketCap;
    BackAllocConfigurations bac_ = new BackAllocConfigurations(cfg, fun);
    Streamlet2<String, BackAllocConfiguration> bacByTag = bac_.bacs().bacByName;
    Streamlet2<String, Simulate> simulationByKey = // 
    bacByTag.filterKey(// 
    n -> strategyMatches == null || strategyMatches.isAny(sm -> Wildcard.match(sm, n) != null)).map(// 
    Pair::of).join2(// 
    years.sort(Object_::compare).map(TimeRange::ofYear)).map2((pair, period) -> pair.t0, (pair, period) -> {
        BackAllocConfiguration bac = pair.t1;
        Streamlet<Asset> assets = bac.assetsFun.apply(period.from);
        return runner.backTest(bac.backAllocator, period, assets);
    }).collect(As::streamlet2);
    String content0 = // 
    Read.bytes(// 
    Paths.get("src/main/java/" + getClass().getName().replace('.', '/') + ".java")).collect(// 
    As::utf8decode).map(// 
    Chars::toString).collect(As::joined);
    String content1 = ParseUtil.fit(content0, "// BEGIN", "// END")[1];
    System.out.println(content1);
    System.out.println(runner.conclude(simulationByKey));
    return true;
}

Example 3 with Object_

use of suite.util.Object_ in project suite by stupidsing.

the class Google method quote_.

private synchronized Map<String, Float> quote_(Streamlet<String> symbols) {
    if (0 < symbols.size()) {
        URL url = To.url(// 
        "http://finance.google.com/finance/info?client=ig&q=HKEX%3A" + symbols.sort(Object_::compare).map(this::fromSymbol).collect(As.joinedBy(",")));
        JsonNode json = Rethrow.ex(() -> {
            try (InputStream is = HttpUtil.get(url).out.collect(To::inputStream)) {
                for (int i = 0; i < 4; i++) is.read();
                return mapper.readTree(is);
            }
        });
        return // 
        Read.from(// 
        json).map2(json_ -> toSymbol(json_.get("t").textValue()), // 
        json_ -> Float.parseFloat(json_.get("l").textValue().replace(",", ""))).toMap();
    } else
        return new HashMap<>();
}

Example 4 with Object_

use of suite.util.Object_ in project suite by stupidsing.

the class OtfTest method otfTest.

@Test
public void otfTest() {
    String familyKey = "Family";
    String subfamilyKey = "Subfamily";
    List<String> keys = List.of(familyKey, subfamilyKey);
    List<String> commands = // 
    Read.each(// 
    "/tmp/fonts").map(// 
    Paths::get).concatMap(// 
    FileUtil::findPaths).map(// 
    Path::toString).filter(path -> {
        String pathl = path.toLowerCase();
        return pathl.endsWith(".otf") || pathl.endsWith(".ttf");
    }).map2(path -> {
        Execute exec = new Execute(new String[] { "otfinfo", "-i", path });
        return // 
        Read.from(// 
        exec.out.split("\n")).map(// 
        line -> line.split(":")).filter(// 
        arr -> 2 <= arr.length).map2(arr -> arr[0].trim(), // 
        arr -> arr[1].trim()).filterKey(// 
        keys::contains).toMap();
    }).map((k, m) -> {
        String f = m.get(familyKey);
        String sf = m.get(subfamilyKey);
        String dir = "/home/ywsing/.fonts/" + f + "/";
        String ext = k.substring(k.lastIndexOf(".") + 1).toLowerCase();
        return "mkdir -p '" + dir + "'; mv '" + k + "' '" + dir + f + " " + sf + "." + ext + "'";
    }).sort(// 
    Object_::compare).toList();
    for (String command : commands) System.out.println(command);
}

Example 5 with Object_

use of suite.util.Object_ in project suite by stupidsing.

the class SewingProverImpl method compileTr.

private Trampoline compileTr(BinderFactory bf, Node node) {
    List<Node> list;
    Trampoline tr;
    Tree tree;
    Node[] m;
    if (1 < (list = TreeUtil.breakdown(TermOp.AND___, node)).size())
        tr = andTr(Read.from(list).map(n -> compileTr(bf, n)));
    else if (1 < (list = TreeUtil.breakdown(TermOp.OR____, node)).size())
        tr = orTr(Read.from(list).map(n -> compileTr(bf, n)));
    else if ((m = Suite.pattern(".0 = .1").match(node)) != null) {
        boolean b = complexity(m[0]) <= complexity(m[1]);
        Node n0 = b ? m[0] : m[1];
        Node n1 = b ? m[1] : m[0];
        Bind_ p = bf.binder(n1);
        Clone_ f = bf.cloner(n0);
        tr = rt -> p.test(rt, f.apply(rt.env)) ? okay : fail;
    } else if ((m = Suite.pattern("builtin:.0:.1 .2").match(node)) != null) {
        String className = ((Atom) m[0]).name;
        String fieldName = ((Atom) m[1]).name;
        BuiltinPredicate predicate = Rethrow.ex(() -> {
            Class<?> clazz = Class.forName(className);
            return (BuiltinPredicate) clazz.getField(fieldName).get(Object_.new_(clazz));
        });
        tr = compileTrCallPredicate(bf, predicate, m[2]);
    } else if ((m = Suite.pattern("find.all .0 .1 .2").match(node)) != null) {
        Clone_ f = bf.cloner(m[0]);
        Trampoline tr1 = compileTr(bf, m[1]);
        Bind_ p = bf.binder(m[2]);
        List<Node> vs = new ArrayList<>();
        tr = rt -> {
            Restore restore = save(rt);
            rt.pushRem(rt_ -> {
                vs.add(new Cloner().clone(f.apply(rt_.env)));
                return fail;
            });
            rt.pushAlt(rt_ -> {
                restore.restore(rt);
                return p.test(rt, Tree.of(TermOp.AND___, vs)) ? okay : fail;
            });
            return tr1;
        };
    } else if ((m = Suite.pattern("if .0 .1 .2").match(node)) != null) {
        Trampoline tr0 = compileTr(bf, m[0]);
        Trampoline tr1 = compileTr(bf, m[1]);
        Trampoline tr2 = compileTr(bf, m[2]);
        tr = if_(tr0, tr1, tr2);
    } else if ((m = Suite.pattern("let .0 .1").match(node)) != null) {
        Bind_ p = bf.binder(m[0]);
        Evaluate_ eval = new CompileExpressionImpl(bf).evaluator(m[1]);
        tr = rt -> p.test(rt, Int.of(eval.evaluate(rt.env))) ? okay : fail;
    } else if ((m = Suite.pattern("list.fold .0/.1/.2 .3").match(node)) != null) {
        Clone_ list0_ = bf.cloner(m[0]);
        Clone_ value0_ = bf.cloner(m[1]);
        Bind_ valuex_ = bf.binder(m[2]);
        Clone_ ht_ = bf.cloner(m[3]);
        tr = rt -> {
            Node[] ht = Suite.pattern(".0 .1").match(ht_.apply(rt.env));
            Trampoline tr1 = saveEnvTr(compileTrRule(ht[0], ht[1]));
            Mutable<Node> current = Mutable.of(value0_.apply(rt.env));
            rt.pushRem(rt_ -> valuex_.test(rt_, current.get()) ? okay : fail);
            for (Node elem : Tree.iter(list0_.apply(rt.env))) {
                Reference result = new Reference();
                rt.pushRem(rt_ -> {
                    current.update(result.finalNode());
                    return okay;
                });
                rt.pushRem(rt_ -> {
                    rt_.query = Tree.of(TermOp.ITEM__, Tree.of(TermOp.ITEM__, elem, current.get()), result);
                    return tr1;
                });
            }
            return okay;
        };
    } else if ((m = Suite.pattern("list.fold.clone .0/.1/.2 .3/.4/.5 .6").match(node)) != null) {
        Clone_ list0_ = bf.cloner(m[0]);
        Clone_ value0_ = bf.cloner(m[1]);
        Bind_ valuex_ = bf.binder(m[2]);
        Bind_ elem_ = bf.binder(m[3]);
        Bind_ v0_ = bf.binder(m[4]);
        Clone_ vx_ = bf.cloner(m[5]);
        Trampoline tr1 = compileTr(bf, m[6]);
        tr = rt -> {
            Mutable<Node> current = Mutable.of(value0_.apply(rt.env));
            Env env0 = rt.env;
            rt.pushRem(rt_ -> {
                rt_.env = env0;
                return valuex_.test(rt_, current.get()) ? okay : fail;
            });
            for (Node elem : Tree.iter(list0_.apply(rt.env))) {
                rt.pushRem(rt_ -> {
                    current.update(vx_.apply(rt_.env));
                    return okay;
                });
                rt.pushRem(rt_ -> {
                    rt_.env = env0.clone();
                    return elem_.test(rt_, elem) && v0_.test(rt_, current.get()) ? tr1 : fail;
                });
            }
            return okay;
        };
    } else if ((m = Suite.pattern("list.query .0 .1").match(node)) != null) {
        Clone_ l_ = bf.cloner(m[0]);
        Clone_ ht_ = bf.cloner(m[1]);
        tr = rt -> {
            Node[] ht = Suite.pattern(".0 .1").match(ht_.apply(rt.env));
            Trampoline tr1 = saveEnvTr(compileTrRule(ht[0], ht[1]));
            for (Node n : Tree.iter(l_.apply(rt.env))) rt.pushRem(rt_ -> {
                rt_.query = n;
                return tr1;
            });
            return okay;
        };
    } else if ((m = Suite.pattern("list.query.clone .0 .1 .2").match(node)) != null) {
        Clone_ f = bf.cloner(m[0]);
        Bind_ p = bf.binder(m[1]);
        Trampoline tr1 = compileTr(bf, m[2]);
        tr = rt -> {
            Env env0 = rt.env;
            rt.pushRem(rt_ -> {
                rt_.env = env0;
                return okay;
            });
            for (Node n : Tree.iter(f.apply(rt.env))) rt.pushRem(rt_ -> {
                rt_.env = env0.clone();
                return p.test(rt_, n) ? tr1 : fail;
            });
            return okay;
        };
    } else if ((m = Suite.pattern("member .0 .1").match(node)) != null && TreeUtil.isList(m[0], TermOp.AND___)) {
        List<Bind_> elems_ = Read.from(Tree.iter(m[0])).map(bf::binder).toList();
        Clone_ f = bf.cloner(m[1]);
        tr = rt -> {
            Iterator<Bind_> iter = elems_.iterator();
            Trampoline[] alt = new Trampoline[1];
            Restore restore = save(rt);
            return alt[0] = rt_ -> {
                while (iter.hasNext()) {
                    restore.restore(rt);
                    if (iter.next().test(rt_, f.apply(rt.env))) {
                        rt_.pushAlt(alt[0]);
                        return okay;
                    }
                }
                return fail;
            };
        };
    } else if ((m = Suite.pattern("not .0").match(node)) != null)
        tr = if_(compileTr(bf, m[0]), fail, okay);
    else if ((m = Suite.pattern("once .0").match(node)) != null) {
        Trampoline tr0 = compileTr(bf, m[0]);
        tr = rt -> {
            IList<Trampoline> alts0 = rt.alts;
            rt.pushRem(rt_ -> {
                rt_.alts = alts0;
                return okay;
            });
            return tr0;
        };
    } else if ((m = Suite.pattern("suspend .0 .1 .2").match(node)) != null) {
        Clone_ f0 = bf.cloner(m[0]);
        Clone_ f1 = bf.cloner(m[1]);
        Trampoline tr0 = compileTr(bf, m[2]);
        tr = rt -> {
            List<Node> results = new ArrayList<>();
            Env env = rt.env;
            Trampoline tr_ = andTr(Read.each(tr0, rt_ -> {
                results.add(f1.apply(env));
                return fail;
            }));
            Node n0 = f0.apply(rt.env);
            Suspend suspend = new Suspend(() -> {
                Runtime rt_ = new Runtime(rt, tr_);
                rt_.trampoline();
                return Read.from(results).uniqueResult();
            });
            if (n0 instanceof Reference) {
                rt.trail.addBind((Reference) n0, suspend);
                return okay;
            } else
                return fail;
        };
    } else if ((m = Suite.pattern("throw .0").match(node)) != null) {
        Clone_ f = bf.cloner(m[0]);
        tr = rt -> {
            rt.handler.sink(new Cloner().clone(f.apply(rt.env)));
            return okay;
        };
    } else if ((m = Suite.pattern("try .0 .1 .2").match(node)) != null) {
        Trampoline tr0 = compileTr(bf, m[0]);
        Bind_ p = bf.binder(m[1]);
        Trampoline catch0 = compileTr(bf, m[2]);
        tr = rt -> {
            BindEnv be = rt;
            Restore restore = save(rt);
            IList<Trampoline> alts0 = rt.alts;
            Sink<Node> handler0 = rt.handler;
            rt.handler = node_ -> {
                restore.restore(rt);
                if (p.test(be, node_)) {
                    rt.alts = alts0;
                    rt.pushRem(catch0);
                } else
                    handler0.sink(node_);
            };
            rt.pushRem(rt_ -> {
                rt_.handler = handler0;
                return okay;
            });
            return tr0;
        };
    } else if ((m = Suite.pattern(".0 .1").match(node)) != null && m[0] instanceof Atom)
        tr = compileTrCallPredicate(bf, ((Atom) m[0]).name, m[1], node);
    else if (node instanceof Atom) {
        String name = ((Atom) node).name;
        if (node == ProverConstant.cut)
            tr = cutEnd();
        else if (String_.equals(name, ""))
            tr = okay;
        else if (String_.equals(name, "fail"))
            tr = fail;
        else
            tr = compileTrCallPredicate(bf, name, Atom.NIL, node);
    } else if (node instanceof Data<?>) {
        Object data = ((Data<?>) node).data;
        if (data instanceof Source<?>)
            tr = rt -> ((Source<?>) data).source() != Boolean.TRUE ? okay : fail;
        else
            tr = Fail.t("cannot understand " + node);
    } else if (node instanceof Reference) {
        Clone_ f = bf.cloner(node);
        tr = rt -> compileTr(passThru, f.apply(rt.env));
    } else if ((tree = Tree.decompose(node)) != null)
        tr = compileTrCallPredicate(bf, tree.getOperator().getName(), node, node);
    else if (node instanceof Tuple)
        tr = compileTrCallPredicate(bf, node);
    else
        tr = Fail.t("cannot understand " + node);
    return tr;
}