diff options
Diffstat (limited to 'language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java')
-rw-r--r-- | language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java | 964 |
1 files changed, 0 insertions, 964 deletions
diff --git a/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java b/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java deleted file mode 100644 index 837d3a03..00000000 --- a/language-model/src/main/emf-gen/org/eclipse/viatra/solver/language/model/problem/util/ProblemSwitch.java +++ /dev/null | |||
@@ -1,964 +0,0 @@ | |||
1 | /** | ||
2 | */ | ||
3 | package org.eclipse.viatra.solver.language.model.problem.util; | ||
4 | |||
5 | import org.eclipse.emf.ecore.EObject; | ||
6 | import org.eclipse.emf.ecore.EPackage; | ||
7 | |||
8 | import org.eclipse.emf.ecore.util.Switch; | ||
9 | |||
10 | import 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 | */ | ||
25 | public 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 = caseNamedElement(problem); | ||
74 | if (result == null) | ||
75 | result = defaultCase(theEObject); | ||
76 | return result; | ||
77 | } | ||
78 | case ProblemPackage.RELATION: { | ||
79 | Relation relation = (Relation) theEObject; | ||
80 | T result = caseRelation(relation); | ||
81 | if (result == null) | ||
82 | result = caseNamedElement(relation); | ||
83 | if (result == null) | ||
84 | result = defaultCase(theEObject); | ||
85 | return result; | ||
86 | } | ||
87 | case ProblemPackage.CLASS_DECLARATION: { | ||
88 | ClassDeclaration classDeclaration = (ClassDeclaration) theEObject; | ||
89 | T result = caseClassDeclaration(classDeclaration); | ||
90 | if (result == null) | ||
91 | result = caseRelation(classDeclaration); | ||
92 | if (result == null) | ||
93 | result = caseStatement(classDeclaration); | ||
94 | if (result == null) | ||
95 | result = caseNamedElement(classDeclaration); | ||
96 | if (result == null) | ||
97 | result = defaultCase(theEObject); | ||
98 | return result; | ||
99 | } | ||
100 | case ProblemPackage.REFERENCE_DECLARATION: { | ||
101 | ReferenceDeclaration referenceDeclaration = (ReferenceDeclaration) theEObject; | ||
102 | T result = caseReferenceDeclaration(referenceDeclaration); | ||
103 | if (result == null) | ||
104 | result = caseRelation(referenceDeclaration); | ||
105 | if (result == null) | ||
106 | result = caseNamedElement(referenceDeclaration); | ||
107 | if (result == null) | ||
108 | result = defaultCase(theEObject); | ||
109 | return result; | ||
110 | } | ||
111 | case ProblemPackage.NAMED_ELEMENT: { | ||
112 | NamedElement namedElement = (NamedElement) theEObject; | ||
113 | T result = caseNamedElement(namedElement); | ||
114 | if (result == null) | ||
115 | result = defaultCase(theEObject); | ||
116 | return result; | ||
117 | } | ||
118 | case ProblemPackage.PREDICATE_DEFINITION: { | ||
119 | PredicateDefinition predicateDefinition = (PredicateDefinition) theEObject; | ||
120 | T result = casePredicateDefinition(predicateDefinition); | ||
121 | if (result == null) | ||
122 | result = caseRelation(predicateDefinition); | ||
123 | if (result == null) | ||
124 | result = caseStatement(predicateDefinition); | ||
125 | if (result == null) | ||
126 | result = caseNamedElement(predicateDefinition); | ||
127 | if (result == null) | ||
128 | result = defaultCase(theEObject); | ||
129 | return result; | ||
130 | } | ||
131 | case ProblemPackage.PARAMETER: { | ||
132 | Parameter parameter = (Parameter) theEObject; | ||
133 | T result = caseParameter(parameter); | ||
134 | if (result == null) | ||
135 | result = caseVariable(parameter); | ||
136 | if (result == null) | ||
137 | result = caseVariableOrNode(parameter); | ||
138 | if (result == null) | ||
139 | result = caseNamedElement(parameter); | ||
140 | if (result == null) | ||
141 | result = defaultCase(theEObject); | ||
142 | return result; | ||
143 | } | ||
144 | case ProblemPackage.VARIABLE: { | ||
145 | Variable variable = (Variable) theEObject; | ||
146 | T result = caseVariable(variable); | ||
147 | if (result == null) | ||
148 | result = caseVariableOrNode(variable); | ||
149 | if (result == null) | ||
150 | result = caseNamedElement(variable); | ||
151 | if (result == null) | ||
152 | result = defaultCase(theEObject); | ||
153 | return result; | ||
154 | } | ||
155 | case ProblemPackage.CONJUNCTION: { | ||
156 | Conjunction conjunction = (Conjunction) theEObject; | ||
157 | T result = caseConjunction(conjunction); | ||
158 | if (result == null) | ||
159 | result = caseExistentialQuantifier(conjunction); | ||
160 | if (result == null) | ||
161 | result = defaultCase(theEObject); | ||
162 | return result; | ||
163 | } | ||
164 | case ProblemPackage.LITERAL: { | ||
165 | Literal literal = (Literal) theEObject; | ||
166 | T result = caseLiteral(literal); | ||
167 | if (result == null) | ||
168 | result = defaultCase(theEObject); | ||
169 | return result; | ||
170 | } | ||
171 | case ProblemPackage.ATOM: { | ||
172 | Atom atom = (Atom) theEObject; | ||
173 | T result = caseAtom(atom); | ||
174 | if (result == null) | ||
175 | result = caseLiteral(atom); | ||
176 | if (result == null) | ||
177 | result = defaultCase(theEObject); | ||
178 | return result; | ||
179 | } | ||
180 | case ProblemPackage.IMPLICIT_VARIABLE: { | ||
181 | ImplicitVariable implicitVariable = (ImplicitVariable) theEObject; | ||
182 | T result = caseImplicitVariable(implicitVariable); | ||
183 | if (result == null) | ||
184 | result = caseVariable(implicitVariable); | ||
185 | if (result == null) | ||
186 | result = caseVariableOrNode(implicitVariable); | ||
187 | if (result == null) | ||
188 | result = caseNamedElement(implicitVariable); | ||
189 | if (result == null) | ||
190 | result = defaultCase(theEObject); | ||
191 | return result; | ||
192 | } | ||
193 | case ProblemPackage.NEGATIVE_LITERAL: { | ||
194 | NegativeLiteral negativeLiteral = (NegativeLiteral) theEObject; | ||
195 | T result = caseNegativeLiteral(negativeLiteral); | ||
196 | if (result == null) | ||
197 | result = caseExistentialQuantifier(negativeLiteral); | ||
198 | if (result == null) | ||
199 | result = caseLiteral(negativeLiteral); | ||
200 | if (result == null) | ||
201 | result = defaultCase(theEObject); | ||
202 | return result; | ||
203 | } | ||
204 | case ProblemPackage.EXISTENTIAL_QUANTIFIER: { | ||
205 | ExistentialQuantifier existentialQuantifier = (ExistentialQuantifier) theEObject; | ||
206 | T result = caseExistentialQuantifier(existentialQuantifier); | ||
207 | if (result == null) | ||
208 | result = defaultCase(theEObject); | ||
209 | return result; | ||
210 | } | ||
211 | case ProblemPackage.ASSERTION: { | ||
212 | Assertion assertion = (Assertion) theEObject; | ||
213 | T result = caseAssertion(assertion); | ||
214 | if (result == null) | ||
215 | result = caseStatement(assertion); | ||
216 | if (result == null) | ||
217 | result = defaultCase(theEObject); | ||
218 | return result; | ||
219 | } | ||
220 | case ProblemPackage.NODE: { | ||
221 | Node node = (Node) theEObject; | ||
222 | T result = caseNode(node); | ||
223 | if (result == null) | ||
224 | result = caseVariableOrNode(node); | ||
225 | if (result == null) | ||
226 | result = caseNamedElement(node); | ||
227 | if (result == null) | ||
228 | result = defaultCase(theEObject); | ||
229 | return result; | ||
230 | } | ||
231 | case ProblemPackage.SCOPE_DECLARATION: { | ||
232 | ScopeDeclaration scopeDeclaration = (ScopeDeclaration) theEObject; | ||
233 | T result = caseScopeDeclaration(scopeDeclaration); | ||
234 | if (result == null) | ||
235 | result = caseStatement(scopeDeclaration); | ||
236 | if (result == null) | ||
237 | result = defaultCase(theEObject); | ||
238 | return result; | ||
239 | } | ||
240 | case ProblemPackage.STATEMENT: { | ||
241 | Statement statement = (Statement) theEObject; | ||
242 | T result = caseStatement(statement); | ||
243 | if (result == null) | ||
244 | result = defaultCase(theEObject); | ||
245 | return result; | ||
246 | } | ||
247 | case ProblemPackage.TYPE_SCOPE: { | ||
248 | TypeScope typeScope = (TypeScope) theEObject; | ||
249 | T result = caseTypeScope(typeScope); | ||
250 | if (result == null) | ||
251 | result = defaultCase(theEObject); | ||
252 | return result; | ||
253 | } | ||
254 | case ProblemPackage.MULTIPLICITY: { | ||
255 | Multiplicity multiplicity = (Multiplicity) theEObject; | ||
256 | T result = caseMultiplicity(multiplicity); | ||
257 | if (result == null) | ||
258 | result = defaultCase(theEObject); | ||
259 | return result; | ||
260 | } | ||
261 | case ProblemPackage.RANGE_MULTIPLICITY: { | ||
262 | RangeMultiplicity rangeMultiplicity = (RangeMultiplicity) theEObject; | ||
263 | T result = caseRangeMultiplicity(rangeMultiplicity); | ||
264 | if (result == null) | ||
265 | result = caseMultiplicity(rangeMultiplicity); | ||
266 | if (result == null) | ||
267 | result = defaultCase(theEObject); | ||
268 | return result; | ||
269 | } | ||
270 | case ProblemPackage.EXACT_MULTIPLICITY: { | ||
271 | ExactMultiplicity exactMultiplicity = (ExactMultiplicity) theEObject; | ||
272 | T result = caseExactMultiplicity(exactMultiplicity); | ||
273 | if (result == null) | ||
274 | result = caseMultiplicity(exactMultiplicity); | ||
275 | if (result == null) | ||
276 | result = defaultCase(theEObject); | ||
277 | return result; | ||
278 | } | ||
279 | case ProblemPackage.UNBOUNDED_MULTIPLICITY: { | ||
280 | UnboundedMultiplicity unboundedMultiplicity = (UnboundedMultiplicity) theEObject; | ||
281 | T result = caseUnboundedMultiplicity(unboundedMultiplicity); | ||
282 | if (result == null) | ||
283 | result = caseMultiplicity(unboundedMultiplicity); | ||
284 | if (result == null) | ||
285 | result = defaultCase(theEObject); | ||
286 | return result; | ||
287 | } | ||
288 | case ProblemPackage.VARIABLE_OR_NODE_ARGUMENT: { | ||
289 | VariableOrNodeArgument variableOrNodeArgument = (VariableOrNodeArgument) theEObject; | ||
290 | T result = caseVariableOrNodeArgument(variableOrNodeArgument); | ||
291 | if (result == null) | ||
292 | result = caseArgument(variableOrNodeArgument); | ||
293 | if (result == null) | ||
294 | result = defaultCase(theEObject); | ||
295 | return result; | ||
296 | } | ||
297 | case ProblemPackage.ENUM_DECLARATION: { | ||
298 | EnumDeclaration enumDeclaration = (EnumDeclaration) theEObject; | ||
299 | T result = caseEnumDeclaration(enumDeclaration); | ||
300 | if (result == null) | ||
301 | result = caseRelation(enumDeclaration); | ||
302 | if (result == null) | ||
303 | result = caseStatement(enumDeclaration); | ||
304 | if (result == null) | ||
305 | result = caseNamedElement(enumDeclaration); | ||
306 | if (result == null) | ||
307 | result = defaultCase(theEObject); | ||
308 | return result; | ||
309 | } | ||
310 | case ProblemPackage.VARIABLE_OR_NODE: { | ||
311 | VariableOrNode variableOrNode = (VariableOrNode) theEObject; | ||
312 | T result = caseVariableOrNode(variableOrNode); | ||
313 | if (result == null) | ||
314 | result = caseNamedElement(variableOrNode); | ||
315 | if (result == null) | ||
316 | result = defaultCase(theEObject); | ||
317 | return result; | ||
318 | } | ||
319 | case ProblemPackage.CONSTANT: { | ||
320 | Constant constant = (Constant) theEObject; | ||
321 | T result = caseConstant(constant); | ||
322 | if (result == null) | ||
323 | result = defaultCase(theEObject); | ||
324 | return result; | ||
325 | } | ||
326 | case ProblemPackage.INT_CONSTANT: { | ||
327 | IntConstant intConstant = (IntConstant) theEObject; | ||
328 | T result = caseIntConstant(intConstant); | ||
329 | if (result == null) | ||
330 | result = caseConstant(intConstant); | ||
331 | if (result == null) | ||
332 | result = defaultCase(theEObject); | ||
333 | return result; | ||
334 | } | ||
335 | case ProblemPackage.REAL_CONSTANT: { | ||
336 | RealConstant realConstant = (RealConstant) theEObject; | ||
337 | T result = caseRealConstant(realConstant); | ||
338 | if (result == null) | ||
339 | result = caseConstant(realConstant); | ||
340 | if (result == null) | ||
341 | result = defaultCase(theEObject); | ||
342 | return result; | ||
343 | } | ||
344 | case ProblemPackage.STRING_CONSTANT: { | ||
345 | StringConstant stringConstant = (StringConstant) theEObject; | ||
346 | T result = caseStringConstant(stringConstant); | ||
347 | if (result == null) | ||
348 | result = caseConstant(stringConstant); | ||
349 | if (result == null) | ||
350 | result = defaultCase(theEObject); | ||
351 | return result; | ||
352 | } | ||
353 | case ProblemPackage.CONSTANT_ARGUMENT: { | ||
354 | ConstantArgument constantArgument = (ConstantArgument) theEObject; | ||
355 | T result = caseConstantArgument(constantArgument); | ||
356 | if (result == null) | ||
357 | result = caseArgument(constantArgument); | ||
358 | if (result == null) | ||
359 | result = defaultCase(theEObject); | ||
360 | return result; | ||
361 | } | ||
362 | case ProblemPackage.ARGUMENT: { | ||
363 | Argument argument = (Argument) theEObject; | ||
364 | T result = caseArgument(argument); | ||
365 | if (result == null) | ||
366 | result = defaultCase(theEObject); | ||
367 | return result; | ||
368 | } | ||
369 | case ProblemPackage.NODE_ASSERTION_ARGUMENT: { | ||
370 | NodeAssertionArgument nodeAssertionArgument = (NodeAssertionArgument) theEObject; | ||
371 | T result = caseNodeAssertionArgument(nodeAssertionArgument); | ||
372 | if (result == null) | ||
373 | result = caseAssertionArgument(nodeAssertionArgument); | ||
374 | if (result == null) | ||
375 | result = defaultCase(theEObject); | ||
376 | return result; | ||
377 | } | ||
378 | case ProblemPackage.ASSERTION_ARGUMENT: { | ||
379 | AssertionArgument assertionArgument = (AssertionArgument) theEObject; | ||
380 | T result = caseAssertionArgument(assertionArgument); | ||
381 | if (result == null) | ||
382 | result = defaultCase(theEObject); | ||
383 | return result; | ||
384 | } | ||
385 | case ProblemPackage.CONSTANT_ASSERTION_ARGUMENT: { | ||
386 | ConstantAssertionArgument constantAssertionArgument = (ConstantAssertionArgument) theEObject; | ||
387 | T result = caseConstantAssertionArgument(constantAssertionArgument); | ||
388 | if (result == null) | ||
389 | result = caseAssertionArgument(constantAssertionArgument); | ||
390 | if (result == null) | ||
391 | result = defaultCase(theEObject); | ||
392 | return result; | ||
393 | } | ||
394 | case ProblemPackage.NODE_VALUE_ASSERTION: { | ||
395 | NodeValueAssertion nodeValueAssertion = (NodeValueAssertion) theEObject; | ||
396 | T result = caseNodeValueAssertion(nodeValueAssertion); | ||
397 | if (result == null) | ||
398 | result = caseStatement(nodeValueAssertion); | ||
399 | if (result == null) | ||
400 | result = defaultCase(theEObject); | ||
401 | return result; | ||
402 | } | ||
403 | default: | ||
404 | return defaultCase(theEObject); | ||
405 | } | ||
406 | } | ||
407 | |||
408 | /** | ||
409 | * Returns the result of interpreting the object as an instance of '<em>Problem</em>'. | ||
410 | * <!-- begin-user-doc --> | ||
411 | * This implementation returns null; | ||
412 | * returning a non-null result will terminate the switch. | ||
413 | * <!-- end-user-doc --> | ||
414 | * @param object the target of the switch. | ||
415 | * @return the result of interpreting the object as an instance of '<em>Problem</em>'. | ||
416 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
417 | * @generated | ||
418 | */ | ||
419 | public T caseProblem(Problem object) { | ||
420 | return null; | ||
421 | } | ||
422 | |||
423 | /** | ||
424 | * Returns the result of interpreting the object as an instance of '<em>Relation</em>'. | ||
425 | * <!-- begin-user-doc --> | ||
426 | * This implementation returns null; | ||
427 | * returning a non-null result will terminate the switch. | ||
428 | * <!-- end-user-doc --> | ||
429 | * @param object the target of the switch. | ||
430 | * @return the result of interpreting the object as an instance of '<em>Relation</em>'. | ||
431 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
432 | * @generated | ||
433 | */ | ||
434 | public T caseRelation(Relation object) { | ||
435 | return null; | ||
436 | } | ||
437 | |||
438 | /** | ||
439 | * Returns the result of interpreting the object as an instance of '<em>Class Declaration</em>'. | ||
440 | * <!-- begin-user-doc --> | ||
441 | * This implementation returns null; | ||
442 | * returning a non-null result will terminate the switch. | ||
443 | * <!-- end-user-doc --> | ||
444 | * @param object the target of the switch. | ||
445 | * @return the result of interpreting the object as an instance of '<em>Class Declaration</em>'. | ||
446 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
447 | * @generated | ||
448 | */ | ||
449 | public T caseClassDeclaration(ClassDeclaration object) { | ||
450 | return null; | ||
451 | } | ||
452 | |||
453 | /** | ||
454 | * Returns the result of interpreting the object as an instance of '<em>Reference Declaration</em>'. | ||
455 | * <!-- begin-user-doc --> | ||
456 | * This implementation returns null; | ||
457 | * returning a non-null result will terminate the switch. | ||
458 | * <!-- end-user-doc --> | ||
459 | * @param object the target of the switch. | ||
460 | * @return the result of interpreting the object as an instance of '<em>Reference Declaration</em>'. | ||
461 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
462 | * @generated | ||
463 | */ | ||
464 | public T caseReferenceDeclaration(ReferenceDeclaration object) { | ||
465 | return null; | ||
466 | } | ||
467 | |||
468 | /** | ||
469 | * Returns the result of interpreting the object as an instance of '<em>Named Element</em>'. | ||
470 | * <!-- begin-user-doc --> | ||
471 | * This implementation returns null; | ||
472 | * returning a non-null result will terminate the switch. | ||
473 | * <!-- end-user-doc --> | ||
474 | * @param object the target of the switch. | ||
475 | * @return the result of interpreting the object as an instance of '<em>Named Element</em>'. | ||
476 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
477 | * @generated | ||
478 | */ | ||
479 | public T caseNamedElement(NamedElement object) { | ||
480 | return null; | ||
481 | } | ||
482 | |||
483 | /** | ||
484 | * Returns the result of interpreting the object as an instance of '<em>Predicate Definition</em>'. | ||
485 | * <!-- begin-user-doc --> | ||
486 | * This implementation returns null; | ||
487 | * returning a non-null result will terminate the switch. | ||
488 | * <!-- end-user-doc --> | ||
489 | * @param object the target of the switch. | ||
490 | * @return the result of interpreting the object as an instance of '<em>Predicate Definition</em>'. | ||
491 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
492 | * @generated | ||
493 | */ | ||
494 | public T casePredicateDefinition(PredicateDefinition object) { | ||
495 | return null; | ||
496 | } | ||
497 | |||
498 | /** | ||
499 | * Returns the result of interpreting the object as an instance of '<em>Parameter</em>'. | ||
500 | * <!-- begin-user-doc --> | ||
501 | * This implementation returns null; | ||
502 | * returning a non-null result will terminate the switch. | ||
503 | * <!-- end-user-doc --> | ||
504 | * @param object the target of the switch. | ||
505 | * @return the result of interpreting the object as an instance of '<em>Parameter</em>'. | ||
506 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
507 | * @generated | ||
508 | */ | ||
509 | public T caseParameter(Parameter object) { | ||
510 | return null; | ||
511 | } | ||
512 | |||
513 | /** | ||
514 | * Returns the result of interpreting the object as an instance of '<em>Variable</em>'. | ||
515 | * <!-- begin-user-doc --> | ||
516 | * This implementation returns null; | ||
517 | * returning a non-null result will terminate the switch. | ||
518 | * <!-- end-user-doc --> | ||
519 | * @param object the target of the switch. | ||
520 | * @return the result of interpreting the object as an instance of '<em>Variable</em>'. | ||
521 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
522 | * @generated | ||
523 | */ | ||
524 | public T caseVariable(Variable object) { | ||
525 | return null; | ||
526 | } | ||
527 | |||
528 | /** | ||
529 | * Returns the result of interpreting the object as an instance of '<em>Conjunction</em>'. | ||
530 | * <!-- begin-user-doc --> | ||
531 | * This implementation returns null; | ||
532 | * returning a non-null result will terminate the switch. | ||
533 | * <!-- end-user-doc --> | ||
534 | * @param object the target of the switch. | ||
535 | * @return the result of interpreting the object as an instance of '<em>Conjunction</em>'. | ||
536 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
537 | * @generated | ||
538 | */ | ||
539 | public T caseConjunction(Conjunction object) { | ||
540 | return null; | ||
541 | } | ||
542 | |||
543 | /** | ||
544 | * Returns the result of interpreting the object as an instance of '<em>Literal</em>'. | ||
545 | * <!-- begin-user-doc --> | ||
546 | * This implementation returns null; | ||
547 | * returning a non-null result will terminate the switch. | ||
548 | * <!-- end-user-doc --> | ||
549 | * @param object the target of the switch. | ||
550 | * @return the result of interpreting the object as an instance of '<em>Literal</em>'. | ||
551 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
552 | * @generated | ||
553 | */ | ||
554 | public T caseLiteral(Literal object) { | ||
555 | return null; | ||
556 | } | ||
557 | |||
558 | /** | ||
559 | * Returns the result of interpreting the object as an instance of '<em>Atom</em>'. | ||
560 | * <!-- begin-user-doc --> | ||
561 | * This implementation returns null; | ||
562 | * returning a non-null result will terminate the switch. | ||
563 | * <!-- end-user-doc --> | ||
564 | * @param object the target of the switch. | ||
565 | * @return the result of interpreting the object as an instance of '<em>Atom</em>'. | ||
566 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
567 | * @generated | ||
568 | */ | ||
569 | public T caseAtom(Atom object) { | ||
570 | return null; | ||
571 | } | ||
572 | |||
573 | /** | ||
574 | * Returns the result of interpreting the object as an instance of '<em>Implicit Variable</em>'. | ||
575 | * <!-- begin-user-doc --> | ||
576 | * This implementation returns null; | ||
577 | * returning a non-null result will terminate the switch. | ||
578 | * <!-- end-user-doc --> | ||
579 | * @param object the target of the switch. | ||
580 | * @return the result of interpreting the object as an instance of '<em>Implicit Variable</em>'. | ||
581 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
582 | * @generated | ||
583 | */ | ||
584 | public T caseImplicitVariable(ImplicitVariable object) { | ||
585 | return null; | ||
586 | } | ||
587 | |||
588 | /** | ||
589 | * Returns the result of interpreting the object as an instance of '<em>Negative Literal</em>'. | ||
590 | * <!-- begin-user-doc --> | ||
591 | * This implementation returns null; | ||
592 | * returning a non-null result will terminate the switch. | ||
593 | * <!-- end-user-doc --> | ||
594 | * @param object the target of the switch. | ||
595 | * @return the result of interpreting the object as an instance of '<em>Negative Literal</em>'. | ||
596 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
597 | * @generated | ||
598 | */ | ||
599 | public T caseNegativeLiteral(NegativeLiteral object) { | ||
600 | return null; | ||
601 | } | ||
602 | |||
603 | /** | ||
604 | * Returns the result of interpreting the object as an instance of '<em>Existential Quantifier</em>'. | ||
605 | * <!-- begin-user-doc --> | ||
606 | * This implementation returns null; | ||
607 | * returning a non-null result will terminate the switch. | ||
608 | * <!-- end-user-doc --> | ||
609 | * @param object the target of the switch. | ||
610 | * @return the result of interpreting the object as an instance of '<em>Existential Quantifier</em>'. | ||
611 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
612 | * @generated | ||
613 | */ | ||
614 | public T caseExistentialQuantifier(ExistentialQuantifier object) { | ||
615 | return null; | ||
616 | } | ||
617 | |||
618 | /** | ||
619 | * Returns the result of interpreting the object as an instance of '<em>Assertion</em>'. | ||
620 | * <!-- begin-user-doc --> | ||
621 | * This implementation returns null; | ||
622 | * returning a non-null result will terminate the switch. | ||
623 | * <!-- end-user-doc --> | ||
624 | * @param object the target of the switch. | ||
625 | * @return the result of interpreting the object as an instance of '<em>Assertion</em>'. | ||
626 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
627 | * @generated | ||
628 | */ | ||
629 | public T caseAssertion(Assertion object) { | ||
630 | return null; | ||
631 | } | ||
632 | |||
633 | /** | ||
634 | * Returns the result of interpreting the object as an instance of '<em>Node</em>'. | ||
635 | * <!-- begin-user-doc --> | ||
636 | * This implementation returns null; | ||
637 | * returning a non-null result will terminate the switch. | ||
638 | * <!-- end-user-doc --> | ||
639 | * @param object the target of the switch. | ||
640 | * @return the result of interpreting the object as an instance of '<em>Node</em>'. | ||
641 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
642 | * @generated | ||
643 | */ | ||
644 | public T caseNode(Node object) { | ||
645 | return null; | ||
646 | } | ||
647 | |||
648 | /** | ||
649 | * Returns the result of interpreting the object as an instance of '<em>Scope Declaration</em>'. | ||
650 | * <!-- begin-user-doc --> | ||
651 | * This implementation returns null; | ||
652 | * returning a non-null result will terminate the switch. | ||
653 | * <!-- end-user-doc --> | ||
654 | * @param object the target of the switch. | ||
655 | * @return the result of interpreting the object as an instance of '<em>Scope Declaration</em>'. | ||
656 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
657 | * @generated | ||
658 | */ | ||
659 | public T caseScopeDeclaration(ScopeDeclaration object) { | ||
660 | return null; | ||
661 | } | ||
662 | |||
663 | /** | ||
664 | * Returns the result of interpreting the object as an instance of '<em>Statement</em>'. | ||
665 | * <!-- begin-user-doc --> | ||
666 | * This implementation returns null; | ||
667 | * returning a non-null result will terminate the switch. | ||
668 | * <!-- end-user-doc --> | ||
669 | * @param object the target of the switch. | ||
670 | * @return the result of interpreting the object as an instance of '<em>Statement</em>'. | ||
671 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
672 | * @generated | ||
673 | */ | ||
674 | public T caseStatement(Statement object) { | ||
675 | return null; | ||
676 | } | ||
677 | |||
678 | /** | ||
679 | * Returns the result of interpreting the object as an instance of '<em>Type Scope</em>'. | ||
680 | * <!-- begin-user-doc --> | ||
681 | * This implementation returns null; | ||
682 | * returning a non-null result will terminate the switch. | ||
683 | * <!-- end-user-doc --> | ||
684 | * @param object the target of the switch. | ||
685 | * @return the result of interpreting the object as an instance of '<em>Type Scope</em>'. | ||
686 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
687 | * @generated | ||
688 | */ | ||
689 | public T caseTypeScope(TypeScope object) { | ||
690 | return null; | ||
691 | } | ||
692 | |||
693 | /** | ||
694 | * Returns the result of interpreting the object as an instance of '<em>Multiplicity</em>'. | ||
695 | * <!-- begin-user-doc --> | ||
696 | * This implementation returns null; | ||
697 | * returning a non-null result will terminate the switch. | ||
698 | * <!-- end-user-doc --> | ||
699 | * @param object the target of the switch. | ||
700 | * @return the result of interpreting the object as an instance of '<em>Multiplicity</em>'. | ||
701 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
702 | * @generated | ||
703 | */ | ||
704 | public T caseMultiplicity(Multiplicity object) { | ||
705 | return null; | ||
706 | } | ||
707 | |||
708 | /** | ||
709 | * Returns the result of interpreting the object as an instance of '<em>Range Multiplicity</em>'. | ||
710 | * <!-- begin-user-doc --> | ||
711 | * This implementation returns null; | ||
712 | * returning a non-null result will terminate the switch. | ||
713 | * <!-- end-user-doc --> | ||
714 | * @param object the target of the switch. | ||
715 | * @return the result of interpreting the object as an instance of '<em>Range Multiplicity</em>'. | ||
716 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
717 | * @generated | ||
718 | */ | ||
719 | public T caseRangeMultiplicity(RangeMultiplicity object) { | ||
720 | return null; | ||
721 | } | ||
722 | |||
723 | /** | ||
724 | * Returns the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'. | ||
725 | * <!-- begin-user-doc --> | ||
726 | * This implementation returns null; | ||
727 | * returning a non-null result will terminate the switch. | ||
728 | * <!-- end-user-doc --> | ||
729 | * @param object the target of the switch. | ||
730 | * @return the result of interpreting the object as an instance of '<em>Exact Multiplicity</em>'. | ||
731 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
732 | * @generated | ||
733 | */ | ||
734 | public T caseExactMultiplicity(ExactMultiplicity object) { | ||
735 | return null; | ||
736 | } | ||
737 | |||
738 | /** | ||
739 | * Returns the result of interpreting the object as an instance of '<em>Unbounded Multiplicity</em>'. | ||
740 | * <!-- begin-user-doc --> | ||
741 | * This implementation returns null; | ||
742 | * returning a non-null result will terminate the switch. | ||
743 | * <!-- end-user-doc --> | ||
744 | * @param object the target of the switch. | ||
745 | * @return the result of interpreting the object as an instance of '<em>Unbounded Multiplicity</em>'. | ||
746 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
747 | * @generated | ||
748 | */ | ||
749 | public T caseUnboundedMultiplicity(UnboundedMultiplicity object) { | ||
750 | return null; | ||
751 | } | ||
752 | |||
753 | /** | ||
754 | * Returns the result of interpreting the object as an instance of '<em>Variable Or Node Argument</em>'. | ||
755 | * <!-- begin-user-doc --> | ||
756 | * This implementation returns null; | ||
757 | * returning a non-null result will terminate the switch. | ||
758 | * <!-- end-user-doc --> | ||
759 | * @param object the target of the switch. | ||
760 | * @return the result of interpreting the object as an instance of '<em>Variable Or Node Argument</em>'. | ||
761 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
762 | * @generated | ||
763 | */ | ||
764 | public T caseVariableOrNodeArgument(VariableOrNodeArgument object) { | ||
765 | return null; | ||
766 | } | ||
767 | |||
768 | /** | ||
769 | * Returns the result of interpreting the object as an instance of '<em>Argument</em>'. | ||
770 | * <!-- begin-user-doc --> | ||
771 | * This implementation returns null; | ||
772 | * returning a non-null result will terminate the switch. | ||
773 | * <!-- end-user-doc --> | ||
774 | * @param object the target of the switch. | ||
775 | * @return the result of interpreting the object as an instance of '<em>Argument</em>'. | ||
776 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
777 | * @generated | ||
778 | */ | ||
779 | public T caseArgument(Argument object) { | ||
780 | return null; | ||
781 | } | ||
782 | |||
783 | /** | ||
784 | * Returns the result of interpreting the object as an instance of '<em>Node Assertion Argument</em>'. | ||
785 | * <!-- begin-user-doc --> | ||
786 | * This implementation returns null; | ||
787 | * returning a non-null result will terminate the switch. | ||
788 | * <!-- end-user-doc --> | ||
789 | * @param object the target of the switch. | ||
790 | * @return the result of interpreting the object as an instance of '<em>Node Assertion Argument</em>'. | ||
791 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
792 | * @generated | ||
793 | */ | ||
794 | public T caseNodeAssertionArgument(NodeAssertionArgument object) { | ||
795 | return null; | ||
796 | } | ||
797 | |||
798 | /** | ||
799 | * Returns the result of interpreting the object as an instance of '<em>Assertion Argument</em>'. | ||
800 | * <!-- begin-user-doc --> | ||
801 | * This implementation returns null; | ||
802 | * returning a non-null result will terminate the switch. | ||
803 | * <!-- end-user-doc --> | ||
804 | * @param object the target of the switch. | ||
805 | * @return the result of interpreting the object as an instance of '<em>Assertion Argument</em>'. | ||
806 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
807 | * @generated | ||
808 | */ | ||
809 | public T caseAssertionArgument(AssertionArgument object) { | ||
810 | return null; | ||
811 | } | ||
812 | |||
813 | /** | ||
814 | * Returns the result of interpreting the object as an instance of '<em>Constant Assertion Argument</em>'. | ||
815 | * <!-- begin-user-doc --> | ||
816 | * This implementation returns null; | ||
817 | * returning a non-null result will terminate the switch. | ||
818 | * <!-- end-user-doc --> | ||
819 | * @param object the target of the switch. | ||
820 | * @return the result of interpreting the object as an instance of '<em>Constant Assertion Argument</em>'. | ||
821 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
822 | * @generated | ||
823 | */ | ||
824 | public T caseConstantAssertionArgument(ConstantAssertionArgument object) { | ||
825 | return null; | ||
826 | } | ||
827 | |||
828 | /** | ||
829 | * Returns the result of interpreting the object as an instance of '<em>Node Value Assertion</em>'. | ||
830 | * <!-- begin-user-doc --> | ||
831 | * This implementation returns null; | ||
832 | * returning a non-null result will terminate the switch. | ||
833 | * <!-- end-user-doc --> | ||
834 | * @param object the target of the switch. | ||
835 | * @return the result of interpreting the object as an instance of '<em>Node Value Assertion</em>'. | ||
836 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
837 | * @generated | ||
838 | */ | ||
839 | public T caseNodeValueAssertion(NodeValueAssertion object) { | ||
840 | return null; | ||
841 | } | ||
842 | |||
843 | /** | ||
844 | * Returns the result of interpreting the object as an instance of '<em>Enum Declaration</em>'. | ||
845 | * <!-- begin-user-doc --> | ||
846 | * This implementation returns null; | ||
847 | * returning a non-null result will terminate the switch. | ||
848 | * <!-- end-user-doc --> | ||
849 | * @param object the target of the switch. | ||
850 | * @return the result of interpreting the object as an instance of '<em>Enum Declaration</em>'. | ||
851 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
852 | * @generated | ||
853 | */ | ||
854 | public T caseEnumDeclaration(EnumDeclaration object) { | ||
855 | return null; | ||
856 | } | ||
857 | |||
858 | /** | ||
859 | * Returns the result of interpreting the object as an instance of '<em>Variable Or Node</em>'. | ||
860 | * <!-- begin-user-doc --> | ||
861 | * This implementation returns null; | ||
862 | * returning a non-null result will terminate the switch. | ||
863 | * <!-- end-user-doc --> | ||
864 | * @param object the target of the switch. | ||
865 | * @return the result of interpreting the object as an instance of '<em>Variable Or Node</em>'. | ||
866 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
867 | * @generated | ||
868 | */ | ||
869 | public T caseVariableOrNode(VariableOrNode object) { | ||
870 | return null; | ||
871 | } | ||
872 | |||
873 | /** | ||
874 | * Returns the result of interpreting the object as an instance of '<em>Constant</em>'. | ||
875 | * <!-- begin-user-doc --> | ||
876 | * This implementation returns null; | ||
877 | * returning a non-null result will terminate the switch. | ||
878 | * <!-- end-user-doc --> | ||
879 | * @param object the target of the switch. | ||
880 | * @return the result of interpreting the object as an instance of '<em>Constant</em>'. | ||
881 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
882 | * @generated | ||
883 | */ | ||
884 | public T caseConstant(Constant object) { | ||
885 | return null; | ||
886 | } | ||
887 | |||
888 | /** | ||
889 | * Returns the result of interpreting the object as an instance of '<em>Int Constant</em>'. | ||
890 | * <!-- begin-user-doc --> | ||
891 | * This implementation returns null; | ||
892 | * returning a non-null result will terminate the switch. | ||
893 | * <!-- end-user-doc --> | ||
894 | * @param object the target of the switch. | ||
895 | * @return the result of interpreting the object as an instance of '<em>Int Constant</em>'. | ||
896 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
897 | * @generated | ||
898 | */ | ||
899 | public T caseIntConstant(IntConstant object) { | ||
900 | return null; | ||
901 | } | ||
902 | |||
903 | /** | ||
904 | * Returns the result of interpreting the object as an instance of '<em>Real Constant</em>'. | ||
905 | * <!-- begin-user-doc --> | ||
906 | * This implementation returns null; | ||
907 | * returning a non-null result will terminate the switch. | ||
908 | * <!-- end-user-doc --> | ||
909 | * @param object the target of the switch. | ||
910 | * @return the result of interpreting the object as an instance of '<em>Real Constant</em>'. | ||
911 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
912 | * @generated | ||
913 | */ | ||
914 | public T caseRealConstant(RealConstant object) { | ||
915 | return null; | ||
916 | } | ||
917 | |||
918 | /** | ||
919 | * Returns the result of interpreting the object as an instance of '<em>String Constant</em>'. | ||
920 | * <!-- begin-user-doc --> | ||
921 | * This implementation returns null; | ||
922 | * returning a non-null result will terminate the switch. | ||
923 | * <!-- end-user-doc --> | ||
924 | * @param object the target of the switch. | ||
925 | * @return the result of interpreting the object as an instance of '<em>String Constant</em>'. | ||
926 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
927 | * @generated | ||
928 | */ | ||
929 | public T caseStringConstant(StringConstant object) { | ||
930 | return null; | ||
931 | } | ||
932 | |||
933 | /** | ||
934 | * Returns the result of interpreting the object as an instance of '<em>Constant Argument</em>'. | ||
935 | * <!-- begin-user-doc --> | ||
936 | * This implementation returns null; | ||
937 | * returning a non-null result will terminate the switch. | ||
938 | * <!-- end-user-doc --> | ||
939 | * @param object the target of the switch. | ||
940 | * @return the result of interpreting the object as an instance of '<em>Constant Argument</em>'. | ||
941 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject) | ||
942 | * @generated | ||
943 | */ | ||
944 | public T caseConstantArgument(ConstantArgument object) { | ||
945 | return null; | ||
946 | } | ||
947 | |||
948 | /** | ||
949 | * Returns the result of interpreting the object as an instance of '<em>EObject</em>'. | ||
950 | * <!-- begin-user-doc --> | ||
951 | * This implementation returns null; | ||
952 | * returning a non-null result will terminate the switch, but this is the last case anyway. | ||
953 | * <!-- end-user-doc --> | ||
954 | * @param object the target of the switch. | ||
955 | * @return the result of interpreting the object as an instance of '<em>EObject</em>'. | ||
956 | * @see #doSwitch(org.eclipse.emf.ecore.EObject) | ||
957 | * @generated | ||
958 | */ | ||
959 | @Override | ||
960 | public T defaultCase(EObject object) { | ||
961 | return null; | ||
962 | } | ||
963 | |||
964 | } //ProblemSwitch | ||