-/*******************************************************************************\r
- * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
- * in Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.modeling.mapping;\r
-\r
-import org.simantics.db.Resource;\r
-import org.simantics.layer0.utils.binaryPredicates.CompositePredicate;\r
-import org.simantics.layer0.utils.binaryPredicates.IBinaryPredicate;\r
-import org.simantics.layer0.utils.binaryPredicates.Relation;\r
-import org.simantics.layer0.utils.predicates.Conjunction;\r
-import org.simantics.layer0.utils.predicates.Disjunction;\r
-import org.simantics.layer0.utils.predicates.IUnaryPredicate;\r
-import org.simantics.layer0.utils.predicates.Negation;\r
-import org.simantics.layer0.utils.predicates.Type;\r
-import org.simantics.layer0.utils.triggers.Trigger;\r
-import org.simantics.mapping.constraint.instructions.AndInstruction;\r
-import org.simantics.mapping.constraint.instructions.BinaryPredicateInstruction;\r
-import org.simantics.mapping.constraint.instructions.BinaryPredicateObjectQuery;\r
-import org.simantics.mapping.constraint.instructions.BinaryPredicateSubjectQuery;\r
-import org.simantics.mapping.constraint.instructions.ExistsInstruction;\r
-import org.simantics.mapping.constraint.instructions.IInstruction;\r
-import org.simantics.mapping.constraint.instructions.NotInstruction;\r
-import org.simantics.mapping.constraint.instructions.OrInstruction;\r
-import org.simantics.mapping.constraint.instructions.TripletInstruction;\r
-import org.simantics.mapping.constraint.instructions.TripletObjectQuery;\r
-import org.simantics.mapping.constraint.instructions.TripletPredicateObjectQuery;\r
-import org.simantics.mapping.constraint.instructions.TripletSubjectPredicateQuery;\r
-import org.simantics.mapping.constraint.instructions.TypedBracketInstruction;\r
-import org.simantics.mapping.constraint.instructions.TypedBracketInstruction.CreationInstruction;\r
-import org.simantics.mapping.constraint.instructions.UnaryPredicateInstruction;\r
-import org.simantics.mapping.rule.instructions.AndRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.ClaimRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.DenyRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.IRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.IfRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.PrintRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.QueryRuleInstruction;\r
-import org.simantics.mapping.rule.instructions.UnlessRuleInstruction;\r
-\r
-public abstract class MappingBase extends Trigger {\r
- \r
- public static IInstruction bf(IBinaryPredicate predicate, int variable0, int variable1) {\r
- return new BinaryPredicateObjectQuery(variable0, variable1, predicate);\r
- }\r
- \r
- public static IInstruction fb(IBinaryPredicate predicate, int variable0, int variable1) {\r
- return new BinaryPredicateSubjectQuery(variable0, variable1, predicate);\r
- }\r
- \r
- public static IInstruction bf(Resource relation, int variable0, int variable1) {\r
- return bf(new Relation(relation), variable0, variable1);\r
- }\r
- \r
- public static IInstruction fb(Resource relation, int variable0, int variable1) {\r
- return fb(new Relation(relation), variable0, variable1);\r
- }\r
- \r
- public static IInstruction bb(IBinaryPredicate predicate, int variable0, int variable1) {\r
- return new BinaryPredicateInstruction(variable0, variable1, predicate);\r
- }\r
- \r
- public static IInstruction bb(Resource relation, int variable0, int variable1) {\r
- return bb(new Relation(relation), variable0, variable1);\r
- }\r
- \r
- public static IInstruction b(IUnaryPredicate predicate, int variable0) {\r
- return new UnaryPredicateInstruction(variable0, predicate);\r
- }\r
- \r
- public static IInstruction b(Resource type, int variable0) {\r
- return b(new Type(type), variable0);\r
- }\r
- \r
- public static IInstruction statement_ffb(int variable0, int variable1, int variable2) {\r
- return new TripletSubjectPredicateQuery(variable0, variable1, variable2);\r
- }\r
- \r
- public static IInstruction statement_ffb(int variable0, int variable1, int variable2, Resource baseRelation) {\r
- return new TripletSubjectPredicateQuery(variable0, variable1, variable2, baseRelation);\r
- }\r
- \r
- public static IInstruction statement_bff(int variable0, int variable1, int variable2) {\r
- return new TripletPredicateObjectQuery(variable0, variable1, variable2);\r
- }\r
- \r
- public static IInstruction statement_bbf(int variable0, int variable1, int variable2) {\r
- return new TripletObjectQuery(variable0, variable1, variable2);\r
- }\r
- \r
- public static IInstruction statement_bff(int variable0, int variable1, int variable2, Resource baseRelation) {\r
- return new TripletPredicateObjectQuery(variable0, variable1, variable2, baseRelation);\r
- }\r
- \r
- public static IInstruction statement(int variable0, int variable1, int variable2) {\r
- return new TripletInstruction(variable0, variable1, variable2);\r
- }\r
- \r
- public static IInstruction exists(IInstruction constraint, int ... variables) {\r
- return new ExistsInstruction(constraint, variables);\r
- }\r
- \r
- public static IInstruction exists(int ... variables) {\r
- return new ExistsInstruction(and(), variables);\r
- }\r
- \r
- public static IInstruction exists(IInstruction constraint, CreationInstruction ... instrs) {\r
- return new TypedBracketInstruction(constraint, instrs);\r
- }\r
- \r
- public static IInstruction and() {\r
- return new AndInstruction();\r
- }\r
-\r
- public static IUnaryPredicate and(IUnaryPredicate ... predicates) {\r
- return new Conjunction(predicates);\r
- } \r
-\r
- public static IUnaryPredicate or(IUnaryPredicate ... predicates) {\r
- return new Disjunction(predicates);\r
- } \r
-\r
- public static IUnaryPredicate not(IUnaryPredicate predicate) {\r
- return new Negation(predicate);\r
- } \r
- \r
- public static IUnaryPredicate implies(IUnaryPredicate from, IUnaryPredicate to) {\r
- return or(not(from), to);\r
- }\r
-\r
- public static IInstruction and(IInstruction ... constraints) {\r
- return new AndInstruction(constraints);\r
- }\r
- \r
- public static IInstruction or(IInstruction ... constraints) {\r
- return new OrInstruction(constraints);\r
- } \r
- \r
- public static IInstruction not(IInstruction constraint) {\r
- return new NotInstruction(constraint);\r
- }\r
- \r
- public static IRuleInstruction and(IRuleInstruction ... rules) {\r
- return new AndRuleInstruction(rules);\r
- }\r
-\r
- public static IRuleInstruction claim(IInstruction constraint) {\r
- return new ClaimRuleInstruction(constraint);\r
- }\r
- \r
- public static IRuleInstruction claim(IInstruction ... constraints) {\r
- return claim(and(constraints));\r
- }\r
- \r
- public static IRuleInstruction claim(IInstruction constraint, IRuleInstruction continuation) {\r
- return new ClaimRuleInstruction(constraint, continuation);\r
- }\r
- \r
- public static IRuleInstruction deny(IInstruction constraint) {\r
- return new DenyRuleInstruction(constraint);\r
- }\r
- \r
- public static IRuleInstruction if_(IInstruction condition, IRuleInstruction then) {\r
- return new IfRuleInstruction(condition, then);\r
- }\r
- \r
- public static IRuleInstruction if_(IInstruction condition, IRuleInstruction then, IRuleInstruction else_) {\r
- return new IfRuleInstruction(condition, then, else_);\r
- }\r
-\r
- public static IRuleInstruction unless(IInstruction condition, IRuleInstruction then) {\r
- return new UnlessRuleInstruction(condition, then);\r
- }\r
- \r
- public static IRuleInstruction query(IRuleInstruction rule) {\r
- return new QueryRuleInstruction(rule);\r
- }\r
- \r
- public static IRuleInstruction print(String text) {\r
- return new PrintRuleInstruction(text);\r
- }\r
- \r
- public static IBinaryPredicate compose(Resource a, Resource b) {\r
- return new CompositePredicate(new Relation(a), new Relation(b)); \r
- }\r
- \r
- public static IBinaryPredicate compose(Resource a, IBinaryPredicate b) {\r
- return new CompositePredicate(new Relation(a), b); \r
- }\r
- \r
- public static IBinaryPredicate compose(IBinaryPredicate a, Resource b) {\r
- return new CompositePredicate(a, new Relation(b)); \r
- }\r
- \r
- public static IBinaryPredicate compose(Resource a, Resource b, Resource c) {\r
- return compose(compose(a, b), c);\r
- }\r
-}\r
+/*******************************************************************************
+ * 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);
+ }
+}
Code Review / simantics / platform.git / blobdiff