X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.modeling%2Fsrc%2Forg%2Fsimantics%2Fmodeling%2Fmapping%2FMappingBase.java;h=7b92fbc11995007d36162e124ebf78e436c6319c;hb=HEAD;hp=11b7e2549decb2e1fbaf3f556e40445c032353ee;hpb=969bd23cab98a79ca9101af33334000879fb60c5;p=simantics%2Fplatform.git diff --git a/bundles/org.simantics.modeling/src/org/simantics/modeling/mapping/MappingBase.java b/bundles/org.simantics.modeling/src/org/simantics/modeling/mapping/MappingBase.java index 11b7e2549..7b92fbc11 100644 --- a/bundles/org.simantics.modeling/src/org/simantics/modeling/mapping/MappingBase.java +++ b/bundles/org.simantics.modeling/src/org/simantics/modeling/mapping/MappingBase.java @@ -1,205 +1,205 @@ -/******************************************************************************* - * Copyright (c) 2007, 2010 Association for Decentralized Information Management - * in Industry THTH ry. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * VTT Technical Research Centre of Finland - initial API and implementation - *******************************************************************************/ -package org.simantics.modeling.mapping; - -import org.simantics.db.Resource; -import org.simantics.layer0.utils.binaryPredicates.CompositePredicate; -import org.simantics.layer0.utils.binaryPredicates.IBinaryPredicate; -import org.simantics.layer0.utils.binaryPredicates.Relation; -import org.simantics.layer0.utils.predicates.Conjunction; -import org.simantics.layer0.utils.predicates.Disjunction; -import org.simantics.layer0.utils.predicates.IUnaryPredicate; -import org.simantics.layer0.utils.predicates.Negation; -import org.simantics.layer0.utils.predicates.Type; -import org.simantics.layer0.utils.triggers.Trigger; -import org.simantics.mapping.constraint.instructions.AndInstruction; -import org.simantics.mapping.constraint.instructions.BinaryPredicateInstruction; -import org.simantics.mapping.constraint.instructions.BinaryPredicateObjectQuery; -import org.simantics.mapping.constraint.instructions.BinaryPredicateSubjectQuery; -import org.simantics.mapping.constraint.instructions.ExistsInstruction; -import org.simantics.mapping.constraint.instructions.IInstruction; -import org.simantics.mapping.constraint.instructions.NotInstruction; -import org.simantics.mapping.constraint.instructions.OrInstruction; -import org.simantics.mapping.constraint.instructions.TripletInstruction; -import org.simantics.mapping.constraint.instructions.TripletObjectQuery; -import org.simantics.mapping.constraint.instructions.TripletPredicateObjectQuery; -import org.simantics.mapping.constraint.instructions.TripletSubjectPredicateQuery; -import org.simantics.mapping.constraint.instructions.TypedBracketInstruction; -import org.simantics.mapping.constraint.instructions.TypedBracketInstruction.CreationInstruction; -import org.simantics.mapping.constraint.instructions.UnaryPredicateInstruction; -import org.simantics.mapping.rule.instructions.AndRuleInstruction; -import org.simantics.mapping.rule.instructions.ClaimRuleInstruction; -import org.simantics.mapping.rule.instructions.DenyRuleInstruction; -import org.simantics.mapping.rule.instructions.IRuleInstruction; -import org.simantics.mapping.rule.instructions.IfRuleInstruction; -import org.simantics.mapping.rule.instructions.PrintRuleInstruction; -import org.simantics.mapping.rule.instructions.QueryRuleInstruction; -import org.simantics.mapping.rule.instructions.UnlessRuleInstruction; - -public abstract class MappingBase extends Trigger { - - public static IInstruction bf(IBinaryPredicate predicate, int variable0, int variable1) { - return new BinaryPredicateObjectQuery(variable0, variable1, predicate); - } - - public static IInstruction fb(IBinaryPredicate predicate, int variable0, int variable1) { - return new BinaryPredicateSubjectQuery(variable0, variable1, predicate); - } - - public static IInstruction bf(Resource relation, int variable0, int variable1) { - return bf(new Relation(relation), variable0, variable1); - } - - public static IInstruction fb(Resource relation, int variable0, int variable1) { - return fb(new Relation(relation), variable0, variable1); - } - - public static IInstruction bb(IBinaryPredicate predicate, int variable0, int variable1) { - return new BinaryPredicateInstruction(variable0, variable1, predicate); - } - - public static IInstruction bb(Resource relation, int variable0, int variable1) { - return bb(new Relation(relation), variable0, variable1); - } - - public static IInstruction b(IUnaryPredicate predicate, int variable0) { - return new UnaryPredicateInstruction(variable0, predicate); - } - - public static IInstruction b(Resource type, int variable0) { - return b(new Type(type), variable0); - } - - public static IInstruction statement_ffb(int variable0, int variable1, int variable2) { - return new TripletSubjectPredicateQuery(variable0, variable1, variable2); - } - - public static IInstruction statement_ffb(int variable0, int variable1, int variable2, Resource baseRelation) { - return new TripletSubjectPredicateQuery(variable0, variable1, variable2, baseRelation); - } - - public static IInstruction statement_bff(int variable0, int variable1, int variable2) { - return new TripletPredicateObjectQuery(variable0, variable1, variable2); - } - - public static IInstruction statement_bbf(int variable0, int variable1, int variable2) { - return new TripletObjectQuery(variable0, variable1, variable2); - } - - public static IInstruction statement_bff(int variable0, int variable1, int variable2, Resource baseRelation) { - return new TripletPredicateObjectQuery(variable0, variable1, variable2, baseRelation); - } - - public static IInstruction statement(int variable0, int variable1, int variable2) { - return new TripletInstruction(variable0, variable1, variable2); - } - - public static IInstruction exists(IInstruction constraint, int ... variables) { - return new ExistsInstruction(constraint, variables); - } - - public static IInstruction exists(int ... variables) { - return new ExistsInstruction(and(), variables); - } - - public static IInstruction exists(IInstruction constraint, CreationInstruction ... instrs) { - return new TypedBracketInstruction(constraint, instrs); - } - - public static IInstruction and() { - return new AndInstruction(); - } - - public static IUnaryPredicate and(IUnaryPredicate ... predicates) { - return new Conjunction(predicates); - } - - public static IUnaryPredicate or(IUnaryPredicate ... predicates) { - return new Disjunction(predicates); - } - - public static IUnaryPredicate not(IUnaryPredicate predicate) { - return new Negation(predicate); - } - - public static IUnaryPredicate implies(IUnaryPredicate from, IUnaryPredicate to) { - return or(not(from), to); - } - - public static IInstruction and(IInstruction ... constraints) { - return new AndInstruction(constraints); - } - - public static IInstruction or(IInstruction ... constraints) { - return new OrInstruction(constraints); - } - - public static IInstruction not(IInstruction constraint) { - return new NotInstruction(constraint); - } - - public static IRuleInstruction and(IRuleInstruction ... rules) { - return new AndRuleInstruction(rules); - } - - public static IRuleInstruction claim(IInstruction constraint) { - return new ClaimRuleInstruction(constraint); - } - - public static IRuleInstruction claim(IInstruction ... constraints) { - return claim(and(constraints)); - } - - public static IRuleInstruction claim(IInstruction constraint, IRuleInstruction continuation) { - return new ClaimRuleInstruction(constraint, continuation); - } - - public static IRuleInstruction deny(IInstruction constraint) { - return new DenyRuleInstruction(constraint); - } - - public static IRuleInstruction if_(IInstruction condition, IRuleInstruction then) { - return new IfRuleInstruction(condition, then); - } - - public static IRuleInstruction if_(IInstruction condition, IRuleInstruction then, IRuleInstruction else_) { - return new IfRuleInstruction(condition, then, else_); - } - - public static IRuleInstruction unless(IInstruction condition, IRuleInstruction then) { - return new UnlessRuleInstruction(condition, then); - } - - public static IRuleInstruction query(IRuleInstruction rule) { - return new QueryRuleInstruction(rule); - } - - public static IRuleInstruction print(String text) { - return new PrintRuleInstruction(text); - } - - public static IBinaryPredicate compose(Resource a, Resource b) { - return new CompositePredicate(new Relation(a), new Relation(b)); - } - - public static IBinaryPredicate compose(Resource a, IBinaryPredicate b) { - return new CompositePredicate(new Relation(a), b); - } - - public static IBinaryPredicate compose(IBinaryPredicate a, Resource b) { - return new CompositePredicate(a, new Relation(b)); - } - - public static IBinaryPredicate compose(Resource a, Resource b, Resource c) { - return compose(compose(a, b), c); - } -} +/******************************************************************************* + * Copyright (c) 2007, 2010 Association for Decentralized Information Management + * in Industry THTH ry. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * VTT Technical Research Centre of Finland - initial API and implementation + *******************************************************************************/ +package org.simantics.modeling.mapping; + +import org.simantics.db.Resource; +import org.simantics.layer0.utils.binaryPredicates.CompositePredicate; +import org.simantics.layer0.utils.binaryPredicates.IBinaryPredicate; +import org.simantics.layer0.utils.binaryPredicates.Relation; +import org.simantics.layer0.utils.predicates.Conjunction; +import org.simantics.layer0.utils.predicates.Disjunction; +import org.simantics.layer0.utils.predicates.IUnaryPredicate; +import org.simantics.layer0.utils.predicates.Negation; +import org.simantics.layer0.utils.predicates.Type; +import org.simantics.layer0.utils.triggers.Trigger; +import org.simantics.mapping.constraint.instructions.AndInstruction; +import org.simantics.mapping.constraint.instructions.BinaryPredicateInstruction; +import org.simantics.mapping.constraint.instructions.BinaryPredicateObjectQuery; +import org.simantics.mapping.constraint.instructions.BinaryPredicateSubjectQuery; +import org.simantics.mapping.constraint.instructions.ExistsInstruction; +import org.simantics.mapping.constraint.instructions.IInstruction; +import org.simantics.mapping.constraint.instructions.NotInstruction; +import org.simantics.mapping.constraint.instructions.OrInstruction; +import org.simantics.mapping.constraint.instructions.TripletInstruction; +import org.simantics.mapping.constraint.instructions.TripletObjectQuery; +import org.simantics.mapping.constraint.instructions.TripletPredicateObjectQuery; +import org.simantics.mapping.constraint.instructions.TripletSubjectPredicateQuery; +import org.simantics.mapping.constraint.instructions.TypedBracketInstruction; +import org.simantics.mapping.constraint.instructions.TypedBracketInstruction.CreationInstruction; +import org.simantics.mapping.constraint.instructions.UnaryPredicateInstruction; +import org.simantics.mapping.rule.instructions.AndRuleInstruction; +import org.simantics.mapping.rule.instructions.ClaimRuleInstruction; +import org.simantics.mapping.rule.instructions.DenyRuleInstruction; +import org.simantics.mapping.rule.instructions.IRuleInstruction; +import org.simantics.mapping.rule.instructions.IfRuleInstruction; +import org.simantics.mapping.rule.instructions.PrintRuleInstruction; +import org.simantics.mapping.rule.instructions.QueryRuleInstruction; +import org.simantics.mapping.rule.instructions.UnlessRuleInstruction; + +public abstract class MappingBase extends Trigger { + + public static IInstruction bf(IBinaryPredicate predicate, int variable0, int variable1) { + return new BinaryPredicateObjectQuery(variable0, variable1, predicate); + } + + public static IInstruction fb(IBinaryPredicate predicate, int variable0, int variable1) { + return new BinaryPredicateSubjectQuery(variable0, variable1, predicate); + } + + public static IInstruction bf(Resource relation, int variable0, int variable1) { + return bf(new Relation(relation), variable0, variable1); + } + + public static IInstruction fb(Resource relation, int variable0, int variable1) { + return fb(new Relation(relation), variable0, variable1); + } + + public static IInstruction bb(IBinaryPredicate predicate, int variable0, int variable1) { + return new BinaryPredicateInstruction(variable0, variable1, predicate); + } + + public static IInstruction bb(Resource relation, int variable0, int variable1) { + return bb(new Relation(relation), variable0, variable1); + } + + public static IInstruction b(IUnaryPredicate predicate, int variable0) { + return new UnaryPredicateInstruction(variable0, predicate); + } + + public static IInstruction b(Resource type, int variable0) { + return b(new Type(type), variable0); + } + + public static IInstruction statement_ffb(int variable0, int variable1, int variable2) { + return new TripletSubjectPredicateQuery(variable0, variable1, variable2); + } + + public static IInstruction statement_ffb(int variable0, int variable1, int variable2, Resource baseRelation) { + return new TripletSubjectPredicateQuery(variable0, variable1, variable2, baseRelation); + } + + public static IInstruction statement_bff(int variable0, int variable1, int variable2) { + return new TripletPredicateObjectQuery(variable0, variable1, variable2); + } + + public static IInstruction statement_bbf(int variable0, int variable1, int variable2) { + return new TripletObjectQuery(variable0, variable1, variable2); + } + + public static IInstruction statement_bff(int variable0, int variable1, int variable2, Resource baseRelation) { + return new TripletPredicateObjectQuery(variable0, variable1, variable2, baseRelation); + } + + public static IInstruction statement(int variable0, int variable1, int variable2) { + return new TripletInstruction(variable0, variable1, variable2); + } + + public static IInstruction exists(IInstruction constraint, int ... variables) { + return new ExistsInstruction(constraint, variables); + } + + public static IInstruction exists(int ... variables) { + return new ExistsInstruction(and(), variables); + } + + public static IInstruction exists(IInstruction constraint, CreationInstruction ... instrs) { + return new TypedBracketInstruction(constraint, instrs); + } + + public static IInstruction and() { + return new AndInstruction(); + } + + public static IUnaryPredicate and(IUnaryPredicate ... predicates) { + return new Conjunction(predicates); + } + + public static IUnaryPredicate or(IUnaryPredicate ... predicates) { + return new Disjunction(predicates); + } + + public static IUnaryPredicate not(IUnaryPredicate predicate) { + return new Negation(predicate); + } + + public static IUnaryPredicate implies(IUnaryPredicate from, IUnaryPredicate to) { + return or(not(from), to); + } + + public static IInstruction and(IInstruction ... constraints) { + return new AndInstruction(constraints); + } + + public static IInstruction or(IInstruction ... constraints) { + return new OrInstruction(constraints); + } + + public static IInstruction not(IInstruction constraint) { + return new NotInstruction(constraint); + } + + public static IRuleInstruction and(IRuleInstruction ... rules) { + return new AndRuleInstruction(rules); + } + + public static IRuleInstruction claim(IInstruction constraint) { + return new ClaimRuleInstruction(constraint); + } + + public static IRuleInstruction claim(IInstruction ... constraints) { + return claim(and(constraints)); + } + + public static IRuleInstruction claim(IInstruction constraint, IRuleInstruction continuation) { + return new ClaimRuleInstruction(constraint, continuation); + } + + public static IRuleInstruction deny(IInstruction constraint) { + return new DenyRuleInstruction(constraint); + } + + public static IRuleInstruction if_(IInstruction condition, IRuleInstruction then) { + return new IfRuleInstruction(condition, then); + } + + public static IRuleInstruction if_(IInstruction condition, IRuleInstruction then, IRuleInstruction else_) { + return new IfRuleInstruction(condition, then, else_); + } + + public static IRuleInstruction unless(IInstruction condition, IRuleInstruction then) { + return new UnlessRuleInstruction(condition, then); + } + + public static IRuleInstruction query(IRuleInstruction rule) { + return new QueryRuleInstruction(rule); + } + + public static IRuleInstruction print(String text) { + return new PrintRuleInstruction(text); + } + + public static IBinaryPredicate compose(Resource a, Resource b) { + return new CompositePredicate(new Relation(a), new Relation(b)); + } + + public static IBinaryPredicate compose(Resource a, IBinaryPredicate b) { + return new CompositePredicate(new Relation(a), b); + } + + public static IBinaryPredicate compose(IBinaryPredicate a, Resource b) { + return new CompositePredicate(a, new Relation(b)); + } + + public static IBinaryPredicate compose(Resource a, Resource b, Resource c) { + return compose(compose(a, b), c); + } +}