aboutsummaryrefslogtreecommitdiffstats
path: root/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3
diff options
context:
space:
mode:
authorLibravatar Kristóf Marussy <marussy@mit.bme.hu>2020-08-06 16:07:16 +0200
committerLibravatar Kristóf Marussy <marussy@mit.bme.hu>2020-08-06 16:07:16 +0200
commita620f07468780778bd55dcffc30245def37ece69 (patch)
tree57189ad9c8bf15211a05a3cd50ee90e90f434557 /Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3
parentFix time measurement (diff)
downloadVIATRA-Generator-a620f07468780778bd55dcffc30245def37ece69.tar.gz
VIATRA-Generator-a620f07468780778bd55dcffc30245def37ece69.tar.zst
VIATRA-Generator-a620f07468780778bd55dcffc30245def37ece69.zip
MoDeS3 unit propagation WIP
Diffstat (limited to 'Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3')
-rw-r--r--Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbinbin0 -> 14631 bytes
-rw-r--r--Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbinbin0 -> 9899 bytes
-rw-r--r--Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore2
-rw-r--r--Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java381
-rw-r--r--Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java585
5 files changed, 968 insertions, 0 deletions
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
new file mode 100644
index 00000000..4f542a67
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3ModelGenerator.xtendbin
Binary files differ
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
new file mode 100644
index 00000000..28e763b9
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.Modes3UnitPropagationGenerator.xtendbin
Binary files differ
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore
new file mode 100644
index 00000000..53dcf60f
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/.gitignore
@@ -0,0 +1,2 @@
1/.Modes3ModelGenerator.java._trace
2/.Modes3UnitPropagationGenerator.java._trace
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java
new file mode 100644
index 00000000..c7364257
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3ModelGenerator.java
@@ -0,0 +1,381 @@
1package modes3.run;
2
3import com.google.common.base.Objects;
4import com.google.common.collect.ImmutableList;
5import com.google.common.collect.ImmutableSet;
6import com.google.common.collect.Iterables;
7import hu.bme.mit.inf.dslreasoner.ecore2logic.EReferenceMapper_RelationsOverTypes_Trace;
8import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
9import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration;
10import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
11import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor;
12import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsFactory;
13import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsPackage;
14import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion;
15import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder;
16import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput;
17import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes;
18import hu.bme.mit.inf.dslreasoner.logic.model.builder.VariableContext;
19import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion;
20import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Iff;
21import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguagePackage;
22import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration;
23import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicValue;
24import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription;
25import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
26import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition;
27import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Variable;
28import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.Annotation;
29import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem;
30import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicproblemPackage;
31import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult;
32import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult;
33import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic;
34import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicConfiguration;
35import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2LogicTrace;
36import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor;
37import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.Viatra2LogicAnnotationsPackage;
38import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod;
39import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorConstraints;
40import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.PolyhedralScopePropagatorSolver;
41import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.ScopePropagatorStrategy;
42import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic;
43import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink;
44import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialComplexTypeInterpretation;
45import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
46import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation;
47import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationPackage;
48import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink;
49import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml;
50import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation;
51import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.StateCoderStrategy;
52import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner;
53import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration;
54import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser;
55import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace;
56import java.util.Collections;
57import java.util.List;
58import java.util.Map;
59import java.util.Set;
60import java.util.function.Consumer;
61import java.util.function.Predicate;
62import modes3.Modes3Factory;
63import modes3.Modes3ModelRoot;
64import modes3.Modes3Package;
65import modes3.queries.Modes3Queries;
66import org.eclipse.emf.common.util.EList;
67import org.eclipse.emf.common.util.URI;
68import org.eclipse.emf.ecore.EAttribute;
69import org.eclipse.emf.ecore.EClass;
70import org.eclipse.emf.ecore.EEnum;
71import org.eclipse.emf.ecore.EEnumLiteral;
72import org.eclipse.emf.ecore.EObject;
73import org.eclipse.emf.ecore.EReference;
74import org.eclipse.emf.ecore.EStructuralFeature;
75import org.eclipse.emf.ecore.resource.Resource;
76import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
77import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup;
78import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
79import org.eclipse.viatra.query.runtime.api.ViatraQueryEngineOptions;
80import org.eclipse.viatra.query.runtime.localsearch.matcher.integration.LocalSearchEMFBackendFactory;
81import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
82import org.eclipse.viatra.query.runtime.rete.matcher.ReteBackendFactory;
83import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor;
84import org.eclipse.xtend2.lib.StringConcatenation;
85import org.eclipse.xtext.xbase.lib.CollectionLiterals;
86import org.eclipse.xtext.xbase.lib.Exceptions;
87import org.eclipse.xtext.xbase.lib.ExclusiveRange;
88import org.eclipse.xtext.xbase.lib.Extension;
89import org.eclipse.xtext.xbase.lib.Functions.Function1;
90import org.eclipse.xtext.xbase.lib.InputOutput;
91import org.eclipse.xtext.xbase.lib.IterableExtensions;
92import org.eclipse.xtext.xbase.lib.ObjectExtensions;
93import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
94
95@FinalFieldsConstructor
96@SuppressWarnings("all")
97public class Modes3ModelGenerator {
98 private enum MonitoringQuery {
99 closeTrains,
100
101 misalignedTurnout;
102 }
103
104 private final Modes3ModelGenerator.MonitoringQuery monitoringQuery;
105
106 private final int modelSize;
107
108 private final Ecore2Logic ecore2Logic = new Ecore2Logic();
109
110 private final InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic();
111
112 private final Viatra2Logic viatra2Logic = new Viatra2Logic(this.ecore2Logic);
113
114 private final ViatraReasoner solver = new ViatraReasoner();
115
116 @Extension
117 private final LogicProblemBuilder _logicProblemBuilder = new LogicProblemBuilder();
118
119 public URI generate() {
120 try {
121 URI _xblockexpression = null;
122 {
123 final EcoreMetamodelDescriptor metamodel = Modes3ModelGenerator.createMetamodelDescriptor();
124 Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration();
125 final TracedOutput<LogicProblem, Ecore2Logic_Trace> metamodelLogic = this.ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration);
126 final Type segment = this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getSegment());
127 final RelationDeclaration connectedTo = this.ecore2Logic.relationOfReference(metamodelLogic.getTrace(),
128 Modes3Package.eINSTANCE.getSegment_ConnectedTo());
129 final RelationDeclaration connectedToIndicator = ((EReferenceMapper_RelationsOverTypes_Trace) metamodelLogic.getTrace().referenceMapperTrace).indicators.get(
130 Modes3Package.eINSTANCE.getSegment_ConnectedTo());
131 StringConcatenation _builder = new StringConcatenation();
132 _builder.append("oppositeReference ");
133 String _name = connectedTo.getName();
134 _builder.append(_name);
135 _builder.append(" ");
136 String _name_1 = connectedTo.getName();
137 _builder.append(_name_1);
138 final Function1<VariableContext, TermDescription> _function = (VariableContext it) -> {
139 Iff _xblockexpression_1 = null;
140 {
141 StringConcatenation _builder_1 = new StringConcatenation();
142 _builder_1.append("src");
143 final Variable src = it.addVar(_builder_1, segment);
144 StringConcatenation _builder_2 = new StringConcatenation();
145 _builder_2.append("trg");
146 final Variable trg = it.addVar(_builder_2, segment);
147 SymbolicValue _call = this._logicProblemBuilder.call(connectedToIndicator, src, trg);
148 SymbolicValue _call_1 = this._logicProblemBuilder.call(connectedToIndicator, trg, src);
149 _xblockexpression_1 = this._logicProblemBuilder.operator_spaceship(_call, _call_1);
150 }
151 return _xblockexpression_1;
152 };
153 final Assertion inverseAssertion = this._logicProblemBuilder.Assertion(_builder,
154 this._logicProblemBuilder.Forall(_function));
155 EList<Assertion> _assertions = metamodelLogic.getOutput().getAssertions();
156 _assertions.add(inverseAssertion);
157 InverseRelationAssertion _createInverseRelationAssertion = Ecore2logicannotationsFactory.eINSTANCE.createInverseRelationAssertion();
158 final Procedure1<InverseRelationAssertion> _function_1 = (InverseRelationAssertion it) -> {
159 it.setTarget(inverseAssertion);
160 it.setInverseA(connectedTo);
161 it.setInverseB(connectedTo);
162 };
163 final InverseRelationAssertion inverseAnnotation = ObjectExtensions.<InverseRelationAssertion>operator_doubleArrow(_createInverseRelationAssertion, _function_1);
164 EList<Annotation> _annotations = metamodelLogic.getOutput().getAnnotations();
165 _annotations.add(inverseAnnotation);
166 final List<EObject> initialModel = Modes3ModelGenerator.loadInitialModel();
167 final TracedOutput<LogicProblem, Ecore2Logic_Trace> initialModelLogic = this.instanceModel2Logic.transform(metamodelLogic, initialModel);
168 final ViatraQuerySetDescriptor queries = this.loadQueries();
169 Viatra2LogicConfiguration _viatra2LogicConfiguration = new Viatra2LogicConfiguration();
170 final TracedOutput<LogicProblem, Viatra2LogicTrace> logic = this.viatra2Logic.transformQueries(queries, initialModelLogic, _viatra2LogicConfiguration);
171 ViatraReasonerConfiguration _viatraReasonerConfiguration = new ViatraReasonerConfiguration();
172 final Procedure1<ViatraReasonerConfiguration> _function_2 = (ViatraReasonerConfiguration it) -> {
173 it.runtimeLimit = 3600;
174 final Procedure1<TypeScopes> _function_3 = (TypeScopes it_1) -> {
175 it_1.minNewElements = this.modelSize;
176 it_1.maxNewElements = this.modelSize;
177 final Procedure1<Map<Type, Integer>> _function_4 = (Map<Type, Integer> it_2) -> {
178 it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getTurnout()), Integer.valueOf(1));
179 };
180 ObjectExtensions.<Map<Type, Integer>>operator_doubleArrow(
181 it_1.minNewElementsByType, _function_4);
182 final Procedure1<Map<Type, Integer>> _function_5 = (Map<Type, Integer> it_2) -> {
183 it_2.put(this.ecore2Logic.TypeofEClass(metamodelLogic.getTrace(), Modes3Package.eINSTANCE.getTrain()), Integer.valueOf(5));
184 };
185 ObjectExtensions.<Map<Type, Integer>>operator_doubleArrow(
186 it_1.maxNewElementsByType, _function_5);
187 };
188 ObjectExtensions.<TypeScopes>operator_doubleArrow(
189 it.typeScopes, _function_3);
190 it.solutionScope.numberOfRequiredSolutions = 1;
191 it.nameNewElements = false;
192 it.typeInferenceMethod = TypeInferenceMethod.PreliminaryAnalysis;
193 it.stateCoderStrategy = StateCoderStrategy.Neighbourhood;
194 ScopePropagatorStrategy.Polyhedral _polyhedral = new ScopePropagatorStrategy.Polyhedral(
195 PolyhedralScopePropagatorConstraints.Relational, PolyhedralScopePropagatorSolver.Clp);
196 it.scopePropagatorStrategy = _polyhedral;
197 it.debugConfiguration.partialInterpretatioVisualiser = null;
198 };
199 final ViatraReasonerConfiguration config = ObjectExtensions.<ViatraReasonerConfiguration>operator_doubleArrow(_viatraReasonerConfiguration, _function_2);
200 final FileSystemWorkspace workspace = new FileSystemWorkspace("output/", "");
201 final LogicResult solution = this.solver.solve(logic.getOutput(), config, workspace);
202 URI _xifexpression = null;
203 if ((solution instanceof ModelResult)) {
204 InputOutput.<String>println("Saving generated solutions");
205 final EList<Object> representations = ((ModelResult)solution).getRepresentation();
206 int _size = representations.size();
207 ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _size, true);
208 for (final Integer representationIndex : _doubleDotLessThan) {
209 {
210 final Object representation = representations.get((representationIndex).intValue());
211 final int representationNumber = ((representationIndex).intValue() + 1);
212 if ((representation instanceof PartialInterpretation)) {
213 StringConcatenation _builder_1 = new StringConcatenation();
214 _builder_1.append("solution");
215 _builder_1.append(representationNumber);
216 _builder_1.append(".partialinterpretation");
217 workspace.writeModel(((EObject)representation), _builder_1.toString());
218 final PartialInterpretation2Gml partialInterpretation2GML = new PartialInterpretation2Gml();
219 final String gml = partialInterpretation2GML.transform(((PartialInterpretation)representation));
220 StringConcatenation _builder_2 = new StringConcatenation();
221 _builder_2.append("solution");
222 _builder_2.append(representationNumber);
223 _builder_2.append(".gml");
224 workspace.writeText(_builder_2.toString(), gml);
225 int _size_1 = ((PartialInterpretation)representation).getNewElements().size();
226 boolean _lessThan = (_size_1 < 160);
227 if (_lessThan) {
228 if ((representation instanceof PartialInterpretation)) {
229 final Consumer<Type> _function_3 = (Type it) -> {
230 InputOutput.<String>println(it.getName());
231 };
232 ((PartialInterpretation)representation).getProblem().getTypes().forEach(_function_3);
233 final Function1<Type, Boolean> _function_4 = (Type it) -> {
234 String _name_2 = it.getName();
235 return Boolean.valueOf(Objects.equal(_name_2, "Modes3ModelRoot class DefinedPart"));
236 };
237 Type _findFirst = IterableExtensions.<Type>findFirst(((PartialInterpretation)representation).getProblem().getTypes(), _function_4);
238 final TypeDefinition rootType = ((TypeDefinition) _findFirst);
239 final Function1<PartialComplexTypeInterpretation, Boolean> _function_5 = (PartialComplexTypeInterpretation it) -> {
240 String _name_2 = it.getInterpretationOf().getName();
241 return Boolean.valueOf(Objects.equal(_name_2, "Modes3ModelRoot class"));
242 };
243 final PartialComplexTypeInterpretation rootIntepretation = IterableExtensions.<PartialComplexTypeInterpretation>findFirst(Iterables.<PartialComplexTypeInterpretation>filter(((PartialInterpretation)representation).getPartialtypeinterpratation(),
244 PartialComplexTypeInterpretation.class), _function_5);
245 rootIntepretation.getElements().removeAll(rootType.getElements());
246 ((PartialInterpretation)representation).getProblem().getElements().removeAll(rootType.getElements());
247 EList<PartialRelationInterpretation> _partialrelationinterpretation = ((PartialInterpretation)representation).getPartialrelationinterpretation();
248 for (final PartialRelationInterpretation relationInterpretation : _partialrelationinterpretation) {
249 final Predicate<RelationLink> _function_6 = (RelationLink link) -> {
250 boolean _xifexpression_1 = false;
251 if ((link instanceof BinaryElementRelationLink)) {
252 _xifexpression_1 = (rootType.getElements().contains(((BinaryElementRelationLink)link).getParam1()) || rootType.getElements().contains(((BinaryElementRelationLink)link).getParam2()));
253 } else {
254 _xifexpression_1 = false;
255 }
256 return _xifexpression_1;
257 };
258 relationInterpretation.getRelationlinks().removeIf(_function_6);
259 }
260 rootType.getElements().clear();
261 }
262 final GraphvizVisualiser visualiser = new GraphvizVisualiser();
263 final PartialInterpretationVisualisation visualisation = visualiser.visualiseConcretization(((PartialInterpretation)representation));
264 StringConcatenation _builder_3 = new StringConcatenation();
265 _builder_3.append("solution");
266 _builder_3.append(representationNumber);
267 _builder_3.append(".png");
268 visualisation.writeToFile(workspace, _builder_3.toString());
269 }
270 } else {
271 StringConcatenation _builder_4 = new StringConcatenation();
272 _builder_4.append("solution");
273 _builder_4.append(representationNumber);
274 _builder_4.append(".txt");
275 workspace.writeText(_builder_4.toString(), representation.toString());
276 }
277 }
278 }
279 } else {
280 URI _xblockexpression_1 = null;
281 {
282 InputOutput.<String>println("Failed to solver problem");
283 final LogicProblem partial = logic.getOutput();
284 _xblockexpression_1 = workspace.writeModel(partial, "solution.partialinterpretation");
285 }
286 _xifexpression = _xblockexpression_1;
287 }
288 _xblockexpression = _xifexpression;
289 }
290 return _xblockexpression;
291 } catch (Throwable _e) {
292 throw Exceptions.sneakyThrow(_e);
293 }
294 }
295
296 public static EcoreMetamodelDescriptor createMetamodelDescriptor() {
297 EcoreMetamodelDescriptor _xblockexpression = null;
298 {
299 final ImmutableList<EClass> eClasses = ImmutableList.<EClass>copyOf(Iterables.<EClass>filter(Modes3Package.eINSTANCE.getEClassifiers(), EClass.class));
300 Set<EClass> _emptySet = CollectionLiterals.<EClass>emptySet();
301 List<EEnum> _emptyList = CollectionLiterals.<EEnum>emptyList();
302 List<EEnumLiteral> _emptyList_1 = CollectionLiterals.<EEnumLiteral>emptyList();
303 final Function1<EClass, EList<EReference>> _function = (EClass it) -> {
304 return it.getEReferences();
305 };
306 ImmutableList<EReference> _copyOf = ImmutableList.<EReference>copyOf(IterableExtensions.<EClass, EReference>flatMap(eClasses, _function));
307 List<EAttribute> _emptyList_2 = CollectionLiterals.<EAttribute>emptyList();
308 _xblockexpression = new EcoreMetamodelDescriptor(eClasses, _emptySet,
309 false, _emptyList, _emptyList_1, _copyOf, _emptyList_2);
310 }
311 return _xblockexpression;
312 }
313
314 public static List<EObject> loadInitialModel() {
315 Modes3ModelRoot _createModes3ModelRoot = Modes3Factory.eINSTANCE.createModes3ModelRoot();
316 return Collections.<EObject>unmodifiableList(CollectionLiterals.<EObject>newArrayList(_createModes3ModelRoot));
317 }
318
319 public ViatraQuerySetDescriptor loadQueries() {
320 ViatraQuerySetDescriptor _xblockexpression = null;
321 {
322 final ImmutableList.Builder<IQuerySpecification<?>> patternsBuilder = ImmutableList.<IQuerySpecification<?>>builder();
323 patternsBuilder.addAll(Modes3Queries.instance().getSpecifications());
324 final ImmutableList<IQuerySpecification<?>> patterns = patternsBuilder.build();
325 final Function1<IQuerySpecification<?>, Boolean> _function = (IQuerySpecification<?> pattern) -> {
326 final Function1<PAnnotation, Boolean> _function_1 = (PAnnotation it) -> {
327 String _name = it.getName();
328 return Boolean.valueOf(Objects.equal(_name, "Constraint"));
329 };
330 return Boolean.valueOf(IterableExtensions.<PAnnotation>exists(pattern.getAllAnnotations(), _function_1));
331 };
332 final ImmutableSet<IQuerySpecification<?>> validationPatterns = ImmutableSet.<IQuerySpecification<?>>copyOf(IterableExtensions.<IQuerySpecification<?>>filter(patterns, _function));
333 Map<IQuerySpecification<?>, EStructuralFeature> _emptyMap = CollectionLiterals.<IQuerySpecification<?>, EStructuralFeature>emptyMap();
334 _xblockexpression = new ViatraQuerySetDescriptor(patterns, validationPatterns, _emptyMap);
335 }
336 return _xblockexpression;
337 }
338
339 public static Object init() {
340 Object _xblockexpression = null;
341 {
342 EMFPatternLanguageStandaloneSetup.doSetup();
343 ViatraQueryEngineOptions.setSystemDefaultBackends(ReteBackendFactory.INSTANCE, ReteBackendFactory.INSTANCE,
344 LocalSearchEMFBackendFactory.INSTANCE);
345 LogiclanguagePackage.eINSTANCE.getClass();
346 LogicproblemPackage.eINSTANCE.getClass();
347 PartialinterpretationPackage.eINSTANCE.getClass();
348 Ecore2logicannotationsPackage.eINSTANCE.getClass();
349 Viatra2LogicAnnotationsPackage.eINSTANCE.getClass();
350 Map<String, Object> _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
351 XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
352 _extensionToFactoryMap.put("ecore", _xMIResourceFactoryImpl);
353 Map<String, Object> _extensionToFactoryMap_1 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
354 XMIResourceFactoryImpl _xMIResourceFactoryImpl_1 = new XMIResourceFactoryImpl();
355 _extensionToFactoryMap_1.put("logicproblem", _xMIResourceFactoryImpl_1);
356 Map<String, Object> _extensionToFactoryMap_2 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
357 XMIResourceFactoryImpl _xMIResourceFactoryImpl_2 = new XMIResourceFactoryImpl();
358 _xblockexpression = _extensionToFactoryMap_2.put("partialinterpretation", _xMIResourceFactoryImpl_2);
359 }
360 return _xblockexpression;
361 }
362
363 public static void main(final String[] args) {
364 int _length = args.length;
365 boolean _notEquals = (_length != 2);
366 if (_notEquals) {
367 System.err.println("Usage: <query> <model size>");
368 }
369 final Modes3ModelGenerator.MonitoringQuery monitoringQuery = Modes3ModelGenerator.MonitoringQuery.valueOf(args[0]);
370 final int modelSize = Integer.parseInt(args[1]);
371 Modes3ModelGenerator.init();
372 final Modes3ModelGenerator generator = new Modes3ModelGenerator(monitoringQuery, modelSize);
373 generator.generate();
374 }
375
376 public Modes3ModelGenerator(final Modes3ModelGenerator.MonitoringQuery monitoringQuery, final int modelSize) {
377 super();
378 this.monitoringQuery = monitoringQuery;
379 this.modelSize = modelSize;
380 }
381}
diff --git a/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java
new file mode 100644
index 00000000..91adaaaa
--- /dev/null
+++ b/Domains/ca.mcgill.rtgmrt.example.modes3/xtend-gen/modes3/run/Modes3UnitPropagationGenerator.java
@@ -0,0 +1,585 @@
1package modes3.run;
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
4import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation;
6import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
7import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality;
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator;
9import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.UnitPropagationPatternGenerator;
10import java.util.Collections;
11import java.util.Map;
12import modes3.Modes3Package;
13import modes3.queries.ExtraInputOfTurnout;
14import modes3.queries.Output;
15import modes3.queries.TurnoutOutput;
16import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
17import org.eclipse.xtend2.lib.StringConcatenationClient;
18import org.eclipse.xtext.xbase.lib.CollectionLiterals;
19import org.eclipse.xtext.xbase.lib.Extension;
20import org.eclipse.xtext.xbase.lib.Pair;
21
22@SuppressWarnings("all")
23public class Modes3UnitPropagationGenerator implements UnitPropagationPatternGenerator {
24 private static final String MUST_NOT_CONNECTED_TO = "mustNotConnectedTo";
25
26 private static final String MUST_NOT_CONNECTED_TO_HELPER = "mustNotConnectedTo_helper";
27
28 private static final String MUST_NOT_TURNOUT_OUTPUT = "mustNotTurnoutOutput";
29
30 private static final String MUST_NOT_STRAIGHT = "mustNotStraight";
31
32 private static final String MUST_NOT_DIVERGENT = "mustNotDivergent";
33
34 private final Type segmentType;
35
36 private final Type turnoutType;
37
38 private final Relation connectedToRelation;
39
40 private final Relation straightRelation;
41
42 private final Relation divergentRelation;
43
44 public Modes3UnitPropagationGenerator(@Extension final Ecore2Logic ecore2Logic, final Ecore2Logic_Trace ecore2LogicTrace) {
45 @Extension
46 final Modes3Package Modes3Package = modes3.Modes3Package.eINSTANCE;
47 this.segmentType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getSegment());
48 this.turnoutType = ecore2Logic.TypeofEClass(ecore2LogicTrace, Modes3Package.getTurnout());
49 this.connectedToRelation = ecore2Logic.relationOfReference(ecore2LogicTrace, Modes3Package.getSegment_ConnectedTo());
50 this.straightRelation = ecore2Logic.relationOfReference(ecore2LogicTrace, Modes3Package.getTurnout_Straight());
51 this.divergentRelation = ecore2Logic.relationOfReference(ecore2LogicTrace, Modes3Package.getTurnout_Divergent());
52 }
53
54 @Override
55 public Map<Relation, String> getMustPatterns() {
56 return CollectionLiterals.<Relation, String>emptyMap();
57 }
58
59 @Override
60 public Map<Relation, String> getMustNotPatterns() {
61 Pair<Relation, String> _mappedTo = Pair.<Relation, String>of(this.connectedToRelation, Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO);
62 Pair<Relation, String> _mappedTo_1 = Pair.<Relation, String>of(this.straightRelation, Modes3UnitPropagationGenerator.MUST_NOT_STRAIGHT);
63 Pair<Relation, String> _mappedTo_2 = Pair.<Relation, String>of(this.divergentRelation, Modes3UnitPropagationGenerator.MUST_NOT_DIVERGENT);
64 return Collections.<Relation, String>unmodifiableMap(CollectionLiterals.<Relation, String>newHashMap(_mappedTo, _mappedTo_1, _mappedTo_2));
65 }
66
67 @Override
68 public StringConcatenationClient getAdditionalPatterns(@Extension final PatternGenerator generator, final Map<String, PQuery> fqnToPQuery) {
69 StringConcatenationClient _xblockexpression = null;
70 {
71 StringConcatenationClient _client = new StringConcatenationClient() {
72 @Override
73 protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
74 _builder.append("problem: LogicProblem, interpretation: PartialInterpretation,");
75 _builder.newLine();
76 _builder.append("source: DefinedElement, target: DefinedElement");
77 _builder.newLine();
78 }
79 };
80 final StringConcatenationClient parameters = _client;
81 StringConcatenationClient _client_1 = new StringConcatenationClient() {
82 @Override
83 protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
84 _builder.append("find interpretation(problem, interpretation);");
85 _builder.newLine();
86 _builder.append("find mustExist(problem, interpretation, source);");
87 _builder.newLine();
88 _builder.append("find mustExist(problem, interpretation, target);");
89 _builder.newLine();
90 }
91 };
92 final StringConcatenationClient commonParameterConstraints = _client_1;
93 StringConcatenationClient _client_2 = new StringConcatenationClient() {
94 @Override
95 protected void appendTo(StringConcatenationClient.TargetStringConcatenation _builder) {
96 _builder.append("pattern ");
97 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO_HELPER);
98 _builder.append("(");
99 _builder.append(parameters);
100 _builder.append(") {");
101 _builder.newLineIfNotEmpty();
102 _builder.append("\t");
103 _builder.append("// connectedToReflexive unit propagation");
104 _builder.newLine();
105 _builder.append("\t");
106 _builder.append(commonParameterConstraints, "\t");
107 _builder.newLineIfNotEmpty();
108 _builder.append("\t");
109 CharSequence _referInstanceOf = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "source");
110 _builder.append(_referInstanceOf, "\t");
111 _builder.newLineIfNotEmpty();
112 _builder.append("\t");
113 CharSequence _referInstanceOf_1 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
114 _builder.append(_referInstanceOf_1, "\t");
115 _builder.newLineIfNotEmpty();
116 _builder.append("\t");
117 _builder.append("source == target;");
118 _builder.newLine();
119 _builder.append("} or {");
120 _builder.newLine();
121 _builder.append("\t");
122 _builder.append("// tooManyInputsOfSegment unit propagation");
123 _builder.newLine();
124 _builder.append("\t");
125 _builder.append(commonParameterConstraints, "\t");
126 _builder.newLineIfNotEmpty();
127 _builder.append("\t");
128 CharSequence _referInstanceOf_2 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "source");
129 _builder.append(_referInstanceOf_2, "\t");
130 _builder.newLineIfNotEmpty();
131 _builder.append("\t");
132 CharSequence _referInstanceOf_3 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
133 _builder.append(_referInstanceOf_3, "\t");
134 _builder.newLineIfNotEmpty();
135 _builder.append("\t");
136 CharSequence _referInstanceOf_4 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "input1");
137 _builder.append(_referInstanceOf_4, "\t");
138 _builder.newLineIfNotEmpty();
139 _builder.append("\t");
140 CharSequence _referInstanceOf_5 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "input2");
141 _builder.append(_referInstanceOf_5, "\t");
142 _builder.newLineIfNotEmpty();
143 _builder.append("\t");
144 _builder.append("neg ");
145 CharSequence _referInstanceOf_6 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "source");
146 _builder.append(_referInstanceOf_6, "\t");
147 _builder.newLineIfNotEmpty();
148 _builder.append("\t");
149 CharSequence _referPattern = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "input1", "source" }, Modality.MUST, true, false);
150 _builder.append(_referPattern, "\t");
151 _builder.newLineIfNotEmpty();
152 _builder.append("\t");
153 CharSequence _referPattern_1 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "input2", "source" }, Modality.MUST, true, false);
154 _builder.append(_referPattern_1, "\t");
155 _builder.newLineIfNotEmpty();
156 _builder.append("\t");
157 _builder.append("input1 != input2;");
158 _builder.newLine();
159 _builder.append("\t");
160 _builder.append("input1 != target;");
161 _builder.newLine();
162 _builder.append("\t");
163 _builder.append("input2 != target;");
164 _builder.newLine();
165 _builder.append("} or {");
166 _builder.newLine();
167 _builder.append("\t");
168 _builder.append("// turnoutConnectedToBothOutputs unit propagation 1");
169 _builder.newLine();
170 _builder.append("\t");
171 _builder.append(commonParameterConstraints, "\t");
172 _builder.newLineIfNotEmpty();
173 _builder.append("\t");
174 CharSequence _referInstanceOf_7 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
175 _builder.append(_referInstanceOf_7, "\t");
176 _builder.newLineIfNotEmpty();
177 _builder.append("\t");
178 CharSequence _referInstanceOf_8 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
179 _builder.append(_referInstanceOf_8, "\t");
180 _builder.newLineIfNotEmpty();
181 _builder.append("\t");
182 CharSequence _referInstanceOf_9 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "divergent");
183 _builder.append(_referInstanceOf_9, "\t");
184 _builder.newLineIfNotEmpty();
185 _builder.append("\t");
186 CharSequence _referRelation = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MUST, fqnToPQuery);
187 _builder.append(_referRelation, "\t");
188 _builder.newLineIfNotEmpty();
189 _builder.append("\t");
190 CharSequence _referRelation_1 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "divergent", Modality.MUST, fqnToPQuery);
191 _builder.append(_referRelation_1, "\t");
192 _builder.newLineIfNotEmpty();
193 _builder.append("\t");
194 CharSequence _referRelation_2 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "divergent", Modality.MUST, fqnToPQuery);
195 _builder.append(_referRelation_2, "\t");
196 _builder.newLineIfNotEmpty();
197 _builder.append("} or {");
198 _builder.newLine();
199 _builder.append("\t");
200 _builder.append("// turnoutConnectedToBothOutputs unit propagation 2");
201 _builder.newLine();
202 _builder.append("\t");
203 _builder.append(commonParameterConstraints, "\t");
204 _builder.newLineIfNotEmpty();
205 _builder.append("\t");
206 CharSequence _referInstanceOf_10 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
207 _builder.append(_referInstanceOf_10, "\t");
208 _builder.newLineIfNotEmpty();
209 _builder.append("\t");
210 CharSequence _referInstanceOf_11 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
211 _builder.append(_referInstanceOf_11, "\t");
212 _builder.newLineIfNotEmpty();
213 _builder.append("\t");
214 CharSequence _referInstanceOf_12 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "straight");
215 _builder.append(_referInstanceOf_12, "\t");
216 _builder.newLineIfNotEmpty();
217 _builder.append("\t");
218 CharSequence _referRelation_3 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "straight", Modality.MUST, fqnToPQuery);
219 _builder.append(_referRelation_3, "\t");
220 _builder.newLineIfNotEmpty();
221 _builder.append("\t");
222 CharSequence _referRelation_4 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MUST, fqnToPQuery);
223 _builder.append(_referRelation_4, "\t");
224 _builder.newLineIfNotEmpty();
225 _builder.append("\t");
226 CharSequence _referRelation_5 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "straight", Modality.MUST, fqnToPQuery);
227 _builder.append(_referRelation_5, "\t");
228 _builder.newLineIfNotEmpty();
229 _builder.append("} or {");
230 _builder.newLine();
231 _builder.append("\t");
232 _builder.append("// tooManyExtraInputsOfTurnout unit propagation");
233 _builder.newLine();
234 _builder.append("\t");
235 _builder.append(commonParameterConstraints, "\t");
236 _builder.newLineIfNotEmpty();
237 _builder.append("\t");
238 CharSequence _referInstanceOf_13 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
239 _builder.append(_referInstanceOf_13, "\t");
240 _builder.newLineIfNotEmpty();
241 _builder.append("\t");
242 CharSequence _referInstanceOf_14 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
243 _builder.append(_referInstanceOf_14, "\t");
244 _builder.newLineIfNotEmpty();
245 _builder.append("\t");
246 CharSequence _referInstanceOf_15 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "extraInput");
247 _builder.append(_referInstanceOf_15, "\t");
248 _builder.newLineIfNotEmpty();
249 _builder.append("\t");
250 CharSequence _referPattern_2 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(TurnoutOutput.instance().getFullyQualifiedName()), new String[] { "source", "target" }, Modality.MAY, false, false);
251 _builder.append(_referPattern_2, "\t");
252 _builder.newLineIfNotEmpty();
253 _builder.append("\t");
254 CharSequence _referPattern_3 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(ExtraInputOfTurnout.instance().getFullyQualifiedName()), new String[] { "source", "extraInput" }, Modality.MUST, true, false);
255 _builder.append(_referPattern_3, "\t");
256 _builder.newLineIfNotEmpty();
257 _builder.append("\t");
258 _builder.append("target != extraInput;");
259 _builder.newLine();
260 _builder.append("}");
261 _builder.newLine();
262 _builder.newLine();
263 _builder.append("pattern ");
264 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO);
265 _builder.append("(");
266 _builder.append(parameters);
267 _builder.append(") {");
268 _builder.newLineIfNotEmpty();
269 _builder.append("\t");
270 _builder.append("find ");
271 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO_HELPER, "\t");
272 _builder.append("(problem, interpretation, source, target);");
273 _builder.newLineIfNotEmpty();
274 _builder.append("} or {");
275 _builder.newLine();
276 _builder.append("\t");
277 _builder.append("find ");
278 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_CONNECTED_TO_HELPER, "\t");
279 _builder.append("(problem, interpretation, target, source);");
280 _builder.newLineIfNotEmpty();
281 _builder.append("}");
282 _builder.newLine();
283 _builder.newLine();
284 _builder.append("pattern ");
285 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_TURNOUT_OUTPUT);
286 _builder.append("(");
287 _builder.append(parameters);
288 _builder.append(") {");
289 _builder.newLineIfNotEmpty();
290 _builder.append("\t");
291 _builder.append("// outputReflexive unit propagation");
292 _builder.newLine();
293 _builder.append("\t");
294 _builder.append(commonParameterConstraints, "\t");
295 _builder.newLineIfNotEmpty();
296 _builder.append("\t");
297 CharSequence _referInstanceOf_16 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
298 _builder.append(_referInstanceOf_16, "\t");
299 _builder.newLineIfNotEmpty();
300 _builder.append("\t");
301 CharSequence _referInstanceOf_17 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "target");
302 _builder.append(_referInstanceOf_17, "\t");
303 _builder.newLineIfNotEmpty();
304 _builder.append("\t");
305 _builder.append("source == target;");
306 _builder.newLine();
307 _builder.append("} or {");
308 _builder.newLine();
309 _builder.append("\t");
310 _builder.append("// tooManyInputsOfSegment unit propagation");
311 _builder.newLine();
312 _builder.append("\t");
313 _builder.append(commonParameterConstraints, "\t");
314 _builder.newLineIfNotEmpty();
315 _builder.append("\t");
316 CharSequence _referInstanceOf_18 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
317 _builder.append(_referInstanceOf_18, "\t");
318 _builder.newLineIfNotEmpty();
319 _builder.append("\t");
320 CharSequence _referInstanceOf_19 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
321 _builder.append(_referInstanceOf_19, "\t");
322 _builder.newLineIfNotEmpty();
323 _builder.append("\t");
324 CharSequence _referInstanceOf_20 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "input1");
325 _builder.append(_referInstanceOf_20, "\t");
326 _builder.newLineIfNotEmpty();
327 _builder.append("\t");
328 CharSequence _referInstanceOf_21 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "input2");
329 _builder.append(_referInstanceOf_21, "\t");
330 _builder.newLineIfNotEmpty();
331 _builder.append("\t");
332 _builder.append("neg ");
333 CharSequence _referInstanceOf_22 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MAY, "target");
334 _builder.append(_referInstanceOf_22, "\t");
335 _builder.newLineIfNotEmpty();
336 _builder.append("\t");
337 CharSequence _referPattern_4 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "input1", "target" }, Modality.MUST, true, false);
338 _builder.append(_referPattern_4, "\t");
339 _builder.newLineIfNotEmpty();
340 _builder.append("\t");
341 CharSequence _referPattern_5 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(Output.instance().getFullyQualifiedName()), new String[] { "input2", "target" }, Modality.MUST, true, false);
342 _builder.append(_referPattern_5, "\t");
343 _builder.newLineIfNotEmpty();
344 _builder.append("\t");
345 _builder.append("input1 != input2;");
346 _builder.newLine();
347 _builder.append("\t");
348 _builder.append("input1 != source;");
349 _builder.newLine();
350 _builder.append("\t");
351 _builder.append("input2 != source;");
352 _builder.newLine();
353 _builder.append("}");
354 _builder.newLine();
355 _builder.newLine();
356 _builder.append("pattern ");
357 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_STRAIGHT);
358 _builder.append("(");
359 _builder.append(parameters);
360 _builder.append(") {");
361 _builder.newLineIfNotEmpty();
362 _builder.append("\t");
363 _builder.append("find ");
364 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_TURNOUT_OUTPUT, "\t");
365 _builder.append("(problem, interpretation, source, target);");
366 _builder.newLineIfNotEmpty();
367 _builder.append("} or {");
368 _builder.newLine();
369 _builder.append("\t");
370 _builder.append("// turnoutOutputsAreSame unit propagation");
371 _builder.newLine();
372 _builder.append("\t");
373 _builder.append(commonParameterConstraints, "\t");
374 _builder.newLineIfNotEmpty();
375 _builder.append("\t");
376 CharSequence _referInstanceOf_23 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
377 _builder.append(_referInstanceOf_23, "\t");
378 _builder.newLineIfNotEmpty();
379 _builder.append("\t");
380 CharSequence _referInstanceOf_24 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
381 _builder.append(_referInstanceOf_24, "\t");
382 _builder.newLineIfNotEmpty();
383 _builder.append("\t");
384 CharSequence _referRelation_6 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "target", Modality.MUST, fqnToPQuery);
385 _builder.append(_referRelation_6, "\t");
386 _builder.newLineIfNotEmpty();
387 _builder.append("} or {");
388 _builder.newLine();
389 _builder.append("\t");
390 _builder.append("// turnoutConnectedToBothOutputs unit propagation");
391 _builder.newLine();
392 _builder.append("\t");
393 _builder.append(commonParameterConstraints, "\t");
394 _builder.newLineIfNotEmpty();
395 _builder.append("\t");
396 CharSequence _referInstanceOf_25 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
397 _builder.append(_referInstanceOf_25, "\t");
398 _builder.newLineIfNotEmpty();
399 _builder.append("\t");
400 CharSequence _referInstanceOf_26 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
401 _builder.append(_referInstanceOf_26, "\t");
402 _builder.newLineIfNotEmpty();
403 _builder.append("\t");
404 CharSequence _referInstanceOf_27 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "divergent");
405 _builder.append(_referInstanceOf_27, "\t");
406 _builder.newLineIfNotEmpty();
407 _builder.append("\t");
408 CharSequence _referRelation_7 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "target", Modality.MUST, fqnToPQuery);
409 _builder.append(_referRelation_7, "\t");
410 _builder.newLineIfNotEmpty();
411 _builder.append("\t");
412 CharSequence _referRelation_8 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "divergent", Modality.MUST, fqnToPQuery);
413 _builder.append(_referRelation_8, "\t");
414 _builder.newLineIfNotEmpty();
415 _builder.append("\t");
416 CharSequence _referRelation_9 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "divergent", Modality.MUST, fqnToPQuery);
417 _builder.append(_referRelation_9, "\t");
418 _builder.newLineIfNotEmpty();
419 _builder.append("} or {");
420 _builder.newLine();
421 _builder.append("\t");
422 _builder.append("// tooManyExtraInputsOfTurnout unit propagation");
423 _builder.newLine();
424 _builder.append("\t");
425 _builder.append(commonParameterConstraints, "\t");
426 _builder.newLineIfNotEmpty();
427 _builder.append("\t");
428 CharSequence _referInstanceOf_28 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
429 _builder.append(_referInstanceOf_28, "\t");
430 _builder.newLineIfNotEmpty();
431 _builder.append("\t");
432 CharSequence _referInstanceOf_29 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
433 _builder.append(_referInstanceOf_29, "\t");
434 _builder.newLineIfNotEmpty();
435 _builder.append("\t");
436 CharSequence _referInstanceOf_30 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "extraInput");
437 _builder.append(_referInstanceOf_30, "\t");
438 _builder.newLineIfNotEmpty();
439 _builder.append("\t");
440 CharSequence _referInstanceOf_31 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "potentialExtraInput");
441 _builder.append(_referInstanceOf_31, "\t");
442 _builder.newLineIfNotEmpty();
443 _builder.append("\t");
444 CharSequence _referPattern_6 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(ExtraInputOfTurnout.instance().getFullyQualifiedName()), new String[] { "source", "extraInput" }, Modality.MUST, true, false);
445 _builder.append(_referPattern_6, "\t");
446 _builder.newLineIfNotEmpty();
447 _builder.append("\t");
448 CharSequence _referRelation_10 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "potentialExtraInput", Modality.MUST, fqnToPQuery);
449 _builder.append(_referRelation_10, "\t");
450 _builder.newLineIfNotEmpty();
451 _builder.append("\t");
452 _builder.append("neg ");
453 CharSequence _referRelation_11 = generator.referRelation(Modes3UnitPropagationGenerator.this.divergentRelation, "source", "potentialExtraInput", Modality.MAY, fqnToPQuery);
454 _builder.append(_referRelation_11, "\t");
455 _builder.newLineIfNotEmpty();
456 _builder.append("\t");
457 _builder.append("extraInput != potentialExtraInput;");
458 _builder.newLine();
459 _builder.append("\t");
460 _builder.append("extraInput != target;");
461 _builder.newLine();
462 _builder.append("\t");
463 _builder.append("potentialExtraInput != target;");
464 _builder.newLine();
465 _builder.append("}");
466 _builder.newLine();
467 _builder.newLine();
468 _builder.append("pattern ");
469 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_DIVERGENT);
470 _builder.append("(");
471 _builder.append(parameters);
472 _builder.append(") {");
473 _builder.newLineIfNotEmpty();
474 _builder.append("\t");
475 _builder.append("find ");
476 _builder.append(Modes3UnitPropagationGenerator.MUST_NOT_TURNOUT_OUTPUT, "\t");
477 _builder.append("(problem, interpretation, source, target);");
478 _builder.newLineIfNotEmpty();
479 _builder.append("} or {");
480 _builder.newLine();
481 _builder.append("\t");
482 _builder.append("// turnoutOutputsAreSame unit propagation");
483 _builder.newLine();
484 _builder.append("\t");
485 _builder.append(commonParameterConstraints, "\t");
486 _builder.newLineIfNotEmpty();
487 _builder.append("\t");
488 CharSequence _referInstanceOf_32 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
489 _builder.append(_referInstanceOf_32, "\t");
490 _builder.newLineIfNotEmpty();
491 _builder.append("\t");
492 CharSequence _referInstanceOf_33 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
493 _builder.append(_referInstanceOf_33, "\t");
494 _builder.newLineIfNotEmpty();
495 _builder.append("\t");
496 CharSequence _referRelation_12 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "target", Modality.MUST, fqnToPQuery);
497 _builder.append(_referRelation_12, "\t");
498 _builder.newLineIfNotEmpty();
499 _builder.append("} or {");
500 _builder.newLine();
501 _builder.append("\t");
502 _builder.append("// turnoutConnectedToBothOutputs unit propagation");
503 _builder.newLine();
504 _builder.append("\t");
505 _builder.append(commonParameterConstraints, "\t");
506 _builder.newLineIfNotEmpty();
507 _builder.append("\t");
508 CharSequence _referInstanceOf_34 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
509 _builder.append(_referInstanceOf_34, "\t");
510 _builder.newLineIfNotEmpty();
511 _builder.append("\t");
512 CharSequence _referInstanceOf_35 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
513 _builder.append(_referInstanceOf_35, "\t");
514 _builder.newLineIfNotEmpty();
515 _builder.append("\t");
516 CharSequence _referInstanceOf_36 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "straight");
517 _builder.append(_referInstanceOf_36, "\t");
518 _builder.newLineIfNotEmpty();
519 _builder.append("\t");
520 CharSequence _referRelation_13 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "target", Modality.MUST, fqnToPQuery);
521 _builder.append(_referRelation_13, "\t");
522 _builder.newLineIfNotEmpty();
523 _builder.append("\t");
524 CharSequence _referRelation_14 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "straight", Modality.MUST, fqnToPQuery);
525 _builder.append(_referRelation_14, "\t");
526 _builder.newLineIfNotEmpty();
527 _builder.append("\t");
528 CharSequence _referRelation_15 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "straight", Modality.MUST, fqnToPQuery);
529 _builder.append(_referRelation_15, "\t");
530 _builder.newLineIfNotEmpty();
531 _builder.append("} or {");
532 _builder.newLine();
533 _builder.append("\t");
534 _builder.append("// tooManyExtraInputsOfTurnout unit propagation");
535 _builder.newLine();
536 _builder.append("\t");
537 _builder.append(commonParameterConstraints, "\t");
538 _builder.newLineIfNotEmpty();
539 _builder.append("\t");
540 CharSequence _referInstanceOf_37 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.turnoutType, Modality.MUST, "source");
541 _builder.append(_referInstanceOf_37, "\t");
542 _builder.newLineIfNotEmpty();
543 _builder.append("\t");
544 CharSequence _referInstanceOf_38 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "target");
545 _builder.append(_referInstanceOf_38, "\t");
546 _builder.newLineIfNotEmpty();
547 _builder.append("\t");
548 CharSequence _referInstanceOf_39 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "extraInput");
549 _builder.append(_referInstanceOf_39, "\t");
550 _builder.newLineIfNotEmpty();
551 _builder.append("\t");
552 CharSequence _referInstanceOf_40 = generator.getTypeIndexer().referInstanceOf(Modes3UnitPropagationGenerator.this.segmentType, Modality.MUST, "potentialExtraInput");
553 _builder.append(_referInstanceOf_40, "\t");
554 _builder.newLineIfNotEmpty();
555 _builder.append("\t");
556 CharSequence _referPattern_7 = generator.getRelationDefinitionIndexer().referPattern(fqnToPQuery.get(ExtraInputOfTurnout.instance().getFullyQualifiedName()), new String[] { "source", "extraInput" }, Modality.MUST, true, false);
557 _builder.append(_referPattern_7, "\t");
558 _builder.newLineIfNotEmpty();
559 _builder.append("\t");
560 CharSequence _referRelation_16 = generator.referRelation(Modes3UnitPropagationGenerator.this.connectedToRelation, "source", "potentialExtraInput", Modality.MUST, fqnToPQuery);
561 _builder.append(_referRelation_16, "\t");
562 _builder.newLineIfNotEmpty();
563 _builder.append("\t");
564 _builder.append("neg ");
565 CharSequence _referRelation_17 = generator.referRelation(Modes3UnitPropagationGenerator.this.straightRelation, "source", "potentialExtraInput", Modality.MAY, fqnToPQuery);
566 _builder.append(_referRelation_17, "\t");
567 _builder.newLineIfNotEmpty();
568 _builder.append("\t");
569 _builder.append("extraInput != potentialExtraInput;");
570 _builder.newLine();
571 _builder.append("\t");
572 _builder.append("extraInput != target;");
573 _builder.newLine();
574 _builder.append("\t");
575 _builder.append("potentialExtraInput != target;");
576 _builder.newLine();
577 _builder.append("}");
578 _builder.newLine();
579 }
580 };
581 _xblockexpression = _client_2;
582 }
583 return _xblockexpression;
584 }
585}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-05 11:09:01 +0000