Examples with Tuple3 org.jparsec.functors.Tuple3 used on opensource projects

Example 86 with Tuple3

use of org.jparsec.functors.Tuple3 in project fql by CategoricalData.

the class XRaToFpql method toFlower.

@SuppressWarnings({ "rawtypes", "unchecked" })
private static EFlower toFlower(Object decl) {
    Map<String, Pair<String, String>> select = new LinkedHashMap<>();
    Map<String, String> from = new LinkedHashMap<>();
    List<Pair<Pair<String, String>, Pair<String, String>>> where = new LinkedList<>();
    Tuple3 o = (Tuple3) decl;
    Tuple3 select0 = (Tuple3) o.a;
    org.jparsec.functors.Pair from0 = (org.jparsec.functors.Pair) o.b;
    org.jparsec.functors.Pair where0 = (org.jparsec.functors.Pair) o.c;
    boolean distinct;
    distinct = select0.b != null;
    List<Tuple3> select1 = (List<Tuple3>) select0.c;
    for (Tuple3 k : select1) {
        Tuple3 a = (Tuple3) k.a;
        String b = k.c.toString();
        select.put(b, new Pair<>(a.a.toString(), a.c.toString()));
    }
    List<Tuple3> from1 = (List<Tuple3>) from0.b;
    for (Tuple3 k : from1) {
        from.put(k.c.toString(), k.a.toString());
    }
    if (where0 != null) {
        List<Tuple3> where1 = (List<Tuple3>) where0.b;
        for (Tuple3 k : where1) {
            Tuple3 l = (Tuple3) k.a;
            if (k.c instanceof Tuple3) {
                Tuple3 r = (Tuple3) k.c;
                where.add(new Pair<>(new Pair<>(l.a.toString(), l.c.toString()), new Pair<>(r.a.toString(), r.c.toString())));
            } else {
                String r = (String) k.c;
                where.add(new Pair<>(new Pair<>(l.a.toString(), l.c.toString()), new Pair<>(r, null)));
            }
        }
    }
    return new EFlower(select, from, where, distinct);
}

Example 87 with Tuple3

use of org.jparsec.functors.Tuple3 in project fql by CategoricalData.

the class XSqlToFql method toEInsertValues.

@SuppressWarnings({ "rawtypes", "unchecked" })
private static EInsertValues toEInsertValues(Object decl) {
    Tuple5 t = (Tuple5) decl;
    String target = t.b.toString();
    List<Tuple3> x = (List<Tuple3>) t.d;
    List<List<String>> values = new LinkedList<>();
    for (Tuple3 y : x) {
        List<String> l = (List<String>) y.b;
        values.add(l);
    }
    return new EInsertValues(target, values);
}

Example 88 with Tuple3

use of org.jparsec.functors.Tuple3 in project fql by CategoricalData.

the class XSqlToFql method program.

@SuppressWarnings({ "unchecked", "rawtypes" })
private static List<EExternal> program(String s) {
    List<EExternal> ret = new LinkedList<>();
    List<Tuple3> decls = (List<Tuple3>) program.parse(s);
    for (Tuple3 decl : decls) {
        if (decl.a.toString().equals("CREATE")) {
            ret.add(toECreateTable(decl));
        } else if (decl.toString().startsWith("((INSERT")) {
            ret.add(toEInsertValues(decl));
        } else {
            throw new RuntimeException(decl.toString());
        }
    }
    return ret;
}

Example 89 with Tuple3

use of org.jparsec.functors.Tuple3 in project fql by CategoricalData.

the class CombinatorParser method mapExpRaw.

// TODO: aql reverse order on arguments env
private static Parser<MapExpRaw> mapExpRaw() {
    Parser<List<catdata.Pair<LocStr, List<String>>>> fks = Parsers.tuple(token("foreign_keys"), env(ident.sepBy1(token(".")), "->")).map(x -> x.b);
    Parser<Tuple5<Token, String, Pair<Token, String>, Token, RawTerm>> lp0 = Parsers.tuple(token("lambda"), ident, Parsers.tuple(token(":"), ident).optional(), token("."), term());
    Parser<Tuple5<Token, String, Pair<Token, String>, Token, RawTerm>> lq = ident.sepBy1(token(".")).map(x -> {
        // TODO aql
        RawTerm term = RawTerm.fold(x, "_x");
        return new Tuple5<>(null, "_x", new Pair<>(null, null), null, term);
    });
    Parser<Tuple5<Token, String, Pair<Token, String>, Token, RawTerm>> lp = Parsers.or(lp0, lq);
    Parser<List<catdata.Pair<LocStr, Triple<String, String, RawTerm>>>> envp = env(lp.map(x -> new Triple<>(x.b, x.c == null ? null : x.c.b, x.e)), "->");
    Parser<List<catdata.Pair<LocStr, Triple<String, String, RawTerm>>>> atts = Parsers.tuple(token("attributes"), envp).map(x -> x.b);
    // List<Pair<LocStr, Triple<String, List<Pair<LocStr, List<String>>>,
    // List<Pair<LocStr, Triple<String, String, RawTerm>>>>>> list,
    Parser<List<catdata.Pair<LocStr, String>>> ens = Parsers.tuple(token("entities"), env(ident, "->")).map(x -> x.b);
    Parser<Tuple3<List<LocStr>, List<catdata.Pair<LocStr, Triple<String, List<catdata.Pair<LocStr, List<String>>>, List<catdata.Pair<LocStr, Triple<String, String, RawTerm>>>>>>, List<catdata.Pair<String, String>>>> pa = Parsers.tuple(imports, Parsers.tuple(token("entity"), locstr.followedBy(token("->")), ident, fks.optional(), atts.optional()).map(x -> new catdata.Pair<>(x.b, new Triple<>(x.c, Util.newIfNull(x.d), Util.newIfNull(x.e)))).many(), options);
    Parser<Tuple5<Token, Token, SchExp<?, ?, ?, ?, ?>, SchExp<?, ?, ?, ?, ?>, Token>> l = Parsers.tuple(token("literal"), token(":"), sch_ref.lazy().followedBy(token("->")), sch_ref.lazy(), token("{"));
    // List<Pair<LocStr, Triple<String, List<Pair<LocStr, List<String>>>,
    // List<Pair<LocStr, Triple<String, String, RawTerm>>>>>> list,
    Parser<MapExpRaw> ret = Parsers.tuple(l, pa, token("}")).map(x -> new MapExpRaw(x.a.c, x.a.d, x.b.a, x.b.b, x.b.c));
    return ret;
}

Example 90 with Tuple3

use of org.jparsec.functors.Tuple3 in project fql by CategoricalData.

the class CombinatorParser method instExpQuotient.

private static Parser<InstExpQuotient<?, ?>> instExpQuotient() {
    Parser<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>> eq = Parsers.tuple(Parsers.INDEX, Parsers.tuple(term(), token("="), term())).map(x -> new catdata.Pair<>(x.a, new catdata.Pair<>(x.b.a, x.b.c)));
    Parser<List<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>>> eqs = Parsers.tuple(token("equations"), eq.many()).map(x -> x.b);
    Parser<List<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>>> table = Parsers.tuple(Parsers.INDEX, Parsers.tuple(ident, token("->"), token("{"), Parsers.tuple(term(), term()).sepBy(token(",")), token("}"))).map(x -> {
        List<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>> ret = new LinkedList<>();
        for (Pair<RawTerm, RawTerm> y : x.b.d) {
            ret.add(new catdata.Pair<>(x.a, new catdata.Pair<>(new RawTerm(x.b.a, Util.singList(y.a)), y.b)));
        }
        return ret;
    });
    Parser<List<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>>> tables = Parsers.tuple(token("multi_equations"), table.many()).map(x -> Util.concat(x.b));
    Parser<Tuple3<List<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>>, List<catdata.Pair<Integer, catdata.Pair<RawTerm, RawTerm>>>, List<catdata.Pair<String, String>>>> pa = Parsers.tuple(eqs.optional(), tables.optional(), options);
    Parser<Tuple3<Token, InstExp<?, ?, ?, ?, ?, ?, ?, ?, ?>, Token>> l = Parsers.tuple(token("quotient"), inst_ref.lazy(), // .map(x -> x.c);
    token("{"));
    Parser<InstExpQuotient<?, ?>> ret = Parsers.tuple(l, pa, token("}")).map(x -> new InstExpQuotient(x.a.b, new LinkedList<>(Util.append(Util.newIfNull(x.b.a), Util.newIfNull(x.b.b))), x.b.c));
    return ret;
}