Search in sources :

Example 1 with OplInst

use of catdata.opl.OplExp.OplInst in project fql by CategoricalData.

the class OplOps method visit.

@Override
public OplObject visit(Program<OplExp> env, OplDistinct e) {
    OplObject o = ENV.get(e.str);
    if (!(o instanceof OplInst)) {
        throw new RuntimeException("Not an instance: " + e.str);
    }
    OplInst ret = (OplInst) o;
    return e.validate(ret);
}
Also used : OplInst(catdata.opl.OplExp.OplInst)

Example 2 with OplInst

use of catdata.opl.OplExp.OplInst in project fql by CategoricalData.

the class OplOps method visit.

@Override
public OplObject visit(Program<OplExp> env, OplColim e) {
    OplObject o = ENV.get(e.name);
    if (!(o instanceof OplGraph)) {
        throw new RuntimeException("Not a graph: " + e.name);
    }
    OplGraph<String, String> shape = (OplGraph<String, String>) o;
    OplObject base0 = ENV.get(e.base);
    String typeSide;
    if (base0 instanceof OplSig) {
        typeSide = e.base;
        OplUnion u0 = new OplUnion(new LinkedList<>(shape.nodes), typeSide);
        OplObject u1 = u0.accept(env, this);
        OplSchema<String, String, String> u = (OplSchema<String, String, String>) u1;
        Map<String, Set<String>> equivs = new HashMap<>();
        Map<String, String> equivs0 = new HashMap<>();
        for (String schname : shape.nodes) {
            OplSchema<String, String, String> sch = (OplSchema<String, String, String>) ENV.get(schname);
            for (String ename : sch.entities) {
                Set<String> set = new HashSet<>();
                set.add(schname + "_" + ename);
                equivs.put(schname + "_" + ename, set);
            }
        }
        // : type check colimit
        for (String mname : shape.edges.keySet()) {
            Pair<String, String> mt = shape.edges.get(mname);
            String s = mt.first;
            String t = mt.second;
            OplSchema<String, String, String> s0 = (OplSchema<String, String, String>) ENV.get(s);
            OplTyMapping<String, String, String, String, String> m0 = (OplTyMapping<String, String, String, String, String>) ENV.get(mname);
            if (!m0.src0.equals(s)) {
                throw new RuntimeException("Source of " + m0 + " is " + m0.src + " and not " + s + "as expected");
            }
            if (!m0.dst0.equals(t)) {
                throw new RuntimeException("Target of " + m0 + " is " + m0.dst + " and not " + t + "as expected");
            }
            for (String ob : s0.entities) {
                String ob0 = m0.m.sorts.get(ob);
                Set<String> set1 = equivs.get(s + "_" + ob);
                Set<String> set2 = equivs.get(t + "_" + ob0);
                set1.addAll(set2);
                equivs.put(s + "_" + ob, set1);
                equivs.put(t + "_" + ob0, set1);
            }
        }
        for (String k : equivs.keySet()) {
            List<String> v = new LinkedList<>(equivs.get(k));
            v.sort(String.CASE_INSENSITIVE_ORDER);
            equivs0.put(k, Util.sep(v, "__"));
        }
        Set<String> entities = new HashSet<>(equivs0.values());
        Map<String, Pair<List<String>, String>> edges = new HashMap<>();
        Map<String, Pair<List<String>, String>> attrs = new HashMap<>();
        List<Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>>> pathEqs = new LinkedList<>();
        List<Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>>> obsEqs = new LinkedList<>();
        Function<String, String> fun = x -> {
            if (equivs0.containsKey(x)) {
                return equivs0.get(x);
            }
            return x;
        };
        for (String edge : u.toSchema0().edges.keySet()) {
            Pair<List<String>, String> ty = u.toSchema0().edges.get(edge);
            edges.put(edge, new Pair<>(ty.first.stream().map(fun).collect(Collectors.toList()), fun.apply(ty.second)));
        }
        for (String attr : u.toSchema0().attrs.keySet()) {
            Pair<List<String>, String> ty = u.toSchema0().attrs.get(attr);
            attrs.put(attr, new Pair<>(ty.first.stream().map(fun).collect(Collectors.toList()), fun.apply(ty.second)));
        }
        for (Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>> eq : u.toSchema0().pathEqs) {
            OplCtx<String, String> ctx = new OplCtx<>(eq.first.values2().stream().map(x -> new Pair<>(x.first, fun.apply(x.second))).collect(Collectors.toList()));
            pathEqs.add(new Triple<>(ctx, fun2(equivs0, eq.second), fun2(equivs0, eq.third)));
        }
        for (Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>> eq : u.toSchema0().obsEqs) {
            OplCtx<String, String> ctx = new OplCtx<>(eq.first.values2().stream().map(x -> new Pair<>(x.first, fun.apply(x.second))).collect(Collectors.toList()));
            obsEqs.add(new Triple<>(ctx, fun2(equivs0, eq.second), fun2(equivs0, eq.third)));
        }
        for (String mname : shape.edges.keySet()) {
            Pair<String, String> mt = shape.edges.get(mname);
            String s = mt.first;
            String t = mt.second;
            OplSchema<String, String, String> s0 = (OplSchema<String, String, String>) ENV.get(s);
            // OplSchema<String, String, String> t0 = (OplSchema<String,
            // String, String>) ENV.get(t);
            OplTyMapping<String, String, String, String, String> m0 = (OplTyMapping<String, String, String, String, String>) ENV.get(mname);
            for (String edge : s0.projE().symbols.keySet()) {
                Pair<OplCtx<String, String>, OplTerm<String, String>> edge2 = m0.m.symbols.get(edge);
                List<OplTerm<String, String>> args = edge2.first.vars0.keySet().stream().map((Function<String, OplTerm<String, String>>) OplTerm::new).collect(Collectors.toList());
                OplTerm<String, String> lhs = fun2(equivs0, new OplTerm<>(s + "_" + edge, args));
                OplCtx<String, String> ctx = new OplCtx<>(edge2.first.values2().stream().map(x -> new Pair<>(x.first, fun.apply(s + "_" + x.second))).collect(Collectors.toList()));
                OplTerm<String, String> rhs = fun2(equivs0, prepend(t, edge2.second));
                pathEqs.add(new Triple<>(ctx, lhs, rhs));
            }
            for (String edge : s0.projA().symbols.keySet()) {
                Pair<OplCtx<String, String>, OplTerm<String, String>> edge2 = m0.m.symbols.get(edge);
                List<OplTerm<String, String>> args = edge2.first.vars0.keySet().stream().map((Function<String, OplTerm<String, String>>) OplTerm::new).collect(Collectors.toList());
                OplTerm<String, String> lhs = fun2(equivs0, new OplTerm<>(s + "_" + edge, args));
                OplCtx<String, String> ctx = new OplCtx<>(edge2.first.values2().stream().map(x -> new Pair<>(x.first, fun.apply(s + "_" + x.second))).collect(Collectors.toList()));
                OplTerm<String, String> rhs = fun2(equivs0, prepend(t, edge2.second));
                obsEqs.add(new Triple<>(ctx, lhs, rhs));
            }
        }
        OplSCHEMA0<String, String, String> ret = new OplSCHEMA0<>(new HashMap<>(), entities, edges, attrs, pathEqs, obsEqs, typeSide);
        OplSchema retsch = (OplSchema) ret.accept(env, this);
        e.compiled.put("Colimit", ret);
        for (String schname : shape.nodes) {
            OplSchema<String, String, String> sch = (OplSchema<String, String, String>) ENV.get(schname);
            Map<String, String> inj_sorts = new HashMap<>();
            Map<String, Pair<OplCtx<String, String>, OplTerm<String, String>>> inj_symbols = new HashMap<>();
            for (String ename : sch.entities) {
                inj_sorts.put(ename, fun.apply(schname + "_" + ename));
            }
            for (String c1 : sch.projEA().symbols.keySet()) {
                Pair<List<String>, String> t = sch.projEA().symbols.get(c1);
                List<Pair<String, String>> l = new LinkedList<>();
                List<OplTerm<String, String>> vs = new LinkedList<>();
                for (String s1 : t.first) {
                    String v = (String) retsch.sig.fr.next();
                    vs.add(new OplTerm<>(v));
                    l.add(new Pair<>(v, fun.apply(schname + "_" + s1)));
                }
                OplCtx<String, String> ctx = new OplCtx<>(l);
                OplTerm<String, String> value = fun2(equivs0, new OplTerm<>(schname + "_" + c1, vs));
                inj_symbols.put(c1, new Pair<>(ctx, value));
            }
            OplMapping<String, String, String, String, String> mapping = new OplMapping<>(inj_sorts, inj_symbols, schname, "Colimit");
            // : name of colimit
            OplTyMapping<String, String, String, String, String> tm = new OplTyMapping<>(schname, "Colimit", sch, retsch, mapping);
            tm.extend().validate(sch.sig, retsch.sig);
            e.compiled.put(schname + "To" + "Colimit", mapping);
        }
        return e;
    } else if (base0 instanceof OplSchema) {
        OplSchema sch2 = (OplSchema) base0;
        // OplSCHEMA0 sch = sch2.toSchema0();
        List<Pair<OplTerm<Chc<String, String>, String>, OplTerm<Chc<String, String>, String>>> equations = new LinkedList<>();
        // List<Pair<OplTerm<Object, String>, OplTerm<Object, String>>> equations1 = new LinkedList<>();
        Map<String, String> gens = new HashMap<>();
        Map<String, Integer> prec = new HashMap<>();
        for (String s : shape.nodes) {
            OplInst<String, String, String, String> toAdd = (OplInst<String, String, String, String>) ENV.get(s);
            for (Object gen : toAdd.P.gens.keySet()) {
                Object ty = toAdd.P.gens.get(gen);
                gens.put(s + "_" + gen, ty.toString());
            }
            for (Object gen : toAdd.P.prec.keySet()) {
                if (toAdd.P.gens.keySet().contains(gen)) {
                    if (toAdd.P.prec.containsKey(gen)) {
                        prec.put(s + "_" + gen, toAdd.P.prec.get(gen));
                    }
                } else {
                    if (toAdd.P.prec.containsKey(gen)) {
                        prec.put(toAdd.P.S + "_" + gen, toAdd.P.prec.get(gen));
                    }
                }
            }
            for (Pair<OplTerm<Chc<String, String>, String>, OplTerm<Chc<String, String>, String>> tr : toAdd.P.equations) {
                OplTerm lhs1 = prepend3(s, tr.first);
                OplTerm rhs1 = prepend3(s, tr.second);
                equations.add(new Pair<>(lhs1, rhs1));
            }
        }
        for (String mname : shape.edges.keySet()) {
            Pair<String, String> mt = shape.edges.get(mname);
            String s = mt.first;
            String t = mt.second;
            OplInst<String, String, String, String> s0 = (OplInst<String, String, String, String>) ENV.get(s);
            // OplSchema<String, String, String> t0 = (OplSchema<String,
            // String, String>) ENV.get(t);
            OplPresTrans<String, String, String, String, String> m0 = (OplPresTrans<String, String, String, String, String>) ENV.get(mname);
            for (String edge : s0.projE().gens.keySet()) {
                Pair<OplCtx<String, String>, OplTerm<Chc<String, String>, String>> edge2 = m0.mapping.symbols.get(Chc.inRight(edge));
                OplTerm<Chc<String, String>, String> lhs = new OplTerm<>(Chc.inRight(s + "_" + edge), new LinkedList<>());
                equations.add(new Pair<>(lhs, prepend3(t, edge2.second)));
            }
        }
        OplPres<String, String, String, String> pres = new OplPres<>(prec, e.base, sch2.sig, gens, equations);
        OplInst<String, String, String, String> colimInst = new OplInst<>(e.base, "?", null);
        colimInst.validate(sch2, pres, null);
        e.compiled.put("ColimitInstance", colimInst);
        for (String s : shape.nodes) {
            OplInst<String, String, String, String> toAdd = (OplInst<String, String, String, String>) ENV.get(s);
            Map<String, Map<String, OplTerm<Chc<String, String>, String>>> inj_map = new HashMap<>();
            for (String entity : toAdd.S.entities) {
                inj_map.put(entity, new HashMap<>());
            }
            for (Object gen : toAdd.P.gens.keySet()) {
                Object ty = toAdd.P.gens.get(gen);
                gens.put(s + "_" + gen, ty.toString());
                Map<String, OplTerm<Chc<String, String>, String>> m = inj_map.get(ty);
                OplTerm<Chc<String, String>, String> term = new OplTerm<>(Chc.inRight(s + "_" + gen), new LinkedList<>());
                m.put((String) gen, term);
            }
            // OplPresTrans
            OplPresTrans<String, String, String, String, String> inj = new OplPresTrans<>(inj_map, s, "ColimitInstance", toAdd.P, pres);
            e.compiled.put(s + "ToColimitInstance", inj);
        }
        return colimInst;
    }
    throw new RuntimeException("Report your program to Ryan");
}
Also used : OplPres(catdata.opl.OplExp.OplPres) OplTyMapping(catdata.opl.OplExp.OplTyMapping) OplGround(catdata.opl.OplExp.OplGround) OplExpVisitor(catdata.opl.OplExp.OplExpVisitor) OplPushoutSch(catdata.opl.OplExp.OplPushoutSch) Map(java.util.Map) Environment(catdata.Environment) OplSchema(catdata.opl.OplExp.OplSchema) OplColim(catdata.opl.OplExp.OplColim) OplPushout(catdata.opl.OplExp.OplPushout) OplSetInst(catdata.opl.OplExp.OplSetInst) Pair(catdata.Pair) OplPushoutBen(catdata.opl.OplExp.OplPushoutBen) OplInst(catdata.opl.OplExp.OplInst) Set(java.util.Set) Collectors(java.util.stream.Collectors) OplChaseExp(catdata.opl.OplExp.OplChaseExp) OplDelta(catdata.opl.OplExp.OplDelta) List(java.util.List) OplUnion(catdata.opl.OplExp.OplUnion) Program(catdata.Program) OplId(catdata.opl.OplExp.OplId) Triple(catdata.Triple) OplSat(catdata.opl.OplExp.OplSat) DefunctGlobalOptions(catdata.ide.DefunctGlobalOptions) OplJavaInst(catdata.opl.OplExp.OplJavaInst) OplDelta0(catdata.opl.OplExp.OplDelta0) Chc(catdata.Chc) HashMap(java.util.HashMap) OplApply(catdata.opl.OplExp.OplApply) OplDistinct(catdata.opl.OplExp.OplDistinct) OplUberSat(catdata.opl.OplExp.OplUberSat) Function(java.util.function.Function) OplSig(catdata.opl.OplExp.OplSig) HashSet(java.util.HashSet) OplFlower(catdata.opl.OplExp.OplFlower) OplPragma(catdata.opl.OplExp.OplPragma) OplPresTrans(catdata.opl.OplExp.OplPresTrans) OplSetTrans(catdata.opl.OplExp.OplSetTrans) LinkedList(java.util.LinkedList) Util(catdata.Util) OplSCHEMA0(catdata.opl.OplExp.OplSCHEMA0) OplEval(catdata.opl.OplExp.OplEval) OplPivot(catdata.opl.OplExp.OplPivot) OplSchemaProj(catdata.opl.OplExp.OplSchemaProj) OplGraph(catdata.opl.OplExp.OplGraph) OplUnSat(catdata.opl.OplExp.OplUnSat) OplInst0(catdata.opl.OplExp.OplInst0) OplSigma(catdata.opl.OplExp.OplSigma) OplVar(catdata.opl.OplExp.OplVar) OplMapping(catdata.opl.OplExp.OplMapping) Collections(java.util.Collections) OplSchema(catdata.opl.OplExp.OplSchema) HashMap(java.util.HashMap) OplPres(catdata.opl.OplExp.OplPres) List(java.util.List) LinkedList(java.util.LinkedList) OplGraph(catdata.opl.OplExp.OplGraph) HashSet(java.util.HashSet) LinkedList(java.util.LinkedList) Triple(catdata.Triple) Map(java.util.Map) HashMap(java.util.HashMap) Set(java.util.Set) HashSet(java.util.HashSet) OplInst(catdata.opl.OplExp.OplInst) Function(java.util.function.Function) OplTyMapping(catdata.opl.OplExp.OplTyMapping) Pair(catdata.Pair) OplPresTrans(catdata.opl.OplExp.OplPresTrans) OplUnion(catdata.opl.OplExp.OplUnion) OplSig(catdata.opl.OplExp.OplSig) OplSCHEMA0(catdata.opl.OplExp.OplSCHEMA0) OplMapping(catdata.opl.OplExp.OplMapping) Chc(catdata.Chc)

Example 3 with OplInst

use of catdata.opl.OplExp.OplInst in project fql by CategoricalData.

the class OplOps method visit.

@Override
public OplObject visit(Program<OplExp> env, OplInst0 e) {
    OplObject zzz = ENV.get(e.P.S);
    if (!(zzz instanceof OplSchema)) {
        throw new RuntimeException("Not a SCHEMA: " + e.P.S);
    }
    for (Object k2 : e.imports) {
        String k = (String) k2;
        OplExp o = env.exps.get(k);
        OplInst0 a;
        if (o instanceof OplInst0) {
            a = (OplInst0) o;
        } else if (o instanceof OplGround) {
            a = ((OplGround) o).validate(((OplInst) ENV.get(k)).S);
        } else {
            throw new RuntimeException("Not an instance: " + k);
        }
        Util.putAllSafely(e.P.gens, a.P.gens);
        e.P.equations.addAll(a.P.equations);
        e.P.prec.putAll(a.P.prec);
    // Util.putAllSafely(e.P.prec, a.P.prec);
    }
    OplPres P = (OplPres) visit(env, e.P);
    OplInst ret = new OplInst(e.P.S, "?", "none");
    OplObject S0 = ENV.get(e.P.S);
    if (!(S0 instanceof OplSchema)) {
        throw new RuntimeException("Not a schema: " + e.P.S);
    }
    OplSchema S = (OplSchema) S0;
    ret.validate(S, P, null);
    return ret;
}
Also used : OplSchema(catdata.opl.OplExp.OplSchema) OplInst0(catdata.opl.OplExp.OplInst0) OplGround(catdata.opl.OplExp.OplGround) OplPres(catdata.opl.OplExp.OplPres) OplInst(catdata.opl.OplExp.OplInst)

Example 4 with OplInst

use of catdata.opl.OplExp.OplInst in project fql by CategoricalData.

the class OplOps method visit.

@Override
public OplObject visit(Program<OplExp> env, OplSigma e) {
    OplObject F = ENV.get(e.F);
    OplObject I = ENV.get(e.I);
    if (F instanceof OplMapping) {
        OplMapping F0 = (OplMapping) F;
        if (I instanceof OplPres) {
            OplPres I0 = (OplPres) I;
            return F0.sigma(I0);
        } else if (I instanceof OplPresTrans) {
            OplPresTrans h = (OplPresTrans) I;
            return F0.sigma(h);
        }
        throw new RuntimeException("Not a presentation of an instance or transform: " + e.I);
    }
    if (F instanceof OplTyMapping) {
        OplTyMapping F0 = (OplTyMapping) F;
        if (I instanceof OplInst) {
            OplInst I0 = (OplInst) I;
            OplInst ret = new OplInst<>(F0.dst0, "?", I0.J0);
            ret.validate(F0.dst, F0.extend().sigma(I0.P), I0.J);
            return ret;
        } else if (I instanceof OplPresTrans) {
            OplPresTrans h = (OplPresTrans) I;
            OplPresTrans z = F0.extend().sigma(h);
            z.src1 = new OplInst<>("?", "?", h.src1.J0);
            z.dst1 = new OplInst<>("?", "?", h.src1.J0);
            z.src1.validate(F0.dst, z.src, h.src1.J);
            z.dst1.validate(F0.dst, z.dst, h.src1.J);
            return z;
        }
        throw new RuntimeException("Not an instance: " + e.I + "\n\n " + I.getClass());
    }
    throw new RuntimeException("Not a mapping: " + e.F);
}
Also used : OplPresTrans(catdata.opl.OplExp.OplPresTrans) OplPres(catdata.opl.OplExp.OplPres) OplMapping(catdata.opl.OplExp.OplMapping) OplTyMapping(catdata.opl.OplExp.OplTyMapping) OplInst(catdata.opl.OplExp.OplInst)

Example 5 with OplInst

use of catdata.opl.OplExp.OplInst in project fql by CategoricalData.

the class OplOps method visit.

// private static int temp = 0;
@Override
public OplObject visit(Program<OplExp> env, OplUnion e) {
    String typeSide;
    OplSchema schema = null;
    Map<String, Integer> prec = new HashMap<>();
    OplObject o = ENV.get(e.base);
    if (o instanceof OplSchema) {
        schema = (OplSchema) o;
        typeSide = schema.forSchema0;
        if (typeSide == null) {
            throw new RuntimeException(e.base + " is not a SCHEMA literal");
        }
    } else if (o instanceof OplSig) {
        typeSide = e.base;
    } else {
        throw new RuntimeException("Report this program to Ryan");
    }
    if (schema == null) {
        Set<String> entities = new HashSet<>();
        Map<String, Pair<List<String>, String>> edges = new HashMap<>();
        Map<String, Pair<List<String>, String>> attrs = new HashMap<>();
        List<Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>>> pathEqs = new LinkedList<>();
        List<Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>>> obsEqs = new LinkedList<>();
        for (String s : e.names) {
            OplExp exp = env.exps.get(s);
            if (exp == null) {
                throw new RuntimeException("Missing expression: " + s);
            }
            if (!(exp instanceof OplSCHEMA0)) {
                throw new RuntimeException("Not a schema: " + s);
            }
            OplSCHEMA0<String, String, String> toAdd = (OplSCHEMA0<String, String, String>) exp;
            if (!toAdd.typeSide.equals(typeSide)) {
                throw new RuntimeException("not all equal typesides in " + e);
            }
            for (Object entity : toAdd.entities) {
                String proposed = s + "_" + entity;
                if (entities.contains(proposed)) {
                    throw new RuntimeException("name clash: " + entity);
                }
                entities.add(proposed);
            }
            for (Object edge : toAdd.edges.keySet()) {
                String proposed = s + "_" + edge;
                if (edges.containsKey(proposed)) {
                    throw new RuntimeException("name clash: " + edge);
                }
                edges.put(proposed, new Pair<>(Util.singList(s + "_" + toAdd.edges.get(edge).first.get(0)), s + "_" + toAdd.edges.get(edge).second));
                if (toAdd.prec.containsKey(edge)) {
                    prec.put(proposed, toAdd.prec.get(edge));
                }
            }
            for (Object att : toAdd.attrs.keySet()) {
                String proposed = s + "_" + att;
                if (attrs.containsKey(proposed)) {
                    throw new RuntimeException("name clash: " + att);
                }
                attrs.put(proposed, new Pair<>(Util.singList(s + "_" + toAdd.attrs.get(att).first.get(0)), toAdd.attrs.get(att).second));
                if (toAdd.prec.containsKey(att)) {
                    prec.put(proposed, toAdd.prec.get(att));
                }
            }
            for (Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>> tr : toAdd.pathEqs) {
                String v = tr.first.names().get(0);
                String t = s + "_" + tr.first.values().get(0);
                OplCtx<String, String> ctx = new OplCtx<>(Util.singList(new Pair<>(v, t)));
                OplTerm<String, String> lhs1 = prepend(s, tr.second);
                OplTerm<String, String> rhs1 = prepend(s, tr.third);
                pathEqs.add(new Triple<>(ctx, lhs1, rhs1));
            }
            for (Triple<OplCtx<String, String>, OplTerm<String, String>, OplTerm<String, String>> tr : toAdd.obsEqs) {
                String v = tr.first.names().get(0);
                String t = s + "_" + tr.first.values().get(0);
                OplCtx<String, String> ctx = new OplCtx<>(Util.singList(new Pair<>(v, t)));
                OplTerm<String, String> lhs1 = prepend(s, tr.second);
                OplTerm<String, String> rhs1 = prepend(s, tr.third);
                obsEqs.add(new Triple<>(ctx, lhs1, rhs1));
            }
        }
        return new OplSCHEMA0<>(prec, entities, edges, attrs, pathEqs, obsEqs, typeSide).accept(env, this);
    } else {
        for (String s : e.names) {
            OplObject exp = ENV.get(s);
            if (!(exp instanceof OplInst)) {
                throw new RuntimeException("Not an instance: " + s);
            }
            OplInst<String, String, String, String> toAdd = (OplInst<String, String, String, String>) exp;
            if (!toAdd.S.equals(schema)) {
                throw new RuntimeException(s + " is not on schema " + schema);
            }
        }
        OplSig<String, String, String> sig = schema.sig;
        Map<String, String> gens = new HashMap<>();
        List<Pair<OplTerm<Object, String>, OplTerm<Object, String>>> equations1 = new LinkedList<>();
        // List<Pair<OplTerm<Chc<String,String>, String>, OplTerm<Chc<String,String>, String>>> equations2 = new LinkedList<>();
        for (String s : e.names) {
            OplExp exp = env.exps.get(s);
            OplInst0<String, String, String, String> toAdd = (OplInst0<String, String, String, String>) exp;
            for (Object gen : toAdd.P.gens.keySet()) {
                Object ty = toAdd.P.gens.get(gen);
                gens.put(s + "_" + gen, /* toAdd.P.S + "_" + */
                ty.toString());
            }
            for (Object gen : toAdd.P.prec.keySet()) {
                if (toAdd.P.gens.keySet().contains(gen)) {
                    if (toAdd.P.prec.containsKey(gen)) {
                        prec.put(s + "_" + gen, toAdd.P.prec.get(gen));
                    }
                } else {
                    if (toAdd.P.prec.containsKey(gen)) {
                        prec.put(toAdd.P.S + "_" + gen, toAdd.P.prec.get(gen));
                    }
                }
            }
            for (Pair<OplTerm<Chc<String, String>, String>, OplTerm<Chc<String, String>, String>> tr : toAdd.P.equations) {
                OplTerm<Object, String> lhs1 = prepend2((OplTerm) tr.first, s, toAdd.P.gens.keySet());
                OplTerm<Object, String> rhs1 = prepend2((OplTerm) tr.second, s, toAdd.P.gens.keySet());
                equations1.add(new Pair<>(lhs1, rhs1));
            }
        }
        // OplPres<String, String, String, String> pres = new OplPres(prec, "_temp" + temp, sig, gens, equations2);
        OplPres<String, String, String, String> pres = new OplPres(prec, e.base, sig, gens, equations1);
        if (DefunctGlobalOptions.debug.opl.opl_prover_simplify_instances) {
            pres = pres.simplify();
        }
        // temp++;
        OplInst0 ret = new OplInst0<>(pres);
        OplObject x = (OplObject) ret.accept(env, this);
        return x;
    }
}
Also used : OplSchema(catdata.opl.OplExp.OplSchema) HashMap(java.util.HashMap) OplInst(catdata.opl.OplExp.OplInst) OplPres(catdata.opl.OplExp.OplPres) HashSet(java.util.HashSet) Pair(catdata.Pair) OplInst0(catdata.opl.OplExp.OplInst0) OplSig(catdata.opl.OplExp.OplSig) LinkedList(java.util.LinkedList) OplSCHEMA0(catdata.opl.OplExp.OplSCHEMA0) Triple(catdata.Triple)

Aggregations

OplInst (catdata.opl.OplExp.OplInst)12 OplPres (catdata.opl.OplExp.OplPres)7 OplSchema (catdata.opl.OplExp.OplSchema)5 HashMap (java.util.HashMap)5 LinkedList (java.util.LinkedList)5 Pair (catdata.Pair)4 Triple (catdata.Triple)4 OplSig (catdata.opl.OplExp.OplSig)4 HashSet (java.util.HashSet)4 Chc (catdata.Chc)3 OplInst0 (catdata.opl.OplExp.OplInst0)3 OplPresTrans (catdata.opl.OplExp.OplPresTrans)3 Map (java.util.Map)3 OplGround (catdata.opl.OplExp.OplGround)2 OplMapping (catdata.opl.OplExp.OplMapping)2 OplPushout (catdata.opl.OplExp.OplPushout)2 OplSCHEMA0 (catdata.opl.OplExp.OplSCHEMA0)2 OplTyMapping (catdata.opl.OplExp.OplTyMapping)2 SqlColumn (catdata.sql.SqlColumn)2 SqlForeignKey (catdata.sql.SqlForeignKey)2