aboutsummaryrefslogtreecommitdiffstats
path: root/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util
diff options
context:
space:
mode:
Diffstat (limited to 'org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util')
-rw-r--r--org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java518
-rw-r--r--org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java620
2 files changed, 1138 insertions, 0 deletions
diff --git a/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java b/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java
new file mode 100644
index 00000000..f228f54a
--- /dev/null
+++ b/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemAdapterFactory.java
@@ -0,0 +1,518 @@
1/**
2 */
3package org.eclipse.viatra.solver.language.model.problem.util;
4
5import org.eclipse.emf.common.notify.Adapter;
6import org.eclipse.emf.common.notify.Notifier;
7
8import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
9
10import org.eclipse.emf.ecore.EObject;
11
12import org.eclipse.viatra.solver.language.model.problem.*;
13
14/**
15 * <!-- begin-user-doc -->
16 * The <b>Adapter Factory</b> for the model.
17 * It provides an adapter <code>createXXX</code> method for each class of the model.
18 * <!-- end-user-doc -->
19 * @see org.eclipse.viatra.solver.language.model.problem.ProblemPackage
20 * @generated
21 */
22public class ProblemAdapterFactory extends AdapterFactoryImpl {
23 /**
24 * The cached model package.
25 * <!-- begin-user-doc -->
26 * <!-- end-user-doc -->
27 * @generated
28 */
29 protected static ProblemPackage modelPackage;
30
31 /**
32 * Creates an instance of the adapter factory.
33 * <!-- begin-user-doc -->
34 * <!-- end-user-doc -->
35 * @generated
36 */
37 public ProblemAdapterFactory() {
38 if (modelPackage == null) {
39 modelPackage = ProblemPackage.eINSTANCE;
40 }
41 }
42
43 /**
44 * Returns whether this factory is applicable for the type of the object.
45 * <!-- begin-user-doc -->
46 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
47 * <!-- end-user-doc -->
48 * @return whether this factory is applicable for the type of the object.
49 * @generated
50 */
51 @Override
52 public boolean isFactoryForType(Object object) {
53 if (object == modelPackage) {
54 return true;
55 }
56 if (object instanceof EObject) {
57 return ((EObject) object).eClass().getEPackage() == modelPackage;
58 }
59 return false;
60 }
61
62 /**
63 * The switch that delegates to the <code>createXXX</code> methods.
64 * <!-- begin-user-doc -->
65 * <!-- end-user-doc -->
66 * @generated
67 */
68 protected ProblemSwitch<Adapter> modelSwitch = new ProblemSwitch<Adapter>() {
69 @Override
70 public Adapter caseProblem(Problem object) {
71 return createProblemAdapter();
72 }
73
74 @Override
75 public Adapter caseRelation(Relation object) {
76 return createRelationAdapter();
77 }
78
79 @Override
80 public Adapter caseClassDeclaration(ClassDeclaration object) {
81 return createClassDeclarationAdapter();
82 }
83
84 @Override
85 public Adapter caseReferenceDeclaration(ReferenceDeclaration object) {
86 return createReferenceDeclarationAdapter();
87 }
88
89 @Override
90 public Adapter caseNamedElement(NamedElement object) {
91 return createNamedElementAdapter();
92 }
93
94 @Override
95 public Adapter casePredicateDefinition(PredicateDefinition object) {
96 return createPredicateDefinitionAdapter();
97 }
98
99 @Override
100 public Adapter caseParameter(Parameter object) {
101 return createParameterAdapter();
102 }
103
104 @Override
105 public Adapter caseVariable(Variable object) {
106 return createVariableAdapter();
107 }
108
109 @Override
110 public Adapter caseConjunction(Conjunction object) {
111 return createConjunctionAdapter();
112 }
113
114 @Override
115 public Adapter caseLiteral(Literal object) {
116 return createLiteralAdapter();
117 }
118
119 @Override
120 public Adapter caseAtom(Atom object) {
121 return createAtomAdapter();
122 }
123
124 @Override
125 public Adapter caseImplicitVariable(ImplicitVariable object) {
126 return createImplicitVariableAdapter();
127 }
128
129 @Override
130 public Adapter caseNegativeLiteral(NegativeLiteral object) {
131 return createNegativeLiteralAdapter();
132 }
133
134 @Override
135 public Adapter caseExistentialQuantifier(ExistentialQuantifier object) {
136 return createExistentialQuantifierAdapter();
137 }
138
139 @Override
140 public Adapter caseAssertion(Assertion object) {
141 return createAssertionAdapter();
142 }
143
144 @Override
145 public Adapter caseNode(Node object) {
146 return createNodeAdapter();
147 }
148
149 @Override
150 public Adapter caseScopeDeclaration(ScopeDeclaration object) {
151 return createScopeDeclarationAdapter();
152 }
153
154 @Override
155 public Adapter caseStatement(Statement object) {
156 return createStatementAdapter();
157 }
158
159 @Override
160 public Adapter caseTypeScope(TypeScope object) {
161 return createTypeScopeAdapter();
162 }
163
164 @Override
165 public Adapter caseMultiplicity(Multiplicity object) {
166 return createMultiplicityAdapter();
167 }
168
169 @Override
170 public Adapter caseRangeMultiplicity(RangeMultiplicity object) {
171 return createRangeMultiplicityAdapter();
172 }
173
174 @Override
175 public Adapter caseExactMultiplicity(ExactMultiplicity object) {
176 return createExactMultiplicityAdapter();
177 }
178
179 @Override
180 public Adapter defaultCase(EObject object) {
181 return createEObjectAdapter();
182 }
183 };
184
185 /**
186 * Creates an adapter for the <code>target</code>.
187 * <!-- begin-user-doc -->
188 * <!-- end-user-doc -->
189 * @param target the object to adapt.
190 * @return the adapter for the <code>target</code>.
191 * @generated
192 */
193 @Override
194 public Adapter createAdapter(Notifier target) {
195 return modelSwitch.doSwitch((EObject) target);
196 }
197
198 /**
199 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Problem <em>Problem</em>}'.
200 * <!-- begin-user-doc -->
201 * This default implementation returns null so that we can easily ignore cases;
202 * it's useful to ignore a case when inheritance will catch all the cases anyway.
203 * <!-- end-user-doc -->
204 * @return the new adapter.
205 * @see org.eclipse.viatra.solver.language.model.problem.Problem
206 * @generated
207 */
208 public Adapter createProblemAdapter() {
209 return null;
210 }
211
212 /**
213 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Relation <em>Relation</em>}'.
214 * <!-- begin-user-doc -->
215 * This default implementation returns null so that we can easily ignore cases;
216 * it's useful to ignore a case when inheritance will catch all the cases anyway.
217 * <!-- end-user-doc -->
218 * @return the new adapter.
219 * @see org.eclipse.viatra.solver.language.model.problem.Relation
220 * @generated
221 */
222 public Adapter createRelationAdapter() {
223 return null;
224 }
225
226 /**
227 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ClassDeclaration <em>Class Declaration</em>}'.
228 * <!-- begin-user-doc -->
229 * This default implementation returns null so that we can easily ignore cases;
230 * it's useful to ignore a case when inheritance will catch all the cases anyway.
231 * <!-- end-user-doc -->
232 * @return the new adapter.
233 * @see org.eclipse.viatra.solver.language.model.problem.ClassDeclaration
234 * @generated
235 */
236 public Adapter createClassDeclarationAdapter() {
237 return null;
238 }
239
240 /**
241 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration <em>Reference Declaration</em>}'.
242 * <!-- begin-user-doc -->
243 * This default implementation returns null so that we can easily ignore cases;
244 * it's useful to ignore a case when inheritance will catch all the cases anyway.
245 * <!-- end-user-doc -->
246 * @return the new adapter.
247 * @see org.eclipse.viatra.solver.language.model.problem.ReferenceDeclaration
248 * @generated
249 */
250 public Adapter createReferenceDeclarationAdapter() {
251 return null;
252 }
253
254 /**
255 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NamedElement <em>Named Element</em>}'.
256 * <!-- begin-user-doc -->
257 * This default implementation returns null so that we can easily ignore cases;
258 * it's useful to ignore a case when inheritance will catch all the cases anyway.
259 * <!-- end-user-doc -->
260 * @return the new adapter.
261 * @see org.eclipse.viatra.solver.language.model.problem.NamedElement
262 * @generated
263 */
264 public Adapter createNamedElementAdapter() {
265 return null;
266 }
267
268 /**
269 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.PredicateDefinition <em>Predicate Definition</em>}'.
270 * <!-- begin-user-doc -->
271 * This default implementation returns null so that we can easily ignore cases;
272 * it's useful to ignore a case when inheritance will catch all the cases anyway.
273 * <!-- end-user-doc -->
274 * @return the new adapter.
275 * @see org.eclipse.viatra.solver.language.model.problem.PredicateDefinition
276 * @generated
277 */
278 public Adapter createPredicateDefinitionAdapter() {
279 return null;
280 }
281
282 /**
283 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Parameter <em>Parameter</em>}'.
284 * <!-- begin-user-doc -->
285 * This default implementation returns null so that we can easily ignore cases;
286 * it's useful to ignore a case when inheritance will catch all the cases anyway.
287 * <!-- end-user-doc -->
288 * @return the new adapter.
289 * @see org.eclipse.viatra.solver.language.model.problem.Parameter
290 * @generated
291 */
292 public Adapter createParameterAdapter() {
293 return null;
294 }
295
296 /**
297 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Variable <em>Variable</em>}'.
298 * <!-- begin-user-doc -->
299 * This default implementation returns null so that we can easily ignore cases;
300 * it's useful to ignore a case when inheritance will catch all the cases anyway.
301 * <!-- end-user-doc -->
302 * @return the new adapter.
303 * @see org.eclipse.viatra.solver.language.model.problem.Variable
304 * @generated
305 */
306 public Adapter createVariableAdapter() {
307 return null;
308 }
309
310 /**
311 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Conjunction <em>Conjunction</em>}'.
312 * <!-- begin-user-doc -->
313 * This default implementation returns null so that we can easily ignore cases;
314 * it's useful to ignore a case when inheritance will catch all the cases anyway.
315 * <!-- end-user-doc -->
316 * @return the new adapter.
317 * @see org.eclipse.viatra.solver.language.model.problem.Conjunction
318 * @generated
319 */
320 public Adapter createConjunctionAdapter() {
321 return null;
322 }
323
324 /**
325 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Literal <em>Literal</em>}'.
326 * <!-- begin-user-doc -->
327 * This default implementation returns null so that we can easily ignore cases;
328 * it's useful to ignore a case when inheritance will catch all the cases anyway.
329 * <!-- end-user-doc -->
330 * @return the new adapter.
331 * @see org.eclipse.viatra.solver.language.model.problem.Literal
332 * @generated
333 */
334 public Adapter createLiteralAdapter() {
335 return null;
336 }
337
338 /**
339 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Atom <em>Atom</em>}'.
340 * <!-- begin-user-doc -->
341 * This default implementation returns null so that we can easily ignore cases;
342 * it's useful to ignore a case when inheritance will catch all the cases anyway.
343 * <!-- end-user-doc -->
344 * @return the new adapter.
345 * @see org.eclipse.viatra.solver.language.model.problem.Atom
346 * @generated
347 */
348 public Adapter createAtomAdapter() {
349 return null;
350 }
351
352 /**
353 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ImplicitVariable <em>Implicit Variable</em>}'.
354 * <!-- begin-user-doc -->
355 * This default implementation returns null so that we can easily ignore cases;
356 * it's useful to ignore a case when inheritance will catch all the cases anyway.
357 * <!-- end-user-doc -->
358 * @return the new adapter.
359 * @see org.eclipse.viatra.solver.language.model.problem.ImplicitVariable
360 * @generated
361 */
362 public Adapter createImplicitVariableAdapter() {
363 return null;
364 }
365
366 /**
367 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.NegativeLiteral <em>Negative Literal</em>}'.
368 * <!-- begin-user-doc -->
369 * This default implementation returns null so that we can easily ignore cases;
370 * it's useful to ignore a case when inheritance will catch all the cases anyway.
371 * <!-- end-user-doc -->
372 * @return the new adapter.
373 * @see org.eclipse.viatra.solver.language.model.problem.NegativeLiteral
374 * @generated
375 */
376 public Adapter createNegativeLiteralAdapter() {
377 return null;
378 }
379
380 /**
381 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier <em>Existential Quantifier</em>}'.
382 * <!-- begin-user-doc -->
383 * This default implementation returns null so that we can easily ignore cases;
384 * it's useful to ignore a case when inheritance will catch all the cases anyway.
385 * <!-- end-user-doc -->
386 * @return the new adapter.
387 * @see org.eclipse.viatra.solver.language.model.problem.ExistentialQuantifier
388 * @generated
389 */
390 public Adapter createExistentialQuantifierAdapter() {
391 return null;
392 }
393
394 /**
395 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Assertion <em>Assertion</em>}'.
396 * <!-- begin-user-doc -->
397 * This default implementation returns null so that we can easily ignore cases;
398 * it's useful to ignore a case when inheritance will catch all the cases anyway.
399 * <!-- end-user-doc -->
400 * @return the new adapter.
401 * @see org.eclipse.viatra.solver.language.model.problem.Assertion
402 * @generated
403 */
404 public Adapter createAssertionAdapter() {
405 return null;
406 }
407
408 /**
409 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Node <em>Node</em>}'.
410 * <!-- begin-user-doc -->
411 * This default implementation returns null so that we can easily ignore cases;
412 * it's useful to ignore a case when inheritance will catch all the cases anyway.
413 * <!-- end-user-doc -->
414 * @return the new adapter.
415 * @see org.eclipse.viatra.solver.language.model.problem.Node
416 * @generated
417 */
418 public Adapter createNodeAdapter() {
419 return null;
420 }
421
422 /**
423 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration <em>Scope Declaration</em>}'.
424 * <!-- begin-user-doc -->
425 * This default implementation returns null so that we can easily ignore cases;
426 * it's useful to ignore a case when inheritance will catch all the cases anyway.
427 * <!-- end-user-doc -->
428 * @return the new adapter.
429 * @see org.eclipse.viatra.solver.language.model.problem.ScopeDeclaration
430 * @generated
431 */
432 public Adapter createScopeDeclarationAdapter() {
433 return null;
434 }
435
436 /**
437 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Statement <em>Statement</em>}'.
438 * <!-- begin-user-doc -->
439 * This default implementation returns null so that we can easily ignore cases;
440 * it's useful to ignore a case when inheritance will catch all the cases anyway.
441 * <!-- end-user-doc -->
442 * @return the new adapter.
443 * @see org.eclipse.viatra.solver.language.model.problem.Statement
444 * @generated
445 */
446 public Adapter createStatementAdapter() {
447 return null;
448 }
449
450 /**
451 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.TypeScope <em>Type Scope</em>}'.
452 * <!-- begin-user-doc -->
453 * This default implementation returns null so that we can easily ignore cases;
454 * it's useful to ignore a case when inheritance will catch all the cases anyway.
455 * <!-- end-user-doc -->
456 * @return the new adapter.
457 * @see org.eclipse.viatra.solver.language.model.problem.TypeScope
458 * @generated
459 */
460 public Adapter createTypeScopeAdapter() {
461 return null;
462 }
463
464 /**
465 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.Multiplicity <em>Multiplicity</em>}'.
466 * <!-- begin-user-doc -->
467 * This default implementation returns null so that we can easily ignore cases;
468 * it's useful to ignore a case when inheritance will catch all the cases anyway.
469 * <!-- end-user-doc -->
470 * @return the new adapter.
471 * @see org.eclipse.viatra.solver.language.model.problem.Multiplicity
472 * @generated
473 */
474 public Adapter createMultiplicityAdapter() {
475 return null;
476 }
477
478 /**
479 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity <em>Range Multiplicity</em>}'.
480 * <!-- begin-user-doc -->
481 * This default implementation returns null so that we can easily ignore cases;
482 * it's useful to ignore a case when inheritance will catch all the cases anyway.
483 * <!-- end-user-doc -->
484 * @return the new adapter.
485 * @see org.eclipse.viatra.solver.language.model.problem.RangeMultiplicity
486 * @generated
487 */
488 public Adapter createRangeMultiplicityAdapter() {
489 return null;
490 }
491
492 /**
493 * Creates a new adapter for an object of class '{@link org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity <em>Exact Multiplicity</em>}'.
494 * <!-- begin-user-doc -->
495 * This default implementation returns null so that we can easily ignore cases;
496 * it's useful to ignore a case when inheritance will catch all the cases anyway.
497 * <!-- end-user-doc -->
498 * @return the new adapter.
499 * @see org.eclipse.viatra.solver.language.model.problem.ExactMultiplicity
500 * @generated
501 */
502 public Adapter createExactMultiplicityAdapter() {
503 return null;
504 }
505
506 /**
507 * Creates a new adapter for the default case.
508 * <!-- begin-user-doc -->
509 * This default implementation returns null.
510 * <!-- end-user-doc -->
511 * @return the new adapter.
512 * @generated
513 */
514 public Adapter createEObjectAdapter() {
515 return null;
516 }
517
518} //ProblemAdapterFactory
diff --git a/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java b/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java
new file mode 100644
index 00000000..a9e1455b
--- /dev/null
+++ b/org.eclipse.viatra.solver.language.parent/org.eclipse.viatra.solver.language.model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java
@@ -0,0 +1,620 @@
1/**
2 */
3package org.eclipse.viatra.solver.language.model.problem.util;
4
5import org.eclipse.emf.ecore.EObject;
6import org.eclipse.emf.ecore.EPackage;
7
8import org.eclipse.emf.ecore.util.Switch;
9
10import org.eclipse.viatra.solver.language.model.problem.*;
11
12/**
13 * <!-- begin-user-doc -->
14 * The <b>Switch</b> for the model's inheritance hierarchy.
15 * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
16 * to invoke the <code>caseXXX</code> method for each class of the model,
17 * starting with the actual class of the object
18 * and proceeding up the inheritance hierarchy
19 * until a non-null result is returned,
20 * which is the result of the switch.
21 * <!-- end-user-doc -->
22 * @see org.eclipse.viatra.solver.language.model.problem.ProblemPackage
23 * @generated
24 */
25public class ProblemSwitch<T> extends Switch<T> {
26 /**
27 * The cached model package
28 * <!-- begin-user-doc -->
29 * <!-- end-user-doc -->
30 * @generated
31 */
32 protected static ProblemPackage modelPackage;
33
34 /**
35 * Creates an instance of the switch.
36 * <!-- begin-user-doc -->
37 * <!-- end-user-doc -->
38 * @generated
39 */
40 public ProblemSwitch() {
41 if (modelPackage == null) {
42 modelPackage = ProblemPackage.eINSTANCE;
43 }
44 }
45
46 /**
47 * Checks whether this is a switch for the given package.
48 * <!-- begin-user-doc -->
49 * <!-- end-user-doc -->
50 * @param ePackage the package in question.
51 * @return whether this is a switch for the given package.
52 * @generated
53 */
54 @Override
55 protected boolean isSwitchFor(EPackage ePackage) {
56 return ePackage == modelPackage;
57 }
58
59 /**
60 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
61 * <!-- begin-user-doc -->
62 * <!-- end-user-doc -->
63 * @return the first non-null result returned by a <code>caseXXX</code> call.
64 * @generated
65 */
66 @Override
67 protected T doSwitch(int classifierID, EObject theEObject) {
68 switch (classifierID) {
69 case ProblemPackage.PROBLEM: {
70 Problem problem = (Problem) theEObject;
71 T result = caseProblem(problem);
72 if (result == null)
73 result = defaultCase(theEObject);
74 return result;
75 }
76 case ProblemPackage.RELATION: {
77 Relation relation = (Relation) theEObject;
78 T result = caseRelation(relation);
79 if (result == null)
80 result = caseNamedElement(relation);
81 if (result == null)
82 result = defaultCase(theEObject);
83 return result;
84 }
85 case ProblemPackage.CLASS_DECLARATION: {
86 ClassDeclaration classDeclaration = (ClassDeclaration) theEObject;
87 T result = caseClassDeclaration(classDeclaration);
88 if (result == null)
89 result = caseRelation(classDeclaration);
90 if (result == null)
91 result = caseStatement(classDeclaration);
92 if (result == null)
93 result = caseNamedElement(classDeclaration);
94 if (result == null)
95 result = defaultCase(theEObject);
96 return result;
97 }
98 case ProblemPackage.REFERENCE_DECLARATION: {
99 ReferenceDeclaration referenceDeclaration = (ReferenceDeclaration) theEObject;
100 T result = caseReferenceDeclaration(referenceDeclaration);
101 if (result == null)
102 result = caseRelation(referenceDeclaration);
103 if (result == null)
104 result = caseNamedElement(referenceDeclaration);
105 if (result == null)
106 result = defaultCase(theEObject);
107 return result;
108 }
109 case ProblemPackage.NAMED_ELEMENT: {
110 NamedElement namedElement = (NamedElement) theEObject;
111 T result = caseNamedElement(namedElement);
112 if (result == null)
113 result = defaultCase(theEObject);
114 return result;
115 }
116 case ProblemPackage.PREDICATE_DEFINITION: {
117 PredicateDefinition predicateDefinition = (PredicateDefinition) theEObject;
118 T result = casePredicateDefinition(predicateDefinition);
119 if (result == null)
120 result = caseRelation(predicateDefinition);
121 if (result == null)
122 result = caseStatement(predicateDefinition);
123 if (result == null)
124 result = caseNamedElement(predicateDefinition);
125 if (result == null)
126 result = defaultCase(theEObject);
127 return result;
128 }
129 case ProblemPackage.PARAMETER: {
130 Parameter parameter = (Parameter) theEObject;
131 T result = caseParameter(parameter);
132 if (result == null)
133 result = caseVariable(parameter);
134 if (result == null)
135 result = caseNamedElement(parameter);
136 if (result == null)
137 result = defaultCase(theEObject);
138 return result;
139 }
140 case ProblemPackage.VARIABLE: {
141 Variable variable = (Variable) theEObject;
142 T result = caseVariable(variable);
143 if (result == null)
144 result = caseNamedElement(variable);
145 if (result == null)
146 result = defaultCase(theEObject);
147 return result;
148 }
149 case ProblemPackage.CONJUNCTION: {
150 Conjunction conjunction = (Conjunction) theEObject;
151 T result = caseConjunction(conjunction);
152 if (result == null)
153 result = caseExistentialQuantifier(conjunction);
154 if (result == null)
155 result = defaultCase(theEObject);
156 return result;
157 }
158 case ProblemPackage.LITERAL: {
159 Literal literal = (Literal) theEObject;
160 T result = caseLiteral(literal);
161 if (result == null)
162 result = defaultCase(theEObject);
163 return result;
164 }
165 case ProblemPackage.ATOM: {
166 Atom atom = (Atom) theEObject;
167 T result = caseAtom(atom);
168 if (result == null)
169 result = caseLiteral(atom);
170 if (result == null)
171 result = defaultCase(theEObject);
172 return result;
173 }
174 case ProblemPackage.IMPLICIT_VARIABLE: {
175 ImplicitVariable implicitVariable = (ImplicitVariable) theEObject;
176 T result = caseImplicitVariable(implicitVariable);
177 if (result == null)
178 result = caseVariable(implicitVariable);
179 if (result == null)
180 result = caseNamedElement(implicitVariable);
181 if (result == null)
182 result = defaultCase(theEObject);
183 return result;
184 }
185 case ProblemPackage.NEGATIVE_LITERAL: {
186 NegativeLiteral negativeLiteral = (NegativeLiteral) theEObject;
187 T result = caseNegativeLiteral(negativeLiteral);
188 if (result == null)
189 result = caseExistentialQuantifier(negativeLiteral);
190 if (result == null)
191 result = caseLiteral(negativeLiteral);
192 if (result == null)
193 result = defaultCase(theEObject);
194 return result;
195 }
196 case ProblemPackage.EXISTENTIAL_QUANTIFIER: {
197 ExistentialQuantifier existentialQuantifier = (ExistentialQuantifier) theEObject;
198 T result = caseExistentialQuantifier(existentialQuantifier);
199 if (result == null)
200 result = defaultCase(theEObject);
201 return result;
202 }
203 case ProblemPackage.ASSERTION: {
204 Assertion assertion = (Assertion) theEObject;
205 T result = caseAssertion(assertion);
206 if (result == null)
207 result = caseStatement(assertion);
208 if (result == null)
209 result = defaultCase(theEObject);
210 return result;
211 }
212 case ProblemPackage.NODE: {
213 Node node = (Node) theEObject;
214 T result = caseNode(node);
215 if (result == null)
216 result = caseNamedElement(node);
217 if (result == null)
218 result = defaultCase(theEObject);
219 return result;
220 }
221 case ProblemPackage.SCOPE_DECLARATION: {
222 ScopeDeclaration scopeDeclaration = (ScopeDeclaration) theEObject;
223 T result = caseScopeDeclaration(scopeDeclaration);
224 if (result == null)
225 result = caseStatement(scopeDeclaration);
226 if (result == null)
227 result = defaultCase(theEObject);
228 return result;
229 }
230 case ProblemPackage.STATEMENT: {
231 Statement statement = (Statement) theEObject;
232 T result = caseStatement(statement);
233 if (result == null)
234 result = defaultCase(theEObject);
235 return result;
236 }
237 case ProblemPackage.TYPE_SCOPE: {
238 TypeScope typeScope = (TypeScope) theEObject;
239 T result = caseTypeScope(typeScope);
240 if (result == null)
241 result = defaultCase(theEObject);
242 return result;
243 }
244 case ProblemPackage.MULTIPLICITY: {
245 Multiplicity multiplicity = (Multiplicity) theEObject;
246 T result = caseMultiplicity(multiplicity);
247 if (result == null)
248 result = defaultCase(theEObject);
249 return result;
250 }
251 case ProblemPackage.RANGE_MULTIPLICITY: {
252 RangeMultiplicity rangeMultiplicity = (RangeMultiplicity) theEObject;
253 T result = caseRangeMultiplicity(rangeMultiplicity);
254 if (result == null)
255 result = caseMultiplicity(rangeMultiplicity);
256 if (result == null)
257 result = defaultCase(theEObject);
258 return result;
259 }
260 case ProblemPackage.EXACT_MULTIPLICITY: {
261 ExactMultiplicity exactMultiplicity = (ExactMultiplicity) theEObject;
262 T result = caseExactMultiplicity(exactMultiplicity);
263 if (result == null)
264 result = caseMultiplicity(exactMultiplicity);
265 if (result == null)
266 result = defaultCase(theEObject);
267 return result;
268 }
269 default:
270 return defaultCase(theEObject);
271 }
272 }
273
274 /**
275 * Returns the result of interpreting the object as an instance of '<em>Problem</em>'.
276 * <!-- begin-user-doc -->
277 * This implementation returns null;
278 * returning a non-null result will terminate the switch.
279 * <!-- end-user-doc -->
280 * @param object the target of the switch.
281 * @return the result of interpreting the object as an instance of '<em>Problem</em>'.
282 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
283 * @generated
284 */
285 public T caseProblem(Problem object) {
286 return null;
287 }
288
289 /**
290 * Returns the result of interpreting the object as an instance of '<em>Relation</em>'.
291 * <!-- begin-user-doc -->
292 * This implementation returns null;
293 * returning a non-null result will terminate the switch.
294 * <!-- end-user-doc -->
295 * @param object the target of the switch.
296 * @return the result of interpreting the object as an instance of '<em>Relation</em>'.
297 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
298 * @generated
299 */
300 public T caseRelation(Relation object) {
301 return null;
302 }
303
304 /**
305 * Returns the result of interpreting the object as an instance of '<em>Class Declaration</em>'.
306 * <!-- begin-user-doc -->
307 * This implementation returns null;
308 * returning a non-null result will terminate the switch.
309 * <!-- end-user-doc -->
310 * @param object the target of the switch.
311 * @return the result of interpreting the object as an instance of '<em>Class Declaration</em>'.
312 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
313 * @generated
314 */
315 public T caseClassDeclaration(ClassDeclaration object) {
316 return null;
317 }
318
319 /**
320 * Returns the result of interpreting the object as an instance of '<em>Reference Declaration</em>'.
321 * <!-- begin-user-doc -->
322 * This implementation returns null;
323 * returning a non-null result will terminate the switch.
324 * <!-- end-user-doc -->
325 * @param object the target of the switch.
326 * @return the result of interpreting the object as an instance of '<em>Reference Declaration</em>'.
327 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
328 * @generated
329 */
330 public T caseReferenceDeclaration(ReferenceDeclaration object) {
331 return null;
332 }
333
334 /**
335 * Returns the result of interpreting the object as an instance of '<em>Named Element</em>'.
336 * <!-- begin-user-doc -->
337 * This implementation returns null;
338 * returning a non-null result will terminate the switch.
339 * <!-- end-user-doc -->
340 * @param object the target of the switch.
341 * @return the result of interpreting the object as an instance of '<em>Named Element</em>'.
342 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
343 * @generated
344 */
345 public T caseNamedElement(NamedElement object) {
346 return null;
347 }
348
349 /**
350 * Returns the result of interpreting the object as an instance of '<em>Predicate Definition</em>'.
351 * <!-- begin-user-doc -->
352 * This implementation returns null;
353 * returning a non-null result will terminate the switch.
354 * <!-- end-user-doc -->
355 * @param object the target of the switch.
356 * @return the result of interpreting the object as an instance of '<em>Predicate Definition</em>'.
357 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
358 * @generated
359 */
360 public T casePredicateDefinition(PredicateDefinition object) {
361 return null;
362 }
363
364 /**
365 * Returns the result of interpreting the object as an instance of '<em>Parameter</em>'.
366 * <!-- begin-user-doc -->
367 * This implementation returns null;
368 * returning a non-null result will terminate the switch.
369 * <!-- end-user-doc -->
370 * @param object the target of the switch.
371 * @return the result of interpreting the object as an instance of '<em>Parameter</em>'.
372 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
373 * @generated
374 */
375 public T caseParameter(Parameter object) {
376 return null;
377 }
378
379 /**
380 * Returns the result of interpreting the object as an instance of '<em>Variable</em>'.
381 * <!-- begin-user-doc -->
382 * This implementation returns null;
383 * returning a non-null result will terminate the switch.
384 * <!-- end-user-doc -->
385 * @param object the target of the switch.
386 * @return the result of interpreting the object as an instance of '<em>Variable</em>'.
387 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
388 * @generated
389 */
390 public T caseVariable(Variable object) {
391 return null;
392 }
393
394 /**
395 * Returns the result of interpreting the object as an instance of '<em>Conjunction</em>'.
396 * <!-- begin-user-doc -->
397 * This implementation returns null;
398 * returning a non-null result will terminate the switch.
399 * <!-- end-user-doc -->
400 * @param object the target of the switch.
401 * @return the result of interpreting the object as an instance of '<em>Conjunction</em>'.
402 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
403 * @generated
404 */
405 public T caseConjunction(Conjunction object) {
406 return null;
407 }
408
409 /**
410 * Returns the result of interpreting the object as an instance of '<em>Literal</em>'.
411 * <!-- begin-user-doc -->
412 * This implementation returns null;
413 * returning a non-null result will terminate the switch.
414 * <!-- end-user-doc -->
415 * @param object the target of the switch.
416 * @return the result of interpreting the object as an instance of '<em>Literal</em>'.
417 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
418 * @generated
419 */
420 public T caseLiteral(Literal object) {
421 return null;
422 }
423
424 /**
425 * Returns the result of interpreting the object as an instance of '<em>Atom</em>'.
426 * <!-- begin-user-doc -->
427 * This implementation returns null;
428 * returning a non-null result will terminate the switch.
429 * <!-- end-user-doc -->
430 * @param object the target of the switch.
431 * @return the result of interpreting the object as an instance of '<em>Atom</em>'.
432 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
433 * @generated
434 */
435 public T caseAtom(Atom object) {
436 return null;
437 }
438
439 /**
440 * Returns the result of interpreting the object as an instance of '<em>Implicit Variable</em>'.
441 * <!-- begin-user-doc -->
442 * This implementation returns null;
443 * returning a non-null result will terminate the switch.
444 * <!-- end-user-doc -->
445 * @param object the target of the switch.
446 * @return the result of interpreting the object as an instance of '<em>Implicit Variable</em>'.
447 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
448 * @generated
449 */
450 public T caseImplicitVariable(ImplicitVariable object) {
451 return null;
452 }
453
454 /**
455 * Returns the result of interpreting the object as an instance of '<em>Negative Literal</em>'.
456 * <!-- begin-user-doc -->
457 * This implementation returns null;
458 * returning a non-null result will terminate the switch.
459 * <!-- end-user-doc -->
460 * @param object the target of the switch.
461 * @return the result of interpreting the object as an instance of '<em>Negative Literal</em>'.
462 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
463 * @generated
464 */
465 public T caseNegativeLiteral(NegativeLiteral object) {
466 return null;
467 }
468
469 /**
470 * Returns the result of interpreting the object as an instance of '<em>Existential Quantifier</em>'.
471 * <!-- begin-user-doc -->
472 * This implementation returns null;
473 * returning a non-null result will terminate the switch.
474 * <!-- end-user-doc -->
475 * @param object the target of the switch.
476 * @return the result of interpreting the object as an instance of '<em>Existential Quantifier</em>'.
477 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
478 * @generated
479 */
480 public T caseExistentialQuantifier(ExistentialQuantifier object) {
481 return null;
482 }
483
484 /**
485 * Returns the result of interpreting the object as an instance of '<em>Assertion</em>'.
486 * <!-- begin-user-doc -->
487 * This implementation returns null;
488 * returning a non-null result will terminate the switch.
489 * <!-- end-user-doc -->
490 * @param object the target of the switch.
491 * @return the result of interpreting the object as an instance of '<em>Assertion</em>'.
492 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
493 * @generated
494 */
495 public T caseAssertion(Assertion object) {
496 return null;
497 }
498
499 /**
500 * Returns the result of interpreting the object as an instance of '<em>Node</em>'.
501 * <!-- begin-user-doc -->
502 * This implementation returns null;
503 * returning a non-null result will terminate the switch.
504 * <!-- end-user-doc -->
505 * @param object the target of the switch.
506 * @return the result of interpreting the object as an instance of '<em>Node</em>'.
507 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
508 * @generated
509 */
510 public T caseNode(Node object) {
511 return null;
512 }
513
514 /**
515 * Returns the result of interpreting the object as an instance of '<em>Scope Declaration</em>'.
516 * <!-- begin-user-doc -->
517 * This implementation returns null;
518 * returning a non-null result will terminate the switch.
519 * <!-- end-user-doc -->
520 * @param object the target of the switch.
521 * @return the result of interpreting the object as an instance of '<em>Scope Declaration</em>'.
522 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
523 * @generated
524 */
525 public T caseScopeDeclaration(ScopeDeclaration object) {
526 return null;
527 }
528
529 /**
530 * Returns the result of interpreting the object as an instance of '<em>Statement</em>'.
531 * <!-- begin-user-doc -->
532 * This implementation returns null;
533 * returning a non-null result will terminate the switch.
534 * <!-- end-user-doc -->
535 * @param object the target of the switch.
536 * @return the result of interpreting the object as an instance of '<em>Statement</em>'.
537 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
538 * @generated
539 */
540 public T caseStatement(Statement object) {
541 return null;
542 }
543
544 /**
545 * Returns the result of interpreting the object as an instance of '<em>Type Scope</em>'.
546 * <!-- begin-user-doc -->
547 * This implementation returns null;
548 * returning a non-null result will terminate the switch.
549 * <!-- end-user-doc -->
550 * @param object the target of the switch.
551 * @return the result of interpreting the object as an instance of '<em>Type Scope</em>'.
552 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
553 * @generated
554 */
555 public T caseTypeScope(TypeScope object) {
556 return null;
557 }
558
559 /**
560 * Returns the result of interpreting the object as an instance of '<em>Multiplicity</em>'.
561 * <!-- begin-user-doc -->
562 * This implementation returns null;
563 * returning a non-null result will terminate the switch.
564 * <!-- end-user-doc -->
565 * @param object the target of the switch.
566 * @return the result of interpreting the object as an instance of '<em>Multiplicity</em>'.
567 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
568 * @generated
569 */
570 public T caseMultiplicity(Multiplicity object) {
571 return null;
572 }
573
574 /**
575 * Returns the result of interpreting the object as an instance of '<em>Range Multiplicity</em>'.
576 * <!-- begin-user-doc -->
577 * This implementation returns null;
578 * returning a non-null result will terminate the switch.
579 * <!-- end-user-doc -->
580 * @param object the target of the switch.
581 * @return the result of interpreting the object as an instance of '<em>Range Multiplicity</em>'.
582 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
583 * @generated
584 */
585 public T caseRangeMultiplicity(RangeMultiplicity object) {
586 return null;
587 }
588
589 /**
590 * Returns the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'.
591 * <!-- begin-user-doc -->
592 * This implementation returns null;
593 * returning a non-null result will terminate the switch.
594 * <!-- end-user-doc -->
595 * @param object the target of the switch.
596 * @return the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'.
597 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
598 * @generated
599 */
600 public T caseExactMultiplicity(ExactMultiplicity object) {
601 return null;
602 }
603
604 /**
605 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
606 * <!-- begin-user-doc -->
607 * This implementation returns null;
608 * returning a non-null result will terminate the switch, but this is the last case anyway.
609 * <!-- end-user-doc -->
610 * @param object the target of the switch.
611 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
612 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
613 * @generated
614 */
615 @Override
616 public T defaultCase(EObject object) {
617 return null;
618 }
619
620} //ProblemSwitch
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2024-09-12 18:21:25 +0000